Konstanten in Ziel-C

Ich entwickle eine Cocoa- Anwendung und verwende Konstante NSStrings, um Schlüsselnamen für meine Einstellungen zu speichern.

Ich verstehe, dass dies eine gute Idee ist, da es bei Bedarf ein einfaches Wechseln der Schlüssel ermöglicht.
Außerdem ist es der ganze Begriff "Trennen Sie Ihre Daten von Ihrer Logik".

Gibt es eine gute Möglichkeit, diese Konstanten für die gesamte Anwendung einmal zu definieren?

Ich bin mir sicher, dass es einen einfachen und intelligenten Weg gibt, aber im Moment definieren meine Klassen nur die, die sie verwenden.

Sie sollten eine Header-Datei wie erstellen

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

(Sie können externanstelle von verwenden, FOUNDATION_EXPORTwenn Ihr Code nicht in gemischten C / C ++ - Umgebungen oder auf anderen Plattformen verwendet wird.)

Sie können diese Datei in jede Datei aufnehmen, die die Konstanten verwendet, oder in den vorkompilierten Header für das Projekt.

Sie definieren diese Konstanten in einer .m-Datei wie

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

Constants.m sollte dem Ziel Ihrer Anwendung / Ihres Frameworks hinzugefügt werden, damit es mit dem Endprodukt verknüpft wird.

Der Vorteil der Verwendung von Zeichenfolgenkonstanten anstelle von #define'd-Konstanten besteht darin, dass Sie die Gleichheit mithilfe des Zeigervergleichs ( stringInstance == MyFirstConstant) testen können, der viel schneller als der Zeichenfolgenvergleich ( [stringInstance isEqualToString:MyFirstConstant]) ist (und einfacher zu lesen ist, IMO).

Einfachster Weg:

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

Besserer Weg:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

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

Ein Vorteil des zweiten ist, dass das Ändern des Werts einer Konstante nicht zu einer Neuerstellung Ihres gesamten Programms führt.

Es gibt auch eine Sache zu erwähnen. Wenn Sie eine nicht globale Konstante benötigen, sollten Sie das staticSchlüsselwort verwenden.

Beispiel

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

Aufgrund des staticSchlüsselworts ist diese Konstante außerhalb der Datei nicht sichtbar.

Kleinere Korrektur durch @QuinnTaylor : Statische Variablen sind in einer Kompilierungseinheit sichtbar . Normalerweise ist dies eine einzelne .m-Datei (wie in diesem Beispiel), aber sie kann Sie beißen, wenn Sie sie in einem Header deklarieren, der an anderer Stelle enthalten ist, da nach dem Kompilieren Linkerfehler auftreten

Die akzeptierte (und korrekte) Antwort lautet: "Sie können diese [Constants.h] -Datei ... in den vorkompilierten Header für das Projekt aufnehmen."

Als Anfänger hatte ich Schwierigkeiten, dies ohne weitere Erklärung zu tun - so geht's: Importieren Sie in Ihrer YourAppNameHere-Prefix.pch-Datei (dies ist der Standardname für den vorkompilierten Header in Xcode) Ihre Constants.h in den #ifdef __OBJC__Block .

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

Beachten Sie auch, dass die Dateien Constants.h und Constants.m absolut nichts anderes enthalten sollten als das, was in der akzeptierten Antwort beschrieben ist. (Keine Schnittstelle oder Implementierung).

Ich benutze im Allgemeinen den Weg von Barry Wark und Rahul Gupta.

Obwohl ich es nicht mag, die gleichen Wörter sowohl in der .h- als auch in der .m-Datei zu wiederholen. Beachten Sie, dass im folgenden Beispiel die Zeile in beiden Dateien nahezu identisch ist:

// file.h
extern NSString* const MyConst;

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

Daher verwende ich gerne einige C-Präprozessor-Maschinen. Lassen Sie mich anhand des Beispiels erklären.

Ich habe eine Header-Datei, die das Makro definiert 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

In meinem .h / .m-Paar, in dem ich die Konstante definieren möchte, mache ich Folgendes:

// 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, ich habe alle Informationen über die Konstanten nur in der .h-Datei.

Ich selbst habe einen Header, der dazu dient, konstante NSStrings zu deklarieren, die für folgende Einstellungen verwendet werden:

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

Dann deklarieren Sie sie in der zugehörigen .m-Datei:

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

Dieser Ansatz hat mir gute Dienste geleistet.

Bearbeiten: Beachten Sie, dass dies am besten funktioniert, wenn die Zeichenfolgen in mehreren Dateien verwendet werden. Wenn nur eine Datei es verwendet, können Sie dies einfach #define kNSStringConstant @"Constant NSString"in der .m-Datei tun , die die Zeichenfolge verwendet.

Eine geringfügige Änderung des Vorschlags von @Krizz, damit er ordnungsgemäß funktioniert, wenn die Konstanten-Header-Datei in den PCH aufgenommen werden soll, was eher normal ist. Da das Original in den PCH importiert wird, wird es nicht erneut in den PCH geladen.m Datei sodass Sie keine Symbole erhalten und der Linker unglücklich ist.

Mit der folgenden Änderung kann es jedoch funktionieren. Es ist ein bisschen verworren, aber es funktioniert.

Sie benötigen drei Dateien, .hDatei , die die Konstanten - Definitionen, die hat .hDatei und die .mDatei, werde ich verwenden ConstantList.h, Constants.hund Constants.m, respectively. Der Inhalt von Constants.hist einfach:

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

und die Constants.mDatei sieht aus wie:

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

Schließlich enthält die ConstantList.hDatei die tatsächlichen Deklarationen und das ist alles:

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

Ein paar Dinge zu beachten:

1. Ich musste das Makro in der .mDatei neu definieren, nachdem ich #undefes für das zu verwendende Makro verwendet hatte.

2. Ich musste #includestattdessen auch verwenden, #importdamit dies richtig funktioniert und der Compiler die zuvor vorkompilierten Werte nicht sieht.

3. Dies erfordert eine Neukompilierung Ihres PCH (und wahrscheinlich des gesamten Projekts), wenn Werte geändert werden. Dies ist nicht der Fall, wenn sie wie gewohnt getrennt (und dupliziert) werden.

Hoffe das ist hilfreich für jemanden.

// Prefs.h
extern NSString * const RAHUL;

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

Wie Abizer sagte, könnten Sie es in die PCH-Datei einfügen. Eine andere Möglichkeit, die nicht so schmutzig ist, besteht darin, eine Include-Datei für alle Ihre Schlüssel zu erstellen und diese dann entweder in die Datei aufzunehmen, in der Sie die Schlüssel verwenden, oder sie in den PCH aufzunehmen. Wenn Sie sie in ihrer eigenen Include-Datei haben, haben Sie mindestens einen Ort, an dem Sie alle diese Konstanten suchen und definieren können.

Wenn Sie so etwas wie globale Konstanten wollen; Ein schneller und schmutziger Weg besteht darin, die konstanten Deklarationen in die pchDatei einzufügen.

Versuchen Sie es mit einer Klassenmethode:

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

Ich benutze es manchmal.

Wenn Sie eine Namespace-Konstante mögen, können Sie struct nutzen. Freitag, Fragen und Antworten 2011-08-19: Namespaced-Konstanten und -Funktionen

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

Ich verwende eine Singleton-Klasse, damit ich die Klasse verspotten und die Konstanten bei Bedarf zum Testen ändern kann. Die Konstantenklasse sieht folgendermaßen aus:

#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

Und es wird so verwendet (beachten Sie die Verwendung einer Kurzform für die Konstanten c - es spart [[Constants alloc] init]jedes Mal die Eingabe ):

#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

Wenn Sie so etwas NSString.newLine;von Ziel c aus aufrufen möchten und möchten, dass es statisch konstant ist, können Sie so etwas in Kürze erstellen:

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

Und Sie haben eine gut lesbare Konstantendefinition, die innerhalb eines Typs Ihrer Wahl verfügbar ist, während der Stil an den Kontext des Typs gebunden ist.