Константи в Objective-C

Я розробляю програму Cocoa , і я використовую постійний NSStrings як спосіб зберігати ключові імена для моїх уподобань.

Я розумію, що це гарна ідея, оскільки вона дозволяє легко змінювати клавіші, якщо це необхідно.
Плюс, це все поняття "відокремити ваші дані від вашої логіки".

У будь-якому випадку, чи є хороший спосіб визначити ці константи один раз для всієї програми?

Я впевнений, що існує простий та розумний спосіб, але зараз мої заняття просто переосмислюють ті, якими вони користуються.

Ви повинні створити файл заголовка, як

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

(ви можете використовувати externзамість того, FOUNDATION_EXPORTякщо ваш код не буде використовуватися в змішаних середовищах C / C ++ або на інших платформах)

Ви можете включити цей файл у кожен файл, який використовує константи, або в попередньо складений заголовок для проекту.

Ви визначаєте ці константи у файлі .m типу

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

Constants.m слід додати до цілі програми / рамки, щоб вона була пов'язана з кінцевим продуктом.

Перевага використання рядкових констант замість #define'd-констант полягає в тому, що ви можете перевірити рівність, використовуючи порівняння вказівників ( stringInstance == MyFirstConstant), яке набагато швидше порівняння рядків ( [stringInstance isEqualToString:MyFirstConstant]) (і простіше для читання, IMO).

Найпростіший спосіб:

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

Однією з переваг другого є те, що зміна значення константи не викликає відновлення всієї вашої програми.

Також слід згадати одне. Якщо вам потрібна не глобальна константа, ви повинні використовувати staticключове слово.

Приклад

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

Через staticключове слово цей const не видно поза файлом.

Незначна корекція за допомогою @QuinnTaylor : статичні змінні видимі в одиниці компіляції . Зазвичай це єдиний .m-файл (як у цьому прикладі), але він може вкусити вас, якщо ви оголосите його у заголовку, який міститься в іншому місці, оскільки після компіляції ви отримаєте помилки в посиланнях

Прийнята (і правильна) відповідь говорить про те, що "ви можете включити цей файл [Constants.h] ... у попередньо складений заголовок проекту".

Як новачок у мене виникли труднощі робити це без додаткових пояснень - ось як: У файлі YourAppNameHere-Prefix.pch (це ім'я за замовчуванням для попередньо складеного заголовка в Xcode) імпортуйте свої константи.h всередину #ifdef __OBJC__блоку .

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

Також зауважте, що файли Constants.h та Constants.m не повинні містити в них абсолютно нічого, крім того, що описано у прийнятій відповіді. (Немає інтерфейсу чи реалізації).

Я, як правило, використовую спосіб, опублікований Баррі Варком та Рахулом Гуптою.

Хоча мені не подобається повторювати одні й ті ж слова у файлах .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"

et voila, я маю всю інформацію про константи лише у файлі .h.

Я сам має заголовок, призначений для оголошення константних NSStrings, використовуваних для таких налаштувань:

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

Такий підхід мені добре послужив.

Редагувати: Зауважте, що це найкраще працює, якщо рядки використовуються у кількох файлах. Якщо використовується лише один файл, ви можете просто зробити це #define kNSStringConstant @"Constant NSString"у файлі .m, який використовує рядок.

Невелика модифікація пропозиції @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. Для цього знадобиться перекомпіляція вашого ПК (і, можливо, всього проекту), коли будь-які значення змінюються, що не відбувається, якщо вони відокремлюються (і дублюються) як звичайні.

Сподіваюся, що комусь це корисно.

// Prefs.h
extern NSString * const RAHUL;

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

Як сказав Абізер, ви можете помістити його у файл PCH. Ще один спосіб, який не є таким брудним, - це зробити файл включення для всіх своїх ключів, а потім або включити його у файл, у якому ви використовуєте ключі, або включити його до PCH. З ними у власний файл включено файл, який принаймні дає вам одне місце для пошуку та визначення всіх цих констант.

Якщо ви хочете чогось типу глобальних констант; Швидкий брудний спосіб - це введення постійних декларацій у pchфайл.

Спробуйте використовувати метод класу:

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

Я інколи користуюсь цим.

Якщо вам подобається константа простору імен, ви можете використовувати структуру, П'ятниця, Питання та відповіді 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"
};

Я використовую однотонний клас, щоб я міг знущатися над класом і змінювати константи, якщо це необхідно для тестування. Клас констант виглядає приблизно так:

#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

Якщо ви хочете викликати щось подібне NSString.newLine;з об’єктивного c, і ви хочете, щоб воно було статичним постійним, ви можете швидко створити щось подібне:

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

І у вас є приємне для читання постійне визначення, яке доступне в межах типу на ваш вибір, при цьому стилі обмежені контекстом типу.