कैसे हल करने के लिए "स्ट्रिंग प्रक्षेप एक वैकल्पिक मूल्य के लिए डिबग विवरण तैयार करता है; क्या आपको यह स्पष्ट करने का मतलब है? " Xcode में 8.3 बीटा?

Question 1

8.3 के बाद से, zillions चेतावनियाँ "स्ट्रिंग प्रक्षेप एक वैकल्पिक मूल्य के लिए एक डिबग विवरण पैदा करता है? क्या आप इसे स्पष्ट करने का मतलब है?" मेरे कोड में दिखाई दिया।

उदाहरण के लिए, चेतावनी निम्न स्थिति में पॉप अप हुई, जहां विकल्प शून्य हो सकते हैं:

let msg = "*** Error \(options["taskDescription"]): cannot load \(sUrl) \(error)"

जैसा कि पहले डिज़ाइन किया गया था, मेरे लिए (और कंपाइलर) वैकल्पिक 'एनआईएल' के रूप में प्रक्षेपित होना ठीक था। लेकिन कंपाइलर ने अपना विचार बदल दिया।

कंपाइलर ने सुझाव दिया है कि स्ट्रिंग कंस्ट्रक्टर को विवरण के साथ जोड़ना है:

let msg = "*** Error \(String(describing: options["taskDescription"])): cannot load \(sUrl) \(error)"

जाहिर है, परिणाम स्पष्ट हैं लेकिन मेरी राय में बहुत ही बोझिल हैं। क्या कोई बेहतर विकल्प है? क्या मुझे उन सभी चेतावनी को ठीक करना होगा या अगले बीटा के लिए बेहतर प्रतीक्षा करनी होगी?

Question 2

यह एक बदलाव है जो इस पुल अनुरोध में इस तथ्य के कारण किया गया था कि Optional(...)परिणामी स्ट्रिंग में प्रक्षेप अक्सर अवांछनीय होता है, और विशेष रूप से अंतर्निहित अलिखित वैकल्पिक के साथ मामलों में आश्चर्यजनक हो सकता है । इस बदलाव की पूरी चर्चा आप यहां मेलिंग सूची पर देख सकते हैं ।

जैसा कि पुल अनुरोध चर्चा में उल्लेख किया गया है (हालांकि दुर्भाग्य से एक्सकोड द्वारा नहीं) - एक थोड़ा अच्छा तरीका यह है कि इसके उपयोग की तुलना में चेतावनी को चुप String(describing:)करने के लिए आप जो भी कर रहे हैं उसके वैकल्पिक प्रकार में एक डाली जोड़ सकते हैं, उदाहरण के लिए:

var i: Int? = 5
var d: Double? = nil

print("description of i: \(i as Int?)")    // description of i: Optional(5)
print("description of d: \(d as Double?)") // description of d: nil

जिसे सामान्यीकृत भी किया जा सकता है as Optional:

print("description of i: \(i as Optional)") // description of i: Optional(5)
print("description of d: \(d as Optional)") // description of d: nil

स्विफ्ट 5 में, नए स्ट्रिंग प्रक्षेप प्रणाली द्वारा शुरू की के साथ एसई 0228 , एक और विकल्प एक कस्टम जोड़ने के लिए है appendInterpolationके लिए अधिभार DefaultStringInterpolation:

extension DefaultStringInterpolation {
  mutating func appendInterpolation<T>(optional: T?) {
    appendInterpolation(String(describing: optional))
  }
}

var i: Int? = 5
var d: Double? = nil

print("description of i: \(optional: i)") // description of i: Optional(5)
print("description of d: \(optional: d)") // description of d: nil

और, यदि वांछित है, तो आप पूरी तरह से एक मॉड्यूल (या किसी विशेष फ़ाइल के भीतर यदि आप इसे चिह्नित करते हैं fileprivate) के भीतर चेतावनी को अक्षम करने के लिए तर्क लेबल को भी हटा सकते हैं :

extension DefaultStringInterpolation {
  mutating func appendInterpolation<T>(_ optional: T?) {
    appendInterpolation(String(describing: optional))
  }
}

var i: Int? = 5
var d: Double? = nil

print("description of i: \(i)") // description of i: Optional(5)
print("description of d: \(d)") // description of d: nil

हालांकि व्यक्तिगत रूप से मैं तर्क लेबल रखना पसंद करूंगा।

Question 3

इस मुद्दे से निपटने के दो आसान तरीके।

विकल्प 1:

पहला "बल-अलिखित" द्वारा होगा जो आप एक बैंग (!) का उपयोग करके वापस करना चाहेंगे ।

var someValue: Int? = 5
print(someValue!)

आउटपुट:

विकल्प 2:

दूसरा तरीका, जो बेहतर तरीका हो सकता है - वह है "सुरक्षित रूप से अनचाहे" जिस मूल्य को आप वापस करना चाहते हैं।

var someValue: Int? = 5

if let newValue = someValue {
    print(newValue)
}

आउटपुट:

विकल्प 2 के साथ जाने की सलाह देंगे।

युक्ति: जहाँ हम संभव नहीं हैं यदि हम हमेशा अपरिवर्तित रहने का मूल्य नहीं रखेंगे, तो बल प्रयोग से बचें!

Question 4

स्ट्रिंग का उपयोग करके लगता है (वर्णन करना: वैकल्पिक) सबसे सरल है।

डिफ़ॉल्ट मान ?? गैर-स्ट्रिंग्स जैसे इंट के लिए कोई मतलब नहीं है।
अगर Int nil है, तो आप चाहते हैं कि लॉग 'nil' को दूसरे Int '0' के लिए डिफॉल्ट न दिखाए।

परीक्षण करने के लिए कुछ खेल का मैदान कोड:

var optionalString : String? = nil
var optionalInt : Int? = nil

var description_ = ""
description_ = description_ + "optionalString: \(String(describing: optionalString))\r"
description_ = description_ + "   optionalInt: \(String(describing: optionalInt))\r"

print(description_)

उत्पादन

optionalString: nil
optionalInt: nil

Question 5

Xcode 8.3 में अपडेट करने और बहुत सारे चेतावनी संदेश प्राप्त करने के बाद, मैं निम्नलिखित के साथ आया, जो मूल आउटपुट व्यवहार की तरह अधिक है, इसमें जोड़ना आसान है, कोड और आउटपुट दोनों में "स्ट्रिंग (वर्णन करना :)") का उपयोग करने की क्रिया को कम करता है ।

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

extension Optional {
    var orNil : String {
        if self == nil {
            return "nil"
        }
        if "\(Wrapped.self)" == "String" {
            return "\"\(self!)\""
        }
        return "\(self!)"
    }
}

और एक खेल के मैदान में उपयोग:

var s : String?
var i : Int?
var d : Double?

var mixed = "s = \(s.orNil)    i = \(i.orNil)   d = \(d.orNil)" // "s = nil    i = nil   d = nil"

d = 3
i = 5
s = ""
mixed = "s = \(s.orNil)    i = \(i.orNil)   d = \(d.orNil)" // "s = ""    i = 5   d = 3.0"

s = "Test"
d = nil
mixed = "s = \(s.orNil)    i = \(i.orNil)   d = \(d.orNil)" // "s = "Test"    i = 5   d = nil"

निम्नलिखित लिंक से मदद के लिए धन्यवाद:

चेक-अगर-चर-है-एक-वैकल्पिक और क्या-प्रकार यह wraps

Question 6

इसके लिए ओले बेगमेन का फिक्स देखें । मुझे यह पसंद है। यह एक ???ऑपरेटर बनाता है जिसे आप इस तरह उपयोग कर सकते हैं:

var someValue: Int? = 5
print("The value is \(someValue ??? "unknown")")
// → "The value is 5"
someValue = nil
print("The value is \(someValue ??? "unknown")")
// → "The value is unknown"

Question 7

इस चेतावनी वाले लाइन पर प्रदर्शित पीले त्रिकोण पर डबल क्लिक करें। यह FixIt को दो समाधानों के साथ दिखाएगा ।

String(describing:)इस चेतावनी को चुप करने के लिए उपयोग करें :

इसके उपयोग से यह बन जाएगा String(describing:<Variable>)

उदाहरण के लिए। :String(describing: employeeName)
default valueइस चेतावनी से बचने के लिए एक प्रदान करें :

इसके उपयोग से यह बन जाएगा (<Variable> ?? default value)

उदाहरण के लिए .: employeeName ?? “Anonymous” as! String

Question 8

स्विफ्ट 5

मेरा समाधान एक extensionअनकही Optionalवस्तु बना रहा है Any।

जब आप ऑब्जेक्ट को लॉग करते हैं या इसे प्रिंट करते हैं, तो आप वास्तविक objectया <nil>⭕️टेक्स्ट (विज़ुअल कैरेक्टर से संयोजन) देख सकते हैं । यह देखने में उपयोगी है, विशेष रूप से कंसोल लॉग में।

extension Optional {
    var logable: Any {
        switch self {
        case .none:
            return "<nil>|⭕️"
        case let .some(value):
            return value
        }
    }
}

// sample
var x: Int?
print("Logging optional without warning: \(x.logable)")
// → Logging optional without warning: <nil>|⭕️

Question 9

एक प्रक्षेप विधि बनाएँ जो एक अनाम पैरामीटर के साथ एक वैकल्पिक सामान्य प्रकार को स्वीकार करता है। आपके सभी कष्टप्रद चेतावनी जादुई रूप से गायब हो जाएंगे।

extension DefaultStringInterpolation {
  mutating func appendInterpolation<T>(_ optional: T?) {
    appendInterpolation(String(describing: optional))
  }
}