පරමාර්ථ-සී හි නියතයන්

මම කොකෝවා යෙදුමක් සංවර්ධනය කරමින් සිටිමි , NSStringමගේ මනාපයන් සඳහා ප්‍රධාන නම් ගබඩා කිරීමේ ක්‍රම ලෙස මම නියත s භාවිතා කරමි.

මෙය හොඳ අදහසක් බව මට වැටහී ඇති බැවින් අවශ්‍ය නම් යතුරු පහසුවෙන් වෙනස් කිරීමට ඉඩ සලසයි.
ඊට අමතරව, එය 'ඔබේ තර්කනයෙන් ඔබේ දත්ත වෙන් කරන්න' යන සංකල්පයයි.

කෙසේ වෙතත්, සමස්ත යෙදුම සඳහා මෙම නියතයන් එක් වරක් නිර්වචනය කිරීමට හොඳ ක්‍රමයක් තිබේද?

පහසු සහ බුද්ධිමත් ක්‍රමයක් ඇති බව මට විශ්වාසයි, නමුත් දැන් මගේ පන්ති ඔවුන් භාවිතා කරන ඒවා නැවත අර්ථ දක්වයි.

ඔබ වැනි ශීර්ෂ ගොනුවක් සෑදිය යුතුය

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

( ඔබේ කේතය මිශ්‍ර සී / සී ++ පරිසරවල හෝ වෙනත් වේදිකාවල භාවිතා නොකරන්නේ නම් externඒ වෙනුවට ඔබට භාවිතා කළ හැකිය FOUNDATION_EXPORT)

නියතයන් භාවිතා කරන සෑම ගොනුවකම හෝ ව්‍යාපෘතිය සඳහා පෙර සම්පාදනය කළ ශීර්ෂයේ ඔබට මෙම ගොනුව ඇතුළත් කළ හැකිය.

ඔබ මෙම නියතයන් .m ගොනුවක අර්ථ දක්වයි

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

Constants.m ඔබේ යෙදුමේ / රාමුවේ ඉලක්කයට එකතු කළ යුතු අතර එමඟින් එය අවසාන නිෂ්පාදනයට සම්බන්ධ වේ.

නියතයන් වෙනුවට නූල් නියතයන් භාවිතා කිරීමේ වාසිය #defineනම්, ඔබට 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 ගොනුවේ දෘශ්යමාන පිටත නොවේ.

@ ක්වින් ටේලර් විසින් සුළු නිවැරදි කිරීම : සංයුක්ත ඒකකයක් තුළ ස්ථිතික විචල්‍යයන් දැකිය හැකිය . සාමාන්‍යයෙන්, මෙය තනි .m ගොනුවකි (මෙම උදාහරණයේ දී මෙන්), නමුත් ඔබ එය වෙනත් තැනක ඇතුළත් කර ඇති ශීර්ෂ පා in යකින් ප්‍රකාශ කළහොත් එය ඔබට දෂ්ට කළ හැකිය.

පිළිගත් (සහ නිවැරදි) පිළිතුර පවසන්නේ "ඔබට මෙම [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 ලිපිගොනු වල පිළිගත් පිළිතුරෙහි විස්තර කර ඇති දේ හැර වෙනත් කිසිවක් අඩංගු නොවන බව සලකන්න. (අතුරු මුහුණතක් හෝ ක්‍රියාත්මක කිරීමක් නොමැත).

මම සාමාන්‍යයෙන් භාවිතා කරන්නේ බැරී වෝක් සහ රාහුල් ගුප්තා විසින් පළ කරන ලද ක්‍රමයයි.

.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 ගොනුවේ නියතයන් පිළිබඳ සියලු තොරතුරු මා සතුව ඇත.

එවැනි මනාපයන් සඳහා භාවිතා කරන නියත එන්එස්එස්ට්රිං ප්රකාශ කිරීම සඳහා කැප වූ ශීර්ෂයක් මා සතුව ඇත:

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 ගොනුවේ කළ හැකිය.

RizKrizz හි යෝජනාවේ සුළු වෙනස් කිරීමක්, එමඟින් නියත ශීර්ෂ ගොනුව 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නිසි වැඩ සහ මීට පෙර precompiled වටිනාකම් දුටු සම්පාදකවරයා වළක්වා ගැනීමට මේ සඳහා.

3. කිසියම් අගයක් වෙනස් වූ විට ඔබේ PCH (සහ බොහෝ විට සමස්ත ව්‍යාපෘතිය) නැවත සකස් කිරීම මේ සඳහා අවශ්‍ය වනු ඇත, ඒවා සාමාන්‍ය පරිදි වෙන් කර (හා අනුපිටපත් කර) තිබේ නම් එය එසේ නොවේ.

යමෙකුට ප්‍රයෝජනවත් වන බලාපොරොත්තුව.

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

ඔබට කියවිය හැකි නියත අර්ථ දැක්වීමක් ඇති අතර, ඔබේ අභිමතය පරිදි ලබා ගත හැකිය.