साक्षात्कार: स्विफ्ट क्यू एंड ए

 var tutorial2 = tutorial1 

 view2 = view1 // : view2 is immutable 

 animals.sort { (one, two) in return one < two } 

 animals.sort { return $0 < $1 } 

 animals.sort { $0 < $1 } 

 animals.sort(by: <) 

इस मामले में, आप भी कम कर सकते हैं:

  animals.sort() 

- आरोही सॉर्ट करता है, तुलनीय को लागू करने वाले प्रकारों के लिए काम करता है।

 func areIntEqual(_ x: Int, _ y: Int) -> Bool { return x == y } func areStringsEqual(_ x: String, _ y: String) -> Bool { return x == y } areStringsEqual("ray", "ray") // true areIntEqual(1, 1) // true 

 func areTheyEqual<T: Equatable>(_ x: T, _ y: T) -> Bool { return x == y } areTheyEqual("ray", "ray") areTheyEqual(1, 1) 

• जब आप एक ऐसी संपत्ति को आरंभीकृत नहीं कर सकते हैं जो निर्माण के समय शून्य नहीं है। एक विशिष्ट उदाहरण इंटरफ़ेस बिल्डर पर आउटलेट है , जो हमेशा इसके मालिक के बाद शुरू होता है। इस विशेष मामले में, यदि इंटरफ़ेस बिल्डर में सब कुछ सही ढंग से कॉन्फ़िगर किया गया है, तो आपको गारंटी दी जाती है कि उपयोग करने से पहले आउटलेट गैर-शून्य है।
• मजबूत संदर्भों के लूप की समस्या को हल करने के लिए, जब कक्षाओं के दो उदाहरण एक दूसरे को संदर्भित करते हैं और गैर-शून्य संदर्भ से दूसरे उदाहरण की आवश्यकता होती है। इस स्थिति में, आप एक तरफ लिंक को अज्ञात के रूप में चिह्नित करते हैं, और दूसरी तरफ अंतर्निहित वैकल्पिक विस्तार का उपयोग करते हैं।

 let a: String = x! 

 var a = x! 

 if let a = x { print("x was successfully unwrapped and is = \(a)") } 

 let a = x?.count 

 let a = x ?? "" 

 guard let a = x else { return } 

 if case let a? = x { print(a) } 

 nil == .none 

 var thing = "cars" let closure = { print("I love \(thing)") } thing = "airplanes" closure() // Prints: "I love airplanes" 

 func countUniques<T: Hashable>(_ array: Array<T>) -> Int { return Set(array).count } 

 extension Array where Element: Comparable { func countUniques() -> Int { let sortedValues = sorted() let initial: (Element?, Int) = (.none, 0) let reduced = sortedValues.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) } return reduced.1 } } 

 guard dividend != nil else { return nil } 

 guard let dividend = dividend else { return .none } 

 func divide(_ dividend: Double?, by divisor: Double?) -> Double? { guard let dividend = dividend else { return nil } guard let divisor = divisor else { return nil } guard divisor != 0 else { return nil } return dividend / divisor } 

 func divide(_ dividend: Double?, by divisor: Double?) -> Double? { guard let dividend = dividend, let divisor = divisor, divisor != 0 else { return nil } return dividend / divisor } 

 func divide(_ dividend: Double?, by divisor: Double?) -> Double? { if let dividend = dividend, let divisor = divisor, divisor != 0 { return dividend / divisor } else { return nil } } 

 let higherNumber = number + 5 

 class Star { class func spin() {} static func illuminate() {} } class Sun : Star { override class func spin() { super.spin() } // error: class method overrides a 'final' class method override static func illuminate() { super.illuminate() } } 

 extension Thermometer: ExpressibleByFloatLiteral { public init(floatLiteral value: FloatLiteralType) { self.init(temperature: value) } } 

 var thermometer: Thermometer = 56.8 

 precedencegroup ExponentPrecedence { higherThan: MultiplicationPrecedence associativity: right } infix operator ^^: ExponentPrecedence 

 func ^^(base: Int, exponent: Int) -> Int { let l = Double(base) let r = Double(exponent) let p = pow(l, r) return Int(p) } 

 protocol Pizzeria { func makePizza(_ ingredients: [String]) -> Pizza } extension Pizzeria { func makeMargherita() -> Pizza { return makePizza(["tomato", "mozzarella"]) } } 

 func showKitten(kitten: Kitten?) { guard let k = kitten else { print("There is no kitten") return } print(k) } 

 enum KittenError: Error { case NoKitten } struct Kitten { } func showKitten(kitten: Kitten?) throws { guard let k = kitten else { print("There is no kitten") throw KittenError.NoKitten } print(k) } try showKitten(kitten: nil) 

 struct Kitten { } func showKitten(kitten: Kitten?) { guard let k = kitten else { print("There is no kitten") fatalError() } print(k) } 

 UInt(bitPattern: Int) 

 let myNegative = UInt(bitPattern: -1) 

 enum List<T> { indirect case node(T, List<T>) }