Constantes no Objective-C

Estou desenvolvendo um aplicativo Cocoa e estou usando constantes NSStrings como formas de armazenar nomes-chave para minhas preferências.

Entendo que é uma boa ideia, pois permite a troca fácil de chaves, se necessário.
Além disso, é toda a noção de 'separar seus dados da sua lógica'.

Enfim, existe uma boa maneira de definir essas constantes uma vez para todo o aplicativo?

Tenho certeza de que existe uma maneira fácil e inteligente, mas agora minhas aulas redefinem as que eles usam.

Você deve criar um arquivo de cabeçalho como

// Constants.h
FOUNDATION_EXPORT NSString *const MyFirstConstant;
FOUNDATION_EXPORT NSString *const MySecondConstant;
//etc.

(você pode usar, em externvez de, FOUNDATION_EXPORTse seu código não for usado em ambientes C / C ++ mistos ou em outras plataformas)

Você pode incluir esse arquivo em cada arquivo que usa as constantes ou no cabeçalho pré-compilado do projeto.

Você define essas constantes em um arquivo .m como

// Constants.m
NSString *const MyFirstConstant = @"FirstConstant";
NSString *const MySecondConstant = @"SecondConstant";

Constants.m deve ser adicionado ao destino do aplicativo / estrutura para que ele seja vinculado ao produto final.

A vantagem de usar constantes de string em vez de #defineconstantes é que você pode testar a igualdade usando a comparação de ponteiro ( stringInstance == MyFirstConstant), que é muito mais rápida que a comparação de string ( [stringInstance isEqualToString:MyFirstConstant]) (e mais fácil de ler, IMO).

Caminho mais fácil:

// Prefs.h
#define PREFS_MY_CONSTANT @"prefs_my_constant"

Melhor maneira:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

// Prefs.m
NSString * const PREFS_MY_CONSTANT = @"prefs_my_constant";

Um benefício do segundo é que alterar o valor de uma constante não causa uma reconstrução de todo o programa.

Há também uma coisa a mencionar. Se você precisar de uma constante não global, use a staticpalavra-chave

Exemplo

// In your *.m file
static NSString * const kNSStringConst = @"const value";

Por causa da staticpalavra - chave, essa const não é visível fora do arquivo.

Correção menor por @QuinnTaylor : variáveis ​​estáticas são visíveis em uma unidade de compilação . Geralmente, esse é um único arquivo .m (como neste exemplo), mas pode ser mordido se você o declarar em um cabeçalho incluído em outro lugar, pois você receberá erros de vinculador após a compilação

A resposta aceita (e correta) diz que "você pode incluir esse arquivo [Constants.h] ... no cabeçalho pré-compilado do projeto".

Como iniciante, tive dificuldade em fazer isso sem maiores explicações - veja como: No arquivo YourAppNameHere-Prefix.pch (este é o nome padrão do cabeçalho pré-compilado no Xcode), importe seu Constants.h dentro do #ifdef __OBJC__bloco .

#ifdef __OBJC__
  #import <UIKit/UIKit.h>
  #import <Foundation/Foundation.h>
  #import "Constants.h"
#endif

Observe também que os arquivos Constants.h e Constants.m não devem conter absolutamente mais nada, exceto o que está descrito na resposta aceita. (Sem interface ou implementação).

Geralmente estou usando o caminho postado por Barry Wark e Rahul Gupta.

Embora eu não goste de repetir as mesmas palavras nos arquivos .he .m. Observe que no exemplo a seguir a linha é quase idêntica nos dois arquivos:

// file.h
extern NSString* const MyConst;

//file.m
NSString* const MyConst = @"Lorem ipsum";

Portanto, o que eu gosto de fazer é usar algumas máquinas do pré-processador C. Deixe-me explicar através do exemplo.

Eu tenho um arquivo de cabeçalho que define a macro STR_CONST(name, value):

// StringConsts.h
#ifdef SYNTHESIZE_CONSTS
# define STR_CONST(name, value) NSString* const name = @ value
#else
# define STR_CONST(name, value) extern NSString* const name
#endif

No meu par .h / .m, onde desejo definir a constante, faço o seguinte:

// myfile.h
#import <StringConsts.h>

STR_CONST(MyConst, "Lorem Ipsum");
STR_CONST(MyOtherConst, "Hello world");

// myfile.m
#define SYNTHESIZE_CONSTS
#import "myfile.h"

et voila, eu tenho todas as informações sobre as constantes no arquivo .h.

Eu próprio tenho um cabeçalho dedicado a declarar constantes NSStrings usadas para preferências como:

extern NSString * const PPRememberMusicList;
extern NSString * const PPLoadMusicAtListLoad;
extern NSString * const PPAfterPlayingMusic;
extern NSString * const PPGotoStartupAfterPlaying;

Em seguida, declare-os no arquivo .m que acompanha:

NSString * const PPRememberMusicList = @"Remember Music List";
NSString * const PPLoadMusicAtListLoad = @"Load music when loading list";
NSString * const PPAfterPlayingMusic = @"After playing music";
NSString * const PPGotoStartupAfterPlaying = @"Go to startup pos. after playing";

Essa abordagem me serviu bem.

Editar: Observe que isso funciona melhor se as strings forem usadas em vários arquivos. Se apenas um arquivo o usar, você poderá fazê-lo #define kNSStringConstant @"Constant NSString"no arquivo .m que usa a string.

Uma leve modificação na sugestão do @Krizz, para que funcione corretamente se o arquivo de cabeçalho das constantes for incluído na PCH, o que é bastante normal. Como o original é importado para a PCH, ele não será recarregado no .marquivo e, portanto, você não recebe símbolos e o vinculador está descontente.

No entanto, a seguinte modificação permite que ele funcione. É um pouco complicado, mas funciona.

Você vai precisar de 3 arquivos, .harquivo que tem as definições constantes, o .harquivo e o .marquivo, eu vou usar ConstantList.h, Constants.he Constants.m, respectivamente. o conteúdo de Constants.hsão simplesmente:

// Constants.h
#define STR_CONST(name, value) extern NSString* const name
#include "ConstantList.h"

e o Constants.marquivo se parece com:

// Constants.m
#ifdef STR_CONST
    #undef STR_CONST
#endif
#define STR_CONST(name, value) NSString* const name = @ value
#include "ConstantList.h"

Finalmente, o ConstantList.harquivo possui as declarações reais e isso é tudo:

// ConstantList.h
STR_CONST(kMyConstant, "Value");
…

Algumas coisas a serem observadas:

1. Eu tive que redefinir a macro no .marquivo após #undef inseri-la na macro a ser usada.

2. Eu também tive que usar em #includevez disso #importpara que funcionasse corretamente e evitar que o compilador visse os valores pré-compilados anteriormente.

3. Isso exigirá uma recompilação do seu PCH (e provavelmente todo o projeto) sempre que quaisquer valores forem alterados, o que não acontece se forem separados (e duplicados) normalmente.

Espero que seja útil para alguém.

// Prefs.h
extern NSString * const RAHUL;

// Prefs.m
NSString * const RAHUL = @"rahul";

Como a Abizer disse, você pode colocá-lo no arquivo PCH. Outra maneira que não é tão suja é criar um arquivo de inclusão para todas as suas chaves e depois incluir no arquivo em que você está usando as chaves ou incluí-lo na PCH. Com eles em seu próprio arquivo de inclusão, isso fornece pelo menos um lugar para procurar e definir todas essas constantes.

Se você deseja algo como constantes globais; Uma maneira rápida e suja é colocar as constantes declarações no pcharquivo.

Tente usar um método de classe:

+(NSString*)theMainTitle
{
    return @"Hello World";
}

Eu uso algumas vezes.

Se você gosta de constante de espaço para nome, pode aproveitar struct, sexta-feira , P&R 19-08-2011: Constantes e funções com espaço para nome

// in the header
extern const struct MANotifyingArrayNotificationsStruct
{
    NSString *didAddObject;
    NSString *didChangeObject;
    NSString *didRemoveObject;
} MANotifyingArrayNotifications;

// in the implementation
const struct MANotifyingArrayNotificationsStruct MANotifyingArrayNotifications = {
    .didAddObject = @"didAddObject",
    .didChangeObject = @"didChangeObject",
    .didRemoveObject = @"didRemoveObject"
};

Eu uso uma classe singleton, para que eu possa zombar da classe e alterar as constantes, se necessário para o teste. A classe constantes fica assim:

#import <Foundation/Foundation.h>

@interface iCode_Framework : NSObject

@property (readonly, nonatomic) unsigned int iBufCapacity;
@property (readonly, nonatomic) unsigned int iPort;
@property (readonly, nonatomic) NSString * urlStr;

@end

#import "iCode_Framework.h"

static iCode_Framework * instance;

@implementation iCode_Framework

@dynamic iBufCapacity;
@dynamic iPort;
@dynamic urlStr;

- (unsigned int)iBufCapacity
{
    return 1024u;
};

- (unsigned int)iPort
{
    return 1978u;
};

- (NSString *)urlStr
{
    return @"localhost";
};

+ (void)initialize
{
    if (!instance) {
        instance = [[super allocWithZone:NULL] init];
    }
}

+ (id)allocWithZone:(NSZone * const)notUsed
{
    return instance;
}

@end

E é usado assim (observe o uso de uma abreviação para as constantes c - ele salva a digitação [[Constants alloc] init]toda vez):

#import "iCode_FrameworkTests.h"
#import "iCode_Framework.h"

static iCode_Framework * c; // Shorthand

@implementation iCode_FrameworkTests

+ (void)initialize
{
    c  = [[iCode_Framework alloc] init]; // Used like normal class; easy to mock!
}

- (void)testSingleton
{
    STAssertNotNil(c, nil);
    STAssertEqualObjects(c, [iCode_Framework alloc], nil);
    STAssertEquals(c.iBufCapacity, 1024u, nil);
}

@end

Se você deseja chamar algo assim a NSString.newLine;partir do objetivo c e deseja que seja constante estática, é possível criar algo assim rapidamente:

public extension NSString {
    @objc public static let newLine = "\n"
}

E você tem uma definição constante legível e disponível em um tipo de sua escolha enquanto o estilo é limitado ao contexto do tipo.