インタビュー：スウィフト。 質疑応答

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

-昇順で並べ替え、Comparableを実装する型で機能します。

 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) 

• 作成時にnilでないプロパティを初期化できない場合。 典型的な例は、Interface Builderのアウトレットです。これは、所有者の後に常に初期化されます。 この特別な場合、Interface Builderですべてが正しく設定されていれば、使用する前にアウトレットが非nilであることが保証されます。
• クラスの2つのインスタンスが相互に参照し、別のインスタンスへの非ゼロ参照が必要な場合の強参照ループの問題を解決します。 この場合、一方の側でリンクをunownedとしてマークし、反対側で暗黙的なオプションの拡張を使用します。

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