Objective-C 中的常量

Question

我正在开发一个 Cocoa 应用程序，并且我正在使用常量 NSString 是根据我的喜好存储键名的方法。

我知道这是一个好主意，因为它可以在必要时轻松更改密钥。
另外，这就是“将数据与逻辑分开”的整个概念。

无论如何，有没有一个好的方法可以让这些常量为整个应用程序定义一次？

我确信有一种简单而智能的方法，但现在我的课程只是重新定义了他们使用的方法。

Answer 1

应该创建一个像这样的头文件：（

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

如果您的代码不会在混合 C/C++ 环境或其他平台上使用，则可以使用 extern 而不是 FOUNDATION_EXPORT。）

您 可以将此文件包含在使用常量的每个文件中或项目的预编译头中。

您可以在 .m 文件中定义这些常量，例如：

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

Constants.m 应添加到您的应用程序/框架的目标中，以便将其链接到最终产品。

使用字符串常量而不是 #define 的常量的优点是，您可以使用指针比较 (stringInstance == MyFirstConstant) 来测试相等性，这比字符串比较快得多([stringInstance isEqualToString:MyF​​irstConstant]) （并且更易于阅读，IMO）。

Answer 2

最简单的方法：

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

更好的方法：

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

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

第二种方法的好处之一是更改常量的值不会导致整个程序的重建。

Answer 3

还有一点值得一提。 如果你需要一个非全局常量，你应该使用static关键字。

示例

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

由于 static 关键字，此常量在文件外部不可见。

---

由@QuinnTaylor进行的小修正：静态变量在编译单元中可见 。 通常，这是一个单个 .m 文件（如本例所示），但如果您在其他地方包含的标头中声明它，它可能会困扰您，因为编译后您将收到链接器错误

Answer 4

接受的（正确的）答案是“您可以包含这个 [Constants.h] 文件......在项目的预编译头中。”

作为一个新手，如果没有进一步的解释，我很难做到这一点 - 方法如下：在 YourAppNameHere-Prefix.pch 文件（这是 Xcode 中预编译标头的默认名称）中，将 Constants.h 导入到 <代码>#ifdef __OBJC__ 块。

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

另请注意，除了接受的答案中描述的内容之外，Constants.h 和 Constants.m 文件中绝对不应包含任何其他内容。 （没有接口或实现）。

Answer 5

我通常使用 Barry Wark 和 Rahul Gupta 发布的方式。

虽然，我不喜欢在 .h 和 .m 文件中重复相同的单词。
请注意，在下面的示例中，两个文件中的行几乎相同：

// file.h
extern NSString* const MyConst;

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

因此，我喜欢做的是使用一些 C 预处理器机制。
让我通过例子来解释一下。

我有一个定义宏 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

在我的 .h/.m 对中，我想定义常量，我执行以下操作：

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

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

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

等瞧，我拥有所有仅有关 .h 文件中常量的信息。

Answer 6

我自己有一个标头，专门用于声明用于首选项的常量 NSString，如下所示：

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

然后在随附的 .m 文件中声明它们：

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

这种方法对我很有帮助。

编辑：请注意，如果在多个文件中使用字符串，则此方法效果最佳。 如果只有一个文件使用它，则只需在使用该字符串的 .m 文件中执行 #define kNSStringConstant @"Constant NSString" 即可。

Answer 7

对@Krizz的建议稍加修改，这样如果常量头文件包含在PCH中，它就可以正常工作，这是相当正常的。 由于原始文件被导入到 PCH 中，因此它不会将其重新加载到 .m 文件中，因此您不会得到任何符号，并且链接器会不满意。

但是，以下修改使其可以工作。 这有点复杂，但它有效。

您将需要 3 个文件：包含常量定义的 .h 文件、.h 文件和 .m 文件，我将分别使用 ConstantList.h、Constants.h 和 Constants.m。 Constants.h 的内容很简单：

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

Constants.m 文件如下所示：

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

最后，ConstantList.h 文件具有实际的声明这就是全部：

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

需要注意的几件事：

1. 我必须在.m文件之后重新定义宏#undef将其设置为要使用的宏。

2. 我还必须使用 #include 而不是 #import 才能正常工作并避免编译器看到之前的预编译值。

3. 每当任何值发生更改时，这都需要重新编译您的 PCH（可能还包括整个项目），如果它们正常分离（和重复），则情况并非如此。

希望这对某人有帮助。

Answer 8

// Prefs.h
extern NSString * const RAHUL;

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

Answer 9

正如 Abizer 所说，您可以将其放入 PCH 文件中。 另一种不太脏的方法是为所有密钥创建一个包含文件，然后将其包含在您正在使用密钥的文件中，或者将其包含在 PCH 中。 将它们放在自己的包含文件中，这至少为您提供了一个位置来查找和定义所有这些常量。

Answer 10

如果你想要全局常量之类的东西； 一种快速但肮脏的方法是将常量声明放入 pch 文件中。

Answer 11

如果您喜欢命名空间常量，则可以利用结构， 星期五问答 2011-08-19：命名空间常量和函数

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

Answer 12

尝试使用类方法：

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

我有时会使用它。

Answer 13

我使用单例类，以便我可以模拟该类并在测试需要时更改常量。 常量类看起来像这样：

#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

它的使用方式如下（注意使用常量 c 的简写 - 它可以节省每次键入 [[Constants alloc] init] 的次数）：

#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

Answer 14

如果你想从 Objective c 调用类似 NSString.newLine; 的东西，并且你希望它是静态常量，你可以在 swift 中创建类似这样的东西：

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

你有很好的可读常量定义，并且可从您选择的类型中使用，同时又受类型上下文的限制。