Costanti in Objective-C

Sto sviluppando un'applicazione Cocoa e sto usando costanti NSStringcome modi per memorizzare i nomi delle chiavi per le mie preferenze.

Capisco che questa è una buona idea perché consente di cambiare facilmente le chiavi se necessario.
Inoltre, è l'intera nozione "separa i tuoi dati dalla tua logica".

Ad ogni modo, c'è un buon modo per rendere queste costanti definite una volta per l'intera applicazione?

Sono sicuro che esiste un modo semplice e intelligente, ma in questo momento le mie lezioni ridefiniscono quelle che usano.

Dovresti creare un file header simile

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

(puoi usare externinvece che FOUNDATION_EXPORTse il tuo codice non verrà usato in ambienti misti C / C ++ o su altre piattaforme)

È possibile includere questo file in ogni file che utilizza le costanti o nell'intestazione precompilata per il progetto.

Definisci queste costanti in un file .m come

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

Constants.m deve essere aggiunto al target dell'applicazione / framework in modo che sia collegato al prodotto finale.

Il vantaggio di usare costanti di stringa invece di #define'd costanti è che puoi verificare l'uguaglianza usando il confronto puntatore ( stringInstance == MyFirstConstant) che è molto più veloce del confronto di stringhe ( [stringInstance isEqualToString:MyFirstConstant]) (e più facile da leggere, IMO).

Il modo più semplice:

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

Modo migliore:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

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

Un vantaggio del secondo è che la modifica del valore di una costante non provoca una ricostruzione dell'intero programma.

C'è anche una cosa da menzionare. Se hai bisogno di una costante non globale, dovresti usare la staticparola chiave.

Esempio

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

A causa della staticparola chiave, questa const non è visibile al di fuori del file.

Correzione minore di @QuinnTaylor : le variabili statiche sono visibili all'interno di un'unità di compilazione . Di solito, questo è un singolo file .m (come in questo esempio), ma può morderti se lo dichiari in un'intestazione inclusa altrove, poiché dopo la compilazione otterrai errori di linker

La risposta accettata (e corretta) afferma che "è possibile includere questo file [Constants.h] ... nell'intestazione precompilata per il progetto."

Come principiante, ho avuto difficoltà a farlo senza ulteriori spiegazioni - ecco come: Nel tuo file YourAppNameHere-Prefix.pch (questo è il nome predefinito per l'intestazione precompilata in Xcode), importa il tuo Costante.h all'interno del #ifdef __OBJC__blocco .

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

Si noti inoltre che i file Constants.h e Constants.m non devono contenere assolutamente nient'altro al di fuori di ciò che è descritto nella risposta accettata. (Nessuna interfaccia o implementazione).

In genere sto usando il modo pubblicato da Barry Wark e Rahul Gupta.

Anche se non mi piace ripetere le stesse parole in entrambi i file .h e .m. Si noti che nell'esempio seguente la riga è quasi identica in entrambi i file:

// file.h
extern NSString* const MyConst;

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

Pertanto, ciò che mi piace fare è utilizzare alcuni macchinari preprocessore C. Lasciami spiegare con l'esempio.

Ho un file di intestazione che definisce la 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

Nella mia coppia .h / .m in cui desidero definire la costante faccio quanto segue:

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

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

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

et voilà, ho tutte le informazioni sulle costanti solo nel file .h.

Io stesso ho un'intestazione dedicata alla dichiarazione di stringhe NSS costanti utilizzate per le preferenze in questo modo:

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

Quindi dichiarandoli nel file .m di accompagnamento:

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";

Questo approccio mi è servito bene.

Modifica: nota che funziona meglio se le stringhe vengono utilizzate in più file. Se lo utilizza solo un file, puoi farlo #define kNSStringConstant @"Constant NSString"nel file .m che utilizza la stringa.

Una leggera modifica del suggerimento di @Krizz, in modo che funzioni correttamente se il file di intestazione delle costanti deve essere incluso nel PCH, il che è piuttosto normale. Poiché l'originale viene importato nel PCH, non lo ricaricherà nel.m file e quindi non si ottengono simboli e il linker è infelice.

Tuttavia, la seguente modifica consente di funzionare. È un po 'contorto, ma funziona.

Avrete bisogno di 3 file, .hil file che ha le definizioni costanti, il .hfile di e la .mlima, userò ConstantList.h, Constants.he Constants.m, rispettivamente. i contenuti di Constants.hsono semplicemente:

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

e il Constants.mfile appare come:

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

Infine, il ConstantList.hfile contiene le dichiarazioni effettive e questo è tutto:

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

Un paio di cose da notare:

1. Ho dovuto ridefinire la macro nel .mfile dopo #undef averla ing per la macro da utilizzare.

2. Ho dovuto anche usare #includeinvece che #importper farlo funzionare correttamente ed evitare che il compilatore vedesse i valori precedentemente precompilati.

3. Ciò richiederà una ricompilazione del tuo PCH (e probabilmente dell'intero progetto) ogni volta che i valori vengono modificati, il che non accade se vengono separati (e duplicati) normalmente.

Spero che sia utile per qualcuno.

// Prefs.h
extern NSString * const RAHUL;

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

Come ha detto Abizer, potresti inserirlo nel file PCH. Un altro modo che non è così sporco è quello di creare un file include per tutte le tue chiavi e poi includerlo nel file in cui stai usando le chiavi o includerlo nel PCH. Con loro nel loro file include, che almeno ti dà un posto dove cercare e definire tutte queste costanti.

Se vuoi qualcosa come le costanti globali; un modo veloce e sporco è quello di inserire le dichiarazioni costanti nel pchfile.

Prova a utilizzare un metodo di classe:

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

Lo uso a volte.

Se ti piace la costante dello spazio dei nomi, puoi sfruttare la struttura, Venerdì Domande e risposte 2011-08-19: Costanti e funzioni spaziate dai nomi

// 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"
};

Uso una classe singleton, in modo da poter deridere la classe e modificare le costanti se necessario per il test. La classe delle costanti si presenta così:

#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

Ed è usato in questo modo (nota l'uso di una scorciatoia per le costanti c - salva [[Constants alloc] init]ogni volta la digitazione ):

#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 vuoi chiamare qualcosa del genere NSString.newLine;dall'obiettivo c e vuoi che sia costante statica, puoi creare qualcosa del genere in breve tempo:

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

E hai una definizione costante leggibile e disponibile da un tipo di tua scelta mentre lo stile è limitato al contesto del tipo.