स्विफ्ट 5.0 में उन्नत स्ट्रिंग प्रक्षेप

स्ट्रिंग प्रक्षेप पहले के संस्करणों से स्विफ्ट में था, लेकिन स्विफ्ट 5.0 में यह कार्यक्षमता विस्तारित हुई, तेज और अधिक शक्तिशाली बन गई।

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

मूल बातें

हम इस तरह से बुनियादी स्ट्रिंग प्रक्षेप का उपयोग करते हैं:

let age = 38 print("You are \(age)") 

हम इसे लेने के लिए है, लेकिन एक समय में यह एक महत्वपूर्ण राहत की तुलना में था जो हमें पहले से निपटने के लिए था:

 [NSString stringWithFormat:@"%ld", (long)unreadCount]; 

विकल्प के रूप में एक महत्वपूर्ण प्रदर्शन लाभ भी है:

 let all = s1 + s2 + s3 + s4 

हां, अंतिम परिणाम समान होगा, लेकिन स्विफ्ट को s5 प्राप्त करने के लिए s1 को s2 में जोड़ना होगा, s6 प्राप्त करने के लिए s3 को s3 में जोड़ना होगा, और s6 को s4 में जोड़ने के लिए s7 प्राप्त करने के लिए, सभी को असाइन करने से पहले।

स्ट्रिंग इंटरपोलेशन व्यावहारिक रूप से स्विफ्ट 1.0 के साथ नहीं बदला, एकमात्र महत्वपूर्ण बदलाव स्विफ्ट 2.1 के साथ आया, जहां हमें इंटरपोल में स्ट्रिंग लीटर का उपयोग करने का अवसर मिला:

 print("Hi, \(user ?? "Anonymous")") 

जैसा कि आप जानते हैं, स्विफ्ट बड़े पैमाने पर सामुदायिक सुझावों के लिए विकसित हो रहा है। विचारों की चर्चा, विकास, और या तो स्वीकार या अस्वीकार कर दिया जाता है।

इसलिए, पांच साल बाद, स्विफ्ट के विकास को लाइन प्रक्षेप मिला। स्विफ्ट 5.0 ने नए सुपर फीचर्स पेश किए जो हमें स्ट्रिंग इंटरपोलेशन प्रक्रिया को नियंत्रित करने की क्षमता प्रदान करते हैं।

प्रयास करने के लिए, निम्नलिखित परिदृश्य पर विचार करें। यदि हम इस तरह एक नया पूर्णांक चर सेट करते हैं:

 let age = 38 

यह काफी स्पष्ट है कि हम स्ट्रिंग प्रक्षेप का उपयोग इस प्रकार कर सकते हैं:

 print("Hi, I'm \(age).") 

लेकिन क्या होगा अगर हम परिणाम को एक अलग तरीके से प्रारूपित करना चाहते हैं?

स्विफ्ट 5.0 में नए स्ट्रिंग इंटरपोलेशन सिस्टम का उपयोग करके, हम अपने स्वयं के प्रक्षेप विधि को जोड़ने के लिए String.StringInterpolation एक्सटेंशन लिख सकते हैं:

 extension String.StringInterpolation { mutating func appendInterpolation(_ value: Int) { let formatter = NumberFormatter() formatter.numberStyle = .spellOut if let result = formatter.string(from: value as NSNumber) { appendLiteral(result) } } } 

अब कोड पाठ के रूप में पूरे चर का उत्पादन करेगा: "हाय, मैं अड़तीस हूँ।"

हम दिनांक स्वरूपण को ठीक करने के लिए एक समान तकनीक का उपयोग कर सकते हैं, क्योंकि एक स्ट्रिंग के रूप में डिफ़ॉल्ट तिथि दृश्य बहुत आकर्षक नहीं है:

 print("Today's date is \(Date()).") 

आप देखेंगे कि स्विफ्ट वर्तमान तिथि को कुछ इस तरह प्रदर्शित करता है जैसे: "2019-02-21 23:30:21 +0000"। हम अपनी स्वयं की दिनांक स्वरूपण का उपयोग करके इसे और अधिक सुंदर बना सकते हैं:

 mutating func appendInterpolation(_ value: Date) { let formatter = DateFormatter() formatter.dateStyle = .full let dateString = formatter.string(from: value) appendLiteral(dateString) } 

अब परिणाम बहुत बेहतर लग रहा है, कुछ इस तरह है: "21 फरवरी, 2019 23:30:21"।

नोट: एक टीम में एक साथ काम करते समय संभावित भ्रम से बचने के लिए, आपको शायद डिफ़ॉल्ट स्विफ्ट विधियों को ओवरराइड नहीं करना चाहिए। इसलिए, भ्रम से बचने के लिए मापदंडों को अपनी पसंद के नाम दें:

 mutating func appendInterpolation(format value: Int) { 

अब हम इस विधि को नामांकित पैरामीटर के साथ कहेंगे:

 print("Hi, I'm \(format: age).") 

अब यह स्पष्ट हो जाएगा कि हम विधि के अपने कार्यान्वयन का उपयोग कर रहे हैं।

मापदंडों के साथ प्रक्षेप

यह परिवर्तन दिखाता है कि अब हमारा पूर्ण नियंत्रण है कि स्ट्रिंग प्रक्षेप कैसे होता है।

उदाहरण के लिए, हम ट्विटर संदेशों को संसाधित करने के लिए कोड को फिर से लिख सकते हैं:

 mutating func appendInterpolation(twitter: String) { appendLiteral("<a href=\"https://twitter.com/\(twitter)\">@\(twitter)</a>") } 

अब हम इस तरह लिख सकते हैं:

 print("You should follow me on Twitter: \(twitter: "twostraws").") 

लेकिन हम खुद को एक पैरामीटर तक सीमित क्यों रखें? हमारे संख्या स्वरूपण उदाहरण के लिए, उपयोगकर्ताओं को एक रूपांतरण पैरामीटर (.spellOut) का उपयोग करने के लिए मजबूर करने का कोई मतलब नहीं है - इसलिए हम दूसरे पैरामीटर को जोड़कर विधि बदल देंगे:

 mutating func appendInterpolation(format value: Int, using style: NumberFormatter.Style) { let formatter = NumberFormatter() formatter.numberStyle = style if let result = formatter.string(from: value as NSNumber) { appendLiteral(result) } } 

और इसे इस तरह से उपयोग करें:

 print("Hi, I'm \(format: age, using: .spellOut).") 

आपके पास किसी भी प्रकार के जितने चाहें, उतने पैरामीटर हो सकते हैं। डिफ़ॉल्ट मान के लिए @ आधार का उपयोग कर उदाहरण:

 extension String.StringInterpolation { mutating func appendInterpolation(_ values: [String], empty defaultValue: @autoclosure () -> String) { if values.count == 0 { appendLiteral(defaultValue()) } else { appendLiteral(values.joined(separator: ", ")) } } } let names = ["Malcolm", "Jayne", "Kaylee"] print("Crew: \(names, empty: "No one").") 

@ उपहास विशेषता का उपयोग करने का अर्थ है कि डिफ़ॉल्ट मान के लिए, हम सरल मानों का उपयोग कर सकते हैं या जटिल कार्यों को कॉल कर सकते हैं। विधि में, वे एक बंद हो जाएंगे।

अब, आप सोच रहे होंगे कि हम प्रक्षेप कार्यक्षमता का उपयोग किए बिना कोड को फिर से लिख सकते हैं, कुछ इस तरह से:

 extension Array where Element == String { func formatted(empty defaultValue: @autoclosure () -> String) -> String { if count == 0 { return defaultValue() } else { return self.joined(separator: ", ") } } } print("Crew: \(names.formatted(empty: "No one")).") 

लेकिन अब हमने कॉल को जटिल कर दिया है - क्योंकि हम स्पष्ट रूप से कुछ प्रारूपित करने की कोशिश कर रहे हैं, यह प्रक्षेप का बिंदु है। स्विफ्ट नियम को याद रखें - अनावश्यक शब्दों से बचें।

एरिका सदुन ने कोड को सरल बनाने के लिए एक बहुत छोटा और सुंदर उदाहरण पेश किया:

 extension String.StringInterpolation { mutating func appendInterpolation(if condition: @autoclosure () -> Bool, _ literal: StringLiteralType) { guard condition() else { return } appendLiteral(literal) } } let doesSwiftRock = true print("Swift rocks: \(if: doesSwiftRock, "(*)")") print("Swift rocks \(doesSwiftRock ? "(*)" : "")") 

कस्टम प्रकारों के लिए स्ट्रिंग प्रक्षेप जोड़ना

हम अपने स्वयं के प्रकारों के लिए स्ट्रिंग प्रक्षेप का उपयोग कर सकते हैं:

 struct Person { var type: String var action: String } extension String.StringInterpolation { mutating func appendInterpolation(_ person: Person) { appendLiteral("I'm a \(person.type) and I'm gonna \(person.action).") } } let hater = Person(type: "hater", action: "hate") print("Status check: \(hater)") 

स्ट्रिंग प्रक्षेप उपयोगी है क्योंकि हम किसी ऑब्जेक्ट के बारे में जानकारी डीबगिंग पर स्पर्श नहीं करते हैं। यदि हम इसे डिबगर में देखते हैं या इसे प्रदर्शित करते हैं, तो हम अछूता डेटा देखेंगे:

 print(hater) 

हम कई मापदंडों के साथ एक कस्टम प्रकार जोड़ सकते हैं:

 extension String.StringInterpolation { mutating func appendInterpolation(_ person: Person, count: Int) { let action = String(repeating: "\(person.action) ", count: count) appendLiteral("\n\(person.type.capitalized)s gonna \(action)") } } let player = Person(type: "player", action: "play") let heartBreaker = Person(type: "heart-breaker", action: "break") let faker = Person(type: "faker", action: "fake") print("Let's sing: \(player, count: 5) \(hater, count: 5) \(heartBreaker, count: 5) \(faker, count: 5)") 

बेशक, आप अपनी स्वयं की स्वरूपण बनाने के लिए स्विफ्ट की सभी विशेषताओं का उपयोग कर सकते हैं। उदाहरण के लिए, हम एक कार्यान्वयन लिख सकते हैं जो किसी भी एन्कोडेबल को स्वीकार करता है और इसे JSON में प्रिंट करता है:

 mutating func appendInterpolation<T: Encodable>(debug value: T) { let encoder = JSONEncoder() encoder.outputFormatting = .prettyPrinted if let result = try? encoder.encode(value) { let str = String(decoding: result, as: UTF8.self) appendLiteral(str) } } 

अगर हम एनकोडेबल प्रोटोकॉल के साथ व्यक्ति का अनुपालन करते हैं, तो हम यह कर सकते हैं:

 print("Here's some data: \(debug: faker)") 

आप मापदंडों की एक चर संख्या जैसी सुविधाओं का उपयोग कर सकते हैं, यहां तक ​​कि फेंकने के रूप में प्रक्षेप के अपने कार्यान्वयन को चिह्नित करें। उदाहरण के लिए, हमारी JSON प्रारूपण प्रणाली एन्कोडिंग त्रुटि की स्थिति में प्रतिक्रिया नहीं देती है, लेकिन हम भविष्य में त्रुटि का विश्लेषण करने के लिए इसे ठीक कर सकते हैं:

 mutating func appendInterpolation<T: Encodable>(debug value: T) throws { let encoder = JSONEncoder() encoder.outputFormatting = .prettyPrinted let result = try encoder.encode(value) let str = String(decoding: result, as: UTF8.self) appendLiteral(str) } print(try "Status check: \(debug: hater)") 

अब तक हमने जो भी देखा है, वे स्ट्रिंग इंटरपोलेशन के तरीकों में संशोधन हैं।

इंटरपोल का उपयोग करके कस्टम प्रकार बनाना

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

इसे प्रदर्शित करने के लिए, हम एक नए प्रकार का निर्माण करेंगे जो स्ट्रिंग इंटरपोलेशन का उपयोग करके स्ट्रिंग से आरंभ किया जाता है।

 struct ColoredString: ExpressibleByStringInterpolation { //    -    -    struct StringInterpolation: StringInterpolationProtocol { //   -    var output = NSMutableAttributedString() //     var baseAttributes: [NSAttributedString.Key: Any] = [.font: UIFont(name: "Georgia-Italic", size: 64) ?? .systemFont(ofSize: 64), .foregroundColor: UIColor.black] //   ,        init(literalCapacity: Int, interpolationCount: Int) { } // ,      mutating func appendLiteral(_ literal: String) { //   ,       print("Appending \(literal)") //    let attributedString = NSAttributedString(string: literal, attributes: baseAttributes) //     output.append(attributedString) } // ,          mutating func appendInterpolation(message: String, color: UIColor) { //     print("Appending \(message)") //        var coloredAttributes = baseAttributes coloredAttributes[.foregroundColor] = color //    -     let attributedString = NSAttributedString(string: message, attributes: coloredAttributes) output.append(attributedString) } } //    ,     let value: NSAttributedString //      init(stringLiteral value: String) { self.value = NSAttributedString(string: value) } //     init(stringInterpolation: StringInterpolation) { self.value = stringInterpolation.output } } let str: ColoredString = "\(message: "Red", color: .red), \(message: "White", color: .white), \(message: "Blue", color: .blue)" 

वास्तव में, हुड के नीचे एक सिंटैक्टिक चीनी है। हम अंतिम भाग को मैन्युअल रूप से लिख सकते हैं:

 var interpolation = ColoredString.StringInterpolation(literalCapacity: 10, interpolationCount: 1) interpolation.appendLiteral("Hello") interpolation.appendInterpolation(message: "Hello", color: .red) interpolation.appendLiteral("Hello") let valentine = ColoredString(stringInterpolation: interpolation) 

निष्कर्ष

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

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