Interview: Schnell. Fragen und Antworten

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

In diesem Fall können Sie noch kürzer:

  animals.sort() 

- Sortiert aufsteigend, funktioniert für Typen, die Comparable implementieren.

 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) 

• Wenn Sie eine Eigenschaft nicht initialisieren können, die zum Zeitpunkt der Erstellung nicht Null ist. Ein typisches Beispiel ist die Steckdose bei Interface Builder, die immer nach ihrem Eigentümer initialisiert wird. In diesem speziellen Fall, wenn in Interface Builder alles richtig konfiguriert ist, ist sichergestellt, dass die Steckdose vor der Verwendung nicht Null ist.
• um das Problem der Schleife starker Referenzen zu lösen, wenn zwei Instanzen von Klassen aufeinander verweisen und eine Nicht-Null-Referenz auf eine andere Instanz erforderlich ist. In diesem Fall markieren Sie den Link auf der einen Seite als nicht besessen und verwenden auf der anderen Seite die implizite optionale Erweiterung.

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