Wawancara: Cepat. Tanya Jawab

 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: <) 

Dalam hal ini, Anda bahkan bisa lebih pendek:

  animals.sort() 

- Macam naik, bekerja untuk jenis yang mengimplementasikan Sebanding.

 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) 

• ketika Anda tidak dapat menginisialisasi properti yang tidak nol pada saat pembuatan. Contoh khas adalah outlet di Interface Builder, yang selalu diinisialisasi setelah pemiliknya. Dalam kasus khusus ini, jika semuanya dikonfigurasikan dengan benar di Interface Builder, Anda dijamin bahwa outlet tidak nol sebelum menggunakannya.
• untuk menyelesaikan masalah loop dari referensi kuat ketika dua instance kelas mereferensi satu sama lain dan referensi non-nil ke instance lain diperlukan. Dalam hal ini, Anda menandai tautan di satu sisi sebagai tidak dimiliki , dan di sisi lain menggunakan ekspansi opsional implisit.

 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>) }