Constantes dans Objective-C

Je suis en train de développer une application Cocoa et j'utilise des NSStrings constants comme moyen de stocker des noms de clés pour mes préférences.

Je comprends que c'est une bonne idée car elle permet de changer facilement les clés si nécessaire.
De plus, c'est toute la notion de «séparer vos données de votre logique».

Quoi qu'il en soit, existe-t-il un bon moyen de définir ces constantes une fois pour l'ensemble de l'application?

Je suis sûr qu'il existe un moyen simple et intelligent, mais pour l'instant mes cours redéfinissent ceux qu'ils utilisent.

Vous devez créer un fichier d'en-tête comme

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

(vous pouvez utiliser à la externplace de FOUNDATION_EXPORTsi votre code ne sera pas utilisé dans des environnements mixtes C / C ++ ou sur d'autres plates-formes)

Vous pouvez inclure ce fichier dans chaque fichier qui utilise les constantes ou dans l'en-tête précompilé du projet.

Vous définissez ces constantes dans un fichier .m comme

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

Constants.m doit être ajouté à la cible de votre application / framework afin qu'il soit lié au produit final.

L'avantage d'utiliser des constantes de chaîne au lieu de constantes #define'd est que vous pouvez tester l'égalité en utilisant la comparaison de pointeurs ( stringInstance == MyFirstConstant) qui est beaucoup plus rapide que la comparaison de chaînes ( [stringInstance isEqualToString:MyFirstConstant]) (et plus facile à lire, IMO).

Manière la plus simple:

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

Meilleure façon:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

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

L'un des avantages de la seconde est que la modification de la valeur d'une constante n'entraîne pas une reconstruction de l'ensemble de votre programme.

Il y a aussi une chose à mentionner. Si vous avez besoin d'une constante non globale, vous devez utiliser un staticmot-clé.

Exemple

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

En raison du staticmot clé, cette constante n'est pas visible en dehors du fichier.

Correction mineure par @QuinnTaylor : les variables statiques sont visibles dans une unité de compilation . Habituellement, il s'agit d'un seul fichier .m (comme dans cet exemple), mais il peut vous mordre si vous le déclarez dans un en-tête qui est inclus ailleurs, car vous obtiendrez des erreurs de l'éditeur de liens après la compilation

La réponse acceptée (et correcte) indique que "vous pouvez inclure ce fichier [Constants.h] ... dans l'en-tête précompilé du projet".

En tant que novice, j'ai eu du mal à le faire sans autre explication - voici comment: dans votre fichier YourAppNameHere-Prefix.pch (c'est le nom par défaut pour l'en-tête précompilé dans Xcode), importez votre Constants.h à l'intérieur du #ifdef __OBJC__bloc .

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

Notez également que les fichiers Constants.h et Constants.m ne doivent contenir absolument rien d'autre, sauf ce qui est décrit dans la réponse acceptée. (Aucune interface ou implémentation).

J'utilise généralement la manière affichée par Barry Wark et Rahul Gupta.

Cependant, je n'aime pas répéter les mêmes mots dans les fichiers .h et .m. Notez que dans l'exemple suivant, la ligne est presque identique dans les deux fichiers:

// file.h
extern NSString* const MyConst;

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

Par conséquent, ce que j'aime faire est d'utiliser des machines de préprocesseur C. Permettez-moi de vous expliquer à travers l'exemple.

J'ai un fichier d'en-tête qui définit 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

Dans ma paire .h / .m où je veux définir la constante, je fais ce qui suit:

// 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, j'ai toutes les informations sur les constantes dans le fichier .h uniquement.

J'ai moi-même un en-tête dédié à la déclaration des NSStrings constants utilisés pour les préférences comme ceci:

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

Puis en les déclarant dans le fichier .m joint:

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

Cette approche m'a bien servi.

Modifier: notez que cela fonctionne mieux si les chaînes sont utilisées dans plusieurs fichiers. Si un seul fichier l'utilise, vous pouvez simplement le faire #define kNSStringConstant @"Constant NSString"dans le fichier .m qui utilise la chaîne.

Une légère modification de la suggestion de @Krizz, pour qu'elle fonctionne correctement si le fichier d'en-tête des constantes doit être inclus dans le PCH, ce qui est plutôt normal. Étant donné que l'original est importé dans le PCH, il ne le rechargera pas dans le .mfichier et donc vous n'obtiendrez aucun symbole et l'éditeur de liens est mécontent.

Cependant, la modification suivante lui permet de fonctionner. C'est un peu compliqué, mais ça marche.

Vous aurez besoin de 3 fichiers, .hfichier qui a les définitions constantes, le .hfichier et le .mfichier, je vais utiliser ConstantList.h, Constants.het Constants.m, respectivement. le contenu de Constants.hest simplement:

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

et le Constants.mfichier ressemble à:

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

Enfin, le ConstantList.hfichier contient les déclarations réelles et c'est tout:

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

Quelques points à noter:

1. J'ai dû redéfinir la macro dans le .mfichier après l'avoir #undef ing pour que la macro soit utilisée.

2. J'ai également dû utiliser #includeau lieu de #importpour que cela fonctionne correctement et éviter que le compilateur ne voie les valeurs précédemment précompilées.

3. Cela nécessitera une recompilation de votre PCH (et probablement de l'ensemble du projet) chaque fois que des valeurs sont modifiées, ce qui n'est pas le cas si elles sont séparées (et dupliquées) comme d'habitude.

J'espère que cela est utile pour quelqu'un.

// Prefs.h
extern NSString * const RAHUL;

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

Comme l'a dit Abizer, vous pouvez le mettre dans le fichier PCH. Une autre façon qui n'est pas si sale est de créer un fichier d'inclusion pour toutes vos clés, puis de l'inclure dans le fichier dans lequel vous utilisez les clés ou de l'inclure dans le PCH. Avec eux dans leur propre fichier include, cela vous donne au moins un endroit pour rechercher et définir toutes ces constantes.

Si vous voulez quelque chose comme des constantes globales; un moyen rapide et sale est de mettre les déclarations constantes dans le pchfichier.

Essayez d'utiliser une méthode de classe:

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

Je l'utilise parfois.

Si vous aimez la constante d'espace de noms, vous pouvez tirer parti de struct, Friday Q&A 2011-08-19: Constantes et fonctions d'espaces de noms

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

J'utilise une classe singleton, afin de pouvoir me moquer de la classe et modifier les constantes si nécessaire pour les tests. La classe des constantes ressemble à ceci:

#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

Et il est utilisé comme ceci (notez l'utilisation d'un raccourci pour les constantes c - il enregistre la frappe à [[Constants alloc] init]chaque fois):

#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

Si vous voulez appeler quelque chose comme ça à NSString.newLine;partir de l'objectif c et que vous voulez que ce soit une constante statique, vous pouvez créer quelque chose comme ça dans swift:

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

Et vous avez une belle définition constante lisible, et disponible à partir d'un type de votre choix tout en étant limité au contexte du type.