在 iOS 应用程序中在哪里存储全局常量？

Where to store global constants in an iOS application?

提问by JoJo

Most of the models in my iOS app query a web server. I would like to have a configuration file storing the base URL of the server. It will look something like this:

我的 iOS 应用程序中的大多数模型都会查询网络服务器。我想要一个存储服务器基本 URL 的配置文件。它看起来像这样：

// production
// static NSString* const baseUrl = "http://website.com/"

// testing
static NSString* const baseUrl = "http://192.168.0.123/"

By commenting out one line or the other, I can instantly change which server my models point to. My question is, what's the best practice for storing global constants in iOS? In Android programming, we have this built-in strings resource file. In any Activity(the equivalent of a UIViewController), we can retrieve those string constants with:

通过注释掉一行或另一行，我可以立即更改我的模型指向的服务器。我的问题是，在 iOS 中存储全局常量的最佳实践是什么？在 Android 编程中，我们有这个内置的字符串资源文件。在任何Activity（相当于UIViewController）中，我们可以通过以下方式检索这些字符串常量：

String string = this.getString(R.string.someConstant);

I was wondering if the iOS SDK has an analogous place to store constants. If not, what is the best practice in Objective-C to do so?

我想知道 iOS SDK 是否有类似的地方来存储常量。如果没有，Objective-C 中这样做的最佳实践是什么？

回答by justin

Well, you want the declaration local to the interfaces it relates to -- the app-wide constants file is not a good thing.

好吧，您希望声明是与它相关的接口的本地声明——应用程序范围的常量文件不是一件好事。

As well, it's preferable to simply declare an extern NSString* constsymbol, rather than use a #define:

同样，最好简单地声明一个extern NSString* const符号，而不是使用 a #define：

---

---

SomeFile.h

一些文件

extern NSString* const MONAppsBaseUrl;

SomeFile.m

一些文件

#import "SomeFile.h"

#ifdef DEBUG
NSString* const MONAppsBaseUrl = @"http://192.168.0.123/";
#else
NSString* const MONAppsBaseUrl = @"http://website.com/";
#endif

---

---

Apart from the omission of the C++ compatible Extern declaration, this is what you will generally see used in Apple's Obj-C frameworks.

除了省略与 C++ 兼容的 Extern 声明之外，这就是您通常会在 Apple 的 Obj-C 框架中看到的内容。

If the constant needs to be visible to just one file or function, then static NSString* const baseUrlin your *.mis good.

如果常量只需要对一个文件或函数可见，那么static NSString* const baseUrlin your*.m是好的。

回答by Cyrille

You could also do a

你也可以做一个

#define kBaseURL @"http://192.168.0.123/"

in a "constants" header file, say constants.h. Then do

在“常量”头文件中，比如constants.h. 然后做

#include "constants.h"

at the top of every file where you need this constant.

在您需要此常量的每个文件的顶部。

This way, you can switch between servers depending on compiler flags, as in:

这样，您可以根据编译器标志在服务器之间切换，如下所示：

#ifdef DEBUG
    #define kBaseURL @"http://192.168.0.123/"
#else
    #define kBaseURL @"http://myproductionserver.com/"
#endif

回答by Piotr Tomasik

The way I define global constants:

我定义全局常量的方式：

---

---

AppConstants.h

应用常量.h

extern NSString* const kAppBaseURL;

AppConstants.m

AppConstants.m

#import "AppConstants.h"

#ifdef DEBUG
NSString* const kAppBaseURL = @"http://192.168.0.123/";
#else
NSString* const kAppBaseURL = @"http://website.com/";
#endif

---

---

Then in your {$APP}-Prefix.pch file:

然后在您的 {$APP}-Prefix.pch 文件中：

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

If you experience any problems, first make sure that you have the Precompile Prefix Header option set to NO.

如果遇到任何问题，请首先确保将 Precompile Prefix Header 选项设置为 NO。

回答by Martin Reichl

You can also concatenate string constants like this:

您还可以像这样连接字符串常量：

  #define kBaseURL @"http://myServer.com"
  #define kFullURL kBaseURL @"/api/request"

回答by Vladimir Despotovic

I do think that another way to do this is far simpler and you will just include it in files you need them included in, not ALL the files, like with the .pch prefix file:

我确实认为另一种方法要简单得多，您只需将其包含在需要包含的文件中，而不是所有文件中，例如 .pch 前缀文件：

#ifndef Constants_h
#define Constants_h

//Some constants
static int const ZERO = 0;
static int const ONE = 1;
static int const TWO = 2;

#endif /* Constants_h */

After that you include this header file in the header file that you want. You include it in header file for the specific class that you want it included in:

之后，您将此头文件包含在所需的头文件中。您将它包含在要包含在其中的特定类的头文件中：

#include "Constants.h"

回答by Yogesh Lolusare

1. I define global constant in YOURPROJECT-Prefix.pch file.
2. #define BASEURl @"http://myWebService.appspot.com/xyz/xx"

3. then anywhere in project to use BASEURL:

   NSString *LOGIN_URL= [BASEURl stringByAppendingString:@"/users/login"];
   

1. 我在 YOURPROJECT-Prefix.pch 文件中定义了全局常量。
2. #define BASEURl @"http://myWebService.appspot.com/xyz/xx"

3. 然后在项目中的任何地方使用 BASEURL：

   NSString *LOGIN_URL= [BASEURl stringByAppendingString:@"/users/login"];
   

Updated: In Xcode 6 you will not find default .pch file created in your project. So please use PCH File in Xcode 6to insert .pch file in your project.

更新：在 Xcode 6 中，您将找不到在项目中创建的默认 .pch 文件。所以请在 Xcode 6 中使用PCH File在你的项目中插入 .pch 文件。

Updates: For SWIFT

更新：对于 SWIFT

1. Create new Swift file [empty without class] say [AppGlobalMemebers]

2. & Right away declare / define member

   Example:

   var STATUS_BAR_GREEN : UIColor  = UIColor(red: 106/255.0, green: 161/255.0, blue: 7/255.0, alpha: 1)  //
   

   3. If you want to define the app global member in any class file say Appdelegate or Singleton class or any, declare given member above class definition

1. 创建新的 Swift 文件 [empty without class] 说 [AppGlobalMemebers]

2. & 马上声明/定义成员

   例子：

   var STATUS_BAR_GREEN : UIColor  = UIColor(red: 106/255.0, green: 161/255.0, blue: 7/255.0, alpha: 1)  //
   

   3. 如果要在任何类文件中定义应用程序全局成员，例如 Appdelegate 或 Singleton 类或任何，请在类定义上方声明给定成员

回答by Gregtheitroade Mulliez

Global declarations are interesting but, for me, what changed deeply my way to code was to have global instances of classes. It took me a couple of day's to really understand how to work with it so I quickly summarized it here

全局声明很有趣，但对我来说，深刻改变了我的编码方式的是拥有类的全局实例。我花了几天的时间才真正理解如何使用它，所以我在这里快速总结了它

I use global instances of classes (1 or 2 per project, if needed), to regroup core data access, or some trades logics.

我使用类的全局实例（每个项目 1 或 2 个，如果需要），重新组合核心数据访问或一些交易逻辑。

For instance if you want to have a central object handling all restaurant tables you create you object at startup and that is it. This object can handle database accesses OR handle it in memory if you don't need to save it. It's centralized, you show only useful interfaces ... !

例如，如果您想让一个中央对象处理您在启动时创建的所有餐厅餐桌，就是这样。如果您不需要保存它，则此对象可以处理数据库访问或在内存中处理它。它是集中式的，您只显示有用的界面......！

It's a great help, object oriented and a good way to get all you stuff at the same place

这是一个很大的帮助，面向对象，是将所有东西放在同一个地方的好方法

A few lines of code :

几行代码：

@interface RestaurantManager : NSObject
    +(id) sharedInstance;
    -(void)registerForTable:(NSNumber *)tableId;
@end 

and object implementation :

和对象实现：

@implementation RestaurantManager

+ (id) sharedInstance {
    static dispatch_once_t onceQueue;

    dispatch_once(&onceQueue, ^{
        sharedInstance = [[self alloc] init];
        NSLog(@"*** Shared instance initialisation ***");
    });
    return sharedInstance;
}

-(void)registerForTable:(NSNumber *)tableId {
}
@end

for using it it's really simple :

使用它真的很简单：

[[RestaurantManager sharedInstance] registerForTable:[NsNumber numberWithInt:10]]

[[RestaurantManager sharedInstance] registerForTable:[NsNumber numberWithInt:10]]

回答by tesla

The accepted answer has 2 weaknesses. First, as others pointed is usage of #definewhich is harder to debug, use instead extern NSString* const kBaseUrlstructure. Second, it defines a single file for constants. IMO, this is wrong because most of classes don't need access to those constants or to access all of them plus file can become bloated if all constants are declared there. A better solution would be to modularize constants at 3 different layers:

接受的答案有两个弱点。首先，正如其他人指出的那样#define，使用更难调试的方法，请改用extern NSString* const kBaseUrl结构。其次，它为常量定义了一个文件。IMO，这是错误的，因为大多数类不需要访问这些常量或访问所有这些常量，而且如果所有常量都在那里声明，文件可能会变得臃肿。更好的解决方案是在 3 个不同层对常量进行模块化：

1. System layer: SystemConstants.hor AppConstants.hwhich describes constants at global scope, which can be accessed by any class in the system. Declare here only those constants that must be accessed from different classes that are not related.

2. Module/Sub-system layer: ModuleNameConstants.h, describes a set of constants which are typical for a set of related classes, inside of a module/sub-system.

3. Class layer: Constants resides in the class and are used only by it.

1. 系统层：SystemConstants.h或AppConstants.h在全局范围内描述常量，系统中的任何类都可以访问它。这里只声明那些必须从不相关的不同类访问的常量。

2. 模块/子系统层：ModuleNameConstants.h描述了一组常量，这些常量对于模块/子系统内部的一组相关类是典型的。

3. 类层：常量驻留在类中，仅供类使用。

Only 1,2 are related to the question.

只有 1,2 与问题有关。

回答by Geri Borbás

I'd use a configuration objectthat initializes from a plist. Why bother other classes with irrelevant external stuff?

我会使用一个从plist. 为什么用不相关的外部内容打扰其他课程？

I created eppz!settignssoley for this reason. See article Advanced yet simple way to save to NSUserDefaultsfor incorporating default values from a plist.

eppz!settigns出于这个原因，我创建了soley。请参阅文章保存到 NSUserDefaults 的高级而简单的方法，以合并来自plist.

回答by Chris Doble

An approach I've used before is to create a file Settings.plistand load it into NSUserDefaultsupon launch using registerDefaults:. You can then access its contents with the following:

我以前使用的一种方法是创建一个文件Settings.plist并NSUserDefaults在启动时使用registerDefaults:. 然后，您可以使用以下内容访问其内容：

// Assuming you've defined some constant kMySettingKey.
[[NSUserDefaults standardUserDefaults] objectForKey:kMySettingKey];

While I haven't done any Android development, it sounds as though this is analogous to the strings resource file you described. The only downside is that you can't use the preprocessor to swap between settings (e.g. in DEBUGmode). I suppose you could load in a different file, though.

虽然我没有做过任何 Android 开发，但听起来好像这类似于您描述的字符串资源文件。唯一的缺点是您不能使用预处理器在设置之间进行切换（例如在DEBUG模式中）。不过，我想您可以加载不同的文件。

NSUserDefaultsdocumentation.

NSUserDefaults文档。