2018 में ऑब्जेक्टिव-सी पर कैसे लिखें। भाग 1

अधिकांश iOS प्रोजेक्ट्स आंशिक रूप से या पूरी तरह से स्विफ्ट में बदल जाते हैं। स्विफ्ट एक बेहतरीन भाषा है, और इसके साथ iOS के विकास का भविष्य निहित है। लेकिन भाषा औंधा रूप से टूलकिट के साथ जुड़ी हुई है, और स्विफ्ट टूलकिट में खामियां हैं।

स्विफ्ट कंपाइलर में अभी भी कीड़े हैं जो इसे गलत कोड बनाने या उत्पन्न करने का कारण बनते हैं। स्विफ्ट में स्थिर ABI नहीं है। और, बहुत महत्वपूर्ण बात, स्विफ्ट परियोजनाएं बहुत लंबे समय से चल रही हैं।

इस संबंध में, मौजूदा परियोजनाएं उद्देश्य-सी पर विकास जारी रखने के लिए अधिक लाभदायक हो सकती हैं। और ऑब्जेक्टिव-सी वह नहीं है जो यह हुआ करता था!

लेखों की इस श्रृंखला में, हम आपको उद्देश्य-सी की उपयोगी विशेषताओं और सुधारों को दिखाएंगे, जो लेखन कोड को और अधिक सुखद बनाता है। हर कोई जो ऑब्जेक्टिव-सी में लिखता है वह अपने लिए कुछ दिलचस्प पाएंगे।

let और var

उद्देश्य-सी को अब चर प्रकार स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है: Xcode 8 में, __auto_type भाषा एक्सटेंशन दिखाई दिया, और इससे पहले कि Xcode 8 प्रकार का __auto_type उद्देश्य-C ++ (C ++ 0X के आगमन के साथ auto कीवर्ड का उपयोग करके) में उपलब्ध था।

सबसे पहले, let और var macros जोड़ें:

 #define let __auto_type const #define var __auto_type 

 //  NSArray<NSString *> *const items = [string componentsSeparatedByString:@","]; void(^const completion)(NSData * _Nullable, NSURLResponse * _Nullable, NSError * _Nullable) = ^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) { // ... }; //  let items = [string componentsSeparatedByString:@","]; let completion = ^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) { // ... }; 

यदि आप ऑब्जेक्टिव-सी क्लास के लिए पॉइंटर के बाद const लिखते थे, तो यह एक असंगत लग्जरी था, लेकिन अब कॉन्स के निहित घोषणा ( let माध्यम let ) को मंजूरी दे दी गई है। अंतर विशेष रूप से ध्यान देने योग्य है जब एक ब्लॉक को एक चर में सहेजा जाता है।

अपने लिए, हमने सभी वेरिएबल्स को घोषित करने के लिए let और var का उपयोग करने के लिए एक नियम विकसित किया। यहां तक ​​कि जब एक चर nil को आरंभीकृत किया जाता है:

 - (nullable JMSomeResult *)doSomething { var result = (JMSomeResult *)nil; if (...) { result = ...; } return result; } 

एकमात्र अपवाद तब होता है जब आपको यह सुनिश्चित करने की आवश्यकता होती है कि प्रत्येक कोड शाखा में एक चर को एक मान दिया गया है:

 NSString *value; if (...) { if (...) { value = ...; } else { value = ...; } } else { value = ...; } 

यदि हम शाखाओं में से किसी एक को मान देना भूल जाते हैं तो केवल इस तरह से हमें एक कंपाइलर चेतावनी मिलेगी।

और अंत में: टाइप id वैरिएबल के लिए let और -Wno-auto-var-id का उपयोग करने के लिए, आपको auto-var-id चेतावनी (प्रोजेक्ट सेटिंग्स में "अन्य चेतावनी फ्लैग" में -Wno-auto-var-id को अक्षम करने की आवश्यकता है)।

ऑटो ब्लॉक प्रकार वापसी मूल्य

कुछ लोगों को पता है कि कंपाइलर ब्लॉक के रिटर्न मान के प्रकार का अनुमान लगा सकता है:

 let block = ^{ return @"abc"; }; // `block`   `NSString *(^const)(void)` 

यह बहुत सुविधाजनक है। खासकर यदि आप ReactiveObjC का उपयोग करके प्रतिक्रियात्मक कोड लिखते हैं। लेकिन कई प्रतिबंध हैं जिनके तहत आपको वापसी मूल्य के प्रकार को स्पष्ट रूप से निर्दिष्ट करना होगा।

1. यदि किसी ब्लॉक में कई return हैं जो विभिन्न प्रकारों के मान लौटाते हैं।

   
   

    let block1 = ^NSUInteger(NSUInteger value){ if (value > 0) { return value; } else { // `NSNotFound`   `NSInteger` return NSNotFound; } }; let block2 = ^JMSomeBaseClass *(BOOL flag) { if (flag) { return [[JMSomeBaseClass alloc] init]; } else { // `JMSomeDerivedClass`   `JMSomeBaseClass` return [[JMSomeDerivedClass alloc] init]; } }; 

   
   

2. यदि ब्लॉक में return है जो nil लौटाता है।

   
   

    let block1 = ^NSString * _Nullable(){ return nil; }; let block2 = ^NSString * _Nullable(BOOL flag) { if (flag) { return @"abc"; } else { return nil; } }; 

   
   

3. यदि ब्लॉक को BOOL वापस करना चाहिए।

   
   

    let predicate = ^BOOL(NSInteger lhs, NSInteger rhs){ return lhs > rhs; }; 

   
   

C (और इसलिए Objective-C) में तुलना ऑपरेटर के साथ अभिव्यक्तियाँ टाइप int । इसलिए, रिटर्न प्रकार BOOL को हमेशा स्पष्ट रूप से निर्दिष्ट करने का नियम बनाना बेहतर है।

पीढ़ी और for...in

एक्सकोड 7 में, जेनरिक (या बल्कि, हल्के जेनरिक) ऑब्जेक्टिव-सी में दिखाई दिए। हमें उम्मीद है कि आप पहले से ही उनका उपयोग करेंगे। लेकिन यदि नहीं, तो आप WWDC सत्र देख सकते हैं या इसे यहाँ या यहाँ पढ़ सकते हैं ।

अपने लिए, हमने जेनेरिक मापदंडों को हमेशा निर्दिष्ट करने के लिए एक नियम विकसित किया है, भले ही वह id ( NSArray<id> * ) हो। इस प्रकार, विरासत कोड के बीच अंतर करना आसान है जिसमें सामान्य पैरामीटर अभी तक निर्दिष्ट नहीं हैं।

let और var मैक्रो के साथ, हम उम्मीद करते हैं कि हम उन्हें for...in : लूप में उपयोग कर सकते हैं।

 let items = (NSArray<NSString *> *)@[@"a", @"b", @"c"]; for (let item in items) { NSLog(@"%@", item); } 

लेकिन ऐसा कोड संकलन नहीं करता है। सबसे अधिक संभावना है, __auto_type में for...in समर्थित नहीं __auto_type , क्योंकि for...in केवल संग्रह के साथ काम करता है जो NSFastEnumeration प्रोटोकॉल को लागू करता है। और ऑब्जेक्टिव-सी में प्रोटोकॉल के लिए जेनरिक का कोई समर्थन नहीं है।

इस खामी को ठीक करने के लिए, अपने foreach मैक्रो को बनाने का प्रयास करें। पहली बात जो ध्यान में आती है: फाउंडेशन के सभी संग्रह में एक objectEnumerator संपत्ति होती है, और मैक्रो इस तरह दिख सकता है:

 #define foreach(object_, collection_) \ for (typeof([(collection_).objectEnumerator nextObject]) object_ in (collection_)) 

लेकिन NSMapTable और NSMapTable प्रोटोकॉल पद्धति कुंजियों पर निर्भर करती है, मानों पर नहीं (आपको keyEnumerator का उपयोग करने की आवश्यकता होगी, objectEnumerator नहीं)।

हमें एक नई संपत्ति घोषित करने की आवश्यकता होगी जिसका उपयोग केवल typeof अभिव्यक्ति में टाइप करने के लिए किया जाएगा:

 @interface NSArray<__covariant ObjectType> (ForeachSupport) @property (nonatomic, strong, readonly) ObjectType jm_enumeratedType; @end @interface NSDictionary<__covariant KeyType, __covariant ObjectType> (ForeachSupport) @property (nonatomic, strong, readonly) KeyType jm_enumeratedType; @end #define foreach(object_, collection_) \ for (typeof((collection_).jm_enumeratedType) object_ in (collection_)) 

अब हमारा कोड बहुत बेहतर लग रहा है:

 //  for (MyItemClass *item in items) { NSLog(@"%@", item); } //  foreach (item, items) { NSLog(@"%@", item); } 

 foreach (<#object#>, <#collection#>) { <#statements#> } 

mutableCopy और copy / mutableCopy

एक अन्य स्थान जहां टाइपिंग सी-ऑब्जेक्टिव-सी में उपलब्ध नहीं है, -mutableCopy और -mutableCopy (साथ ही -copyWithZone: और -mutableCopyWithZone: विधियां हैं, लेकिन हम उन्हें सीधे कॉल नहीं करेंगे)।

स्पष्ट जाति की आवश्यकता से बचने के लिए, आप रिटर्न प्रकार के साथ तरीकों को फिर से कर सकते हैं। उदाहरण के लिए, NSArray के लिए, घोषणाएँ होंगी:

 @interface NSArray<__covariant ObjectType> (TypedCopying) - (NSArray<ObjectType> *)copy; - (NSMutableArray<ObjectType> *)mutableCopy; @end 

 let items = [NSMutableArray<NSString *> array]; // ... //  let itemsCopy = (NSArray<NSString *> *)[items copy]; //  let itemsCopy = [items copy]; 

warn_unused_result

चूँकि हमने -copy और -mutableCopy को फिर से घोषित किया है, इसलिए यह गारंटी देना अच्छा होगा कि इन विधियों को कॉल करने के परिणाम का उपयोग किया जाएगा। ऐसा करने के लिए, warn_unused_result में warn_unused_result विशेषता है।

 #define JM_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) 

 @interface NSArray<__covariant ObjectType> (TypedCopying) - (NSArray<ObjectType> *)copy JM_WARN_UNUSED_RESULT; - (NSMutableArray<ObjectType> *)mutableCopy JM_WARN_UNUSED_RESULT; @end 

निम्नलिखित कोड के लिए, कंपाइलर एक चेतावनी उत्पन्न करेगा:

 let items = @[@"a", @"b", @"c"]; [items mutableCopy]; // Warning: Ignoring return value of function declared with 'warn_unused_result' attribute. 

overloadable

कुछ ही जानते हैं कि क्लैंग आपको सी भाषा में फ़ंक्शन को फिर से परिभाषित करने की अनुमति देता है (और इसलिए उद्देश्य-सी में)। overloadable विशेषता का उपयोग करके, आप एक ही नाम के साथ फ़ंक्शन बना सकते हैं, लेकिन विभिन्न प्रकार के तर्कों के साथ या विभिन्न संख्याओं के साथ।

अतिदेय कार्य केवल वापसी मूल्य के प्रकार में भिन्न नहीं हो सकते हैं।

 #define JM_OVERLOADABLE __attribute__((overloadable)) 

 JM_OVERLOADABLE float JMCompare(float lhs, float rhs); JM_OVERLOADABLE float JMCompare(float lhs, float rhs, float accuracy); JM_OVERLOADABLE double JMCompare(double lhs, double rhs); JM_OVERLOADABLE double JMCompare(double lhs, double rhs, double accuracy); 

बॉक्सिंग के भाव

2012 में वापस WWDC 413 सत्र में, Apple ने NSNumber , NSArray और NSDictionary Shadow के लिए शाब्दिक शुरुआत की, साथ ही साथ बॉक्सिंग एक्सप्रेशन भी प्रस्तुत किए। आप क्लैंग प्रलेखन में शाब्दिक और बॉक्सिंग अभिव्यक्तियों के बारे में अधिक पढ़ सकते हैं।

 //  @YES // [NSNumber numberWithBool:YES] @NO // [NSNumber numberWithBool:NO] @123 // [NSNumber numberWithInt:123] @3.14 // [NSNumber numberWithDouble:3.14] @[obj1, obj2] // [NSArray arrayWithObjects:obj1, obj2, nil] @{key1: obj1, key2: obj2} // [NSDictionary dictionaryWithObjectsAndKeys:obj1, key1, obj2, key2, nil] // Boxed expressions @(boolVariable) // [NSNumber numberWithBool:boolVariable] @(intVariable) // [NSNumber numberWithInt:intVariable)] 

शाब्दिक और बॉक्सिंग अभिव्यक्तियों का उपयोग करके, आप आसानी से एक संख्या या बूलियन मान का प्रतिनिधित्व करने वाली एक वस्तु प्राप्त कर सकते हैं। लेकिन एक ऐसी वस्तु प्राप्त करने के लिए जो संरचना को लपेटती है, आपको कुछ कोड लिखने की आवश्यकता है:

 //  `NSDirectionalEdgeInsets`  `NSValue` let insets = (NSDirectionalEdgeInsets){ ... }; let value = [[NSValue alloc] initWithBytes:&insets objCType:@encode(typeof(insets))]; // ... //  `NSDirectionalEdgeInsets`  `NSValue` var insets = (NSDirectionalEdgeInsets){}; [value getValue:&insets]; 

कुछ वर्गों के लिए सहायक विधियाँ और गुण परिभाषित किए गए हैं (जैसे +[NSValue valueWithCGPoint:] विधि और CGPointValue गुण), लेकिन यह अभी भी बॉक्सिंग अभिव्यक्ति के रूप में सुविधाजनक नहीं है!

और 2015 में, एलेक्स डेनिसोव ने क्लैंग के लिए एक पैच बनाया , जिससे आप NSValue में किसी भी संरचना को लपेटने के लिए बॉक्सिंग अभिव्यक्तियों का उपयोग कर सकते हैं।

बॉक्सिंग अभिव्यक्तियों का समर्थन करने के लिए हमारी संरचना के लिए, आपको बस संरचना के लिए objc_boxable विशेषता जोड़ने की आवश्यकता है।

 #define JM_BOXABLE __attribute__((objc_boxable)) 

 typedef struct JM_BOXABLE JMDimension { JMDimensionUnit unit; CGFloat value; } JMDimension; 

और हम अपनी संरचना के लिए @(...) सिंटैक्स का उपयोग कर सकते हैं:

 let dimension = (JMDimension){ ... }; let boxedValue = @(dimension); //   `NSValue *` 

आपको अभी भी संरचना को विधि के माध्यम से वापस -[NSValue getValue:] या श्रेणी विधि।

CoreGraphics अपने स्वयं के मैक्रो को परिभाषित करता है, CG_BOXABLE , और बॉक्सिंग अभिव्यक्तियाँ पहले से ही CGPoint , CGSize , CGVector और CGRect लिए समर्थित हैं।

अन्य आम तौर पर उपयोग की जाने वाली संरचनाओं के लिए, हम अपने दम पर बॉक्सिंग अभिव्यक्तियों के लिए समर्थन जोड़ सकते हैं:

 typedef struct JM_BOXABLE _NSRange NSRange; typedef struct JM_BOXABLE CGAffineTransform CGAffineTransform; typedef struct JM_BOXABLE UIEdgeInsets UIEdgeInsets; typedef struct JM_BOXABLE NSDirectionalEdgeInsets NSDirectionalEdgeInsets; typedef struct JM_BOXABLE UIOffset UIOffset; typedef struct JM_BOXABLE CATransform3D CATransform3D; 

यौगिक शाब्दिक

एक अन्य उपयोगी भाषा निर्माण यौगिक शाब्दिक है । यौगिक शाब्दिक रूप से जीसीसी में एक भाषा विस्तार के रूप में दिखाई दिया, और बाद में सी 11 मानक में जोड़ा गया।

यदि पहले, UIEdgeInsetsMake को कॉल मिला, तो हम केवल अनुमान लगा सकते हैं कि हमें क्या इंडेंटेशन मिलेगा (हमें UIEdgeInsetsMake फ़ंक्शन की घोषणा को देखना था), फिर कंपाउंड शाब्दिक के साथ कोड खुद के लिए बोलता है:

 //  UIEdgeInsetsMake(1, 2, 3, 4) //  (UIEdgeInsets){ .top = 1, .left = 2, .bottom = 3, .right = 4 } 

खेतों में से कुछ शून्य होने पर इस तरह के निर्माण का उपयोग करना और भी अधिक सुविधाजनक है:

 (CGPoint){ .y = 10 } //  (CGPoint){ .x = 0, .y = 10 } (CGRect){ .size = { .width = 10, .height = 20 } } //  (CGRect){ .origin = { .x = 0, .y = 0 }, .size = { .width = 10, .height = 20 } } (UIEdgeInsets){ .top = 10, .bottom = 20 } //  (UIEdgeInsets){ .top = 20, .left = 0, .bottom = 10, .right = 0 } 

बेशक, यौगिक शाब्दिक में आप न केवल स्थिरांक का उपयोग कर सकते हैं, बल्कि किसी भी भाव:

 textFrame = (CGRect){ .origin = { .y = CGRectGetMaxY(buttonFrame) + textMarginTop }, .size = textSize }; 

 (NSRange){ .location = <#location#>, .length = <#length#> } (CGPoint){ .x = <#x#>, .y = <#y#> } (CGSize){ .width = <#width#>, .height = <#height#> } (CGRect){ .origin = { .x = <#x#>, .y = <#y#> }, .size = { .width = <#width#>, .height = <#height#> } } (UIEdgeInsets){ .top = <#top#>, .left = <#left#>, .bottom = <#bottom#>, .right = <#right#> } (NSDirectionalEdgeInsets){ .top = <#top#>, .leading = <#leading#>, .bottom = <#bottom#>, .trailing = <#trailing#> } (UIOffset){ .horizontal = <#horizontal#>, .vertical = <#vertical#> } 

Nullability

Xcode 6.3.2 में, अशक्तता एनोटेशन ऑब्जेक्टिव-सी में दिखाई दिया। Apple डेवलपर्स ने उन्हें स्विफ्ट में ऑब्जेक्टिव-सी एपीआई आयात करने के लिए जोड़ा। लेकिन अगर भाषा में कुछ जोड़ा जाता है, तो आपको इसे अपनी सेवा में रखने की कोशिश करनी चाहिए। और हम बताएंगे कि हम एक उद्देश्य-सी परियोजना में अशक्तता का उपयोग कैसे करते हैं और सीमाएं क्या हैं।

अपने ज्ञान को ताज़ा करने के लिए, आप WWDC सत्र देख सकते हैं।

सबसे पहली बात हमने NS_ASSUME_NONNULL_BEGIN / NS_ASSUME_NONNULL_END को .m फ़ाइलों में लिखना शुरू करना था। हाथ से ऐसा न करने के लिए, हम सीधे Xcode में फ़ाइल टेम्प्लेट पैच करते हैं।

हमने सभी निजी संपत्तियों और विधियों के लिए सही ढंग से अशक्तता स्थापित करना शुरू कर दिया।

यदि हम एक मौजूदा .m फ़ाइल में मैक्रोज़ NS_ASSUME_NONNULL_BEGIN / NS_ASSUME_NONNULL_END जोड़ते हैं, तो हम तुरंत पूरी फ़ाइल में लापता nullable , null_resettable और _Nullable ।

सभी उपयोगी अशक्तता संकलक चेतावनी डिफ़ॉल्ट रूप से सक्षम हैं। लेकिन एक चरम चेतावनी है जिसे मैं शामिल करना चाहूंगा: -Wnullable-to-nonnull-conversion (परियोजना सेटिंग्स में "अन्य चेतावनी झंडे" में सेट)। कंपाइलर इस चेतावनी को तब उत्पन्न करता है जब एक अशक्त प्रकार के साथ एक चर या अभिव्यक्ति को गैर-प्रकार से अंतर्निहित रूप से डाला जाता है।

 + (NSString *)foo:(nullable NSString *)string { return string; // Implicit conversion from nullable pointer 'NSString * _Nullable' to non-nullable pointer type 'NSString * _Nonnull' } 

दुर्भाग्य से, __auto_type (और इसलिए let और var ) के लिए, यह चेतावनी काम नहीं करती है। __auto_type माध्यम से __auto_type प्रकार अशक्तता की व्याख्या करता है। और, Apple डेवलपर की टिप्पणी rdar: // 27062504 में देखते हुए , यह व्यवहार नहीं बदलेगा। यह प्रायोगिक तौर पर देखा गया है कि _Nullable या _Nonnull जोड़ने से कुछ भी प्रभावित नहीं होता है।

 - (NSString *)test:(nullable NSString *)string { let tmp = string; return tmp; //   } 

nullable-to-nonnull-conversion को दबाने के लिए nullable-to-nonnull-conversion हमने एक मैक्रो लिखा है जो "बलपूर्वक अनट्रैप" करता है। RBBNotNil मैक्रो से लिया गया आइडिया। लेकिन __auto_type के व्यवहार के __auto_type सहायक वर्ग से छुटकारा पाना संभव था।

 #define JMNonnull(obj_) \ ({ \ NSCAssert(obj_, @"Expected `%@` not to be nil.", @#obj_); \ (typeof({ __auto_type result_ = (obj_); result_; }))(obj_); \ }) 

JMNonnull मैक्रो का उपयोग करने का एक उदाहरण:

 @interface JMRobot : NSObject @property (nonatomic, strong, nullable) JMLeg *leftLeg; @property (nonatomic, strong, nullable) JMLeg *rightLeg; @end @implementation JMRobot - (void)stepLeft { [self step:JMNonnull(self.leftLeg)] } - (void)stepRight { [self step:JMNonnull(self.rightLeg)] } - (void)step:(JMLeg *)leg { // ... } @end 

ध्यान दें कि लेखन के समय, nullable-to-nonnull-conversion चेतावनी nullable-to-nonnull-conversion काम नहीं करती nullable-to-nonnull-conversion : कंपाइलर अभी तक यह नहीं समझता है कि असमानता की जांच करने के बाद एक nullable चर को nonnull व्याख्या के रूप में व्याख्या किया जा सकता है।

 - (NSString *)foo:(nullable NSString *)string { if (string != nil) { return string; // Implicit conversion from nullable pointer 'NSString * _Nullable' to non-nullable pointer type 'NSString * _Nonnull' } else { return @""; } } 

ऑब्जेक्टिव-सी ++ कोड में, आप इस if let कंस्ट्रक्शन का उपयोग करके प्राप्त कर सकते हैं, क्योंकि ऑब्जेक्टिव-सी ++ एक if में वेरिएबल्स को घोषित करने की अनुमति देता है।

 - (NSString *)foo:(nullable NSString *)stringOrNil { if (let string = stringOrNil) { return string; } else { return @""; } } 

उपयोगी लिंक

और भी कई जाने-माने मैक्रोज़ और कीवर्ड हैं, जिनका मैं उल्लेख करना चाहूंगा: @available कीवर्ड, मैक्रोज़ NS_DESIGNATED_INITIALIZER , NS_UNAVAILABLE , NS_REQUIRES_SUPER , NS_NOESCAPE , NS_ENUM , NS_OPTIONS (या आपके अन्य मैक्रोज़)। हम यह भी सलाह देते हैं कि आप बाकी के libextobjc लाइब्रेरी को देखें।

→ लेख का कोड जिस्ट में पोस्ट किया गया है।

निष्कर्ष

लेख के पहले भाग में, हमने मुख्य विशेषताओं और सरल भाषा में सुधार के बारे में बात करने की कोशिश की, जो उद्देश्य-सी कोड के लेखन और समर्थन को बहुत सुविधाजनक बनाता है। अगले भाग में, हम दिखाएंगे कि आप स्विफ्ट के रूप में एनम का उपयोग करके अपनी उत्पादकता को कैसे बढ़ा सकते हैं (वे भी केस क्लास हैं; वे बीजीय डेटा प्रकार , एडीटी भी हैं) और प्रोटोकॉल स्तर पर तरीकों को लागू करने की संभावना है।