Swift 4ノート-Tour

以前のバージョン

Swift4

コードアドレスのMarkdownはどのようにページ内のジャンプを実现しますか???日常メモ、参考

のみ

Simple Values

var

let定数

宣言タイプ

let explicitDouble: Double = 70

タイプ変換1

let label = "The width is"
let width = 94
let widthLabel = label + String(width)

タイプ変換2

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

配列および辞書

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
     
var occupations = [
        "Malcolm": "Captain",
        "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

空配列、空辞書

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

Control Flow

? 値のタイプの後に疑問符を書きますか?値をオプションとしてマークする、オプション値に値を含める、またはnil

を含む

if let処理が空の値である可能性がある

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello,\(name)"
}
else {
    print(greeting)
}

?? オプションの値を処理し、前の値が欠落している場合は、後の値

を使用します.

let nickName: String? = nil
let fullName: String? = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

switch構文は、任意のタイプのデータと様々な比較操作

をサポートする.

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup")
}

for-in反復辞書

let interestingNumbers = [
    "Prime" : [2, 3, 5, 7, 11, 13,],
    "Fibonacci" : [1, 1, 2, 3, 5, 8],
    "Square" : [1, 4, 9, 16, 25]
]

var largest = 0

for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

while、repeat-while repeat-whileは、サイクルが少なくとも1回

実行されることを保証する.

var n = 2
while n < 2 {
    n *= 2
}
print(n)

var m = 2
repeat {
    m *= 2
}while m < 2
print(m)

.. ..

for i in 0..<4 {
    print(i)
}

for i in 0...4 {
    print(i)
}

Functions and Closures

関数

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)"
}
greet(person: "Bob", day: "Tuesday")

「

」--パラメータラベルのデフォルトでは、パラメータのラベルとしてパラメータ名が使用されます.パラメータ名の前にカスタムパラメータラベルを作成するか、書き込み_パラメータラベルは使用しません.

func greet2(_ person: String, on day: String) -> String {
    return "Hi \(person), today is \(day)"
}
greet2("John", on: "Wednesday")

で返される値がタプルの関数タプルの要素は、名前または数値で

を参照できます.

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    
    for score in scores {
        if score > max {
            max = score
        }
        else if score < min {
            min = score
        }
        sum += score
    }
    
    return (min,max,sum)
}

let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

ネスト関数は、ネスト関数を使用して、長いまたは複雑な関数でコードを整理することができる.

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

戻り値タイプが関数である関数

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne(number:)
}
var increment = makeIncrementer()
increment(7)

パラメータタイプが関数の関数

// ， 
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}

func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]

// 10 
hasAnyMatches(list: numbers, condition: lessThanTen(number:))

閉パケットinを使用してパラメータと戻りタイプを本文から

分離する

let myNumbers = numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})
print(myNumbers)

閉パケット省略パラメータまたは戻りタイプ

let mappedNumbers = numbers.map({ number in 3 * number})
print(mappedNumbers)

閉パッケージの略語--$0は、名前を付ける必要がなく、数値でパラメータを参照します.また、外側カッコ()

を省略することもできます.

let mappedNumbers2 = numbers.map({ 3 * $0})
print(mappedNumbers2)

// 
let sortedNumbers = numbers.sorted {$0 > $1}
print(sortedNumbers)

Objects and Classes

クラスclass+クラス名

を作成

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides"
    }
}

クラスオブジェクトポイント構文アクセス属性とメソッド

を作成する

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

initメソッド

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

var namedShape = NamedShape(name: "tom")
namedShape.simpleDescription()

クラス継承

override親を書き換える方法

class Square: NamedShape {
    var sideLength: Double
    
    init(sideLength: Double, name:String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    
    func area() -> Double {
        return sideLength * sideLength
    }
    
    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}

let test = Square(sideLength: 5.2, name: "my test quare")
test.area()
test.simpleDescription()

属性のgetとsetメソッドsetの後の新しい属性値の暗黙名はnewValue

である.

class EqualateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)"
    }
}

var triangle = EqualateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

自分で新しい値に名前を付けることもできます

class EqualateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set(myValue) {
            sideLength = myValue / 3.0
        }
    }
    
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)"
    }
}

willSetとdidSet監視属性の初期化以外の属性値変化

class TriangleAndSquare {
    var triangle: EqualateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EqualateralTriangle(sideLength: size, name: name)
    }
    
}

var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)

オプション値タイプのオブジェクトポイント構文呼び出し属性またはメソッド

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

Enumerations and Structures

列挙(enum列挙名:列挙タイプ)Intタイプ列挙のデフォルトの元の値は0です.列挙タイプを指定しないとrawValue属性を使用できない

は、明示的に値を指定することで変更できます.

enum Rank: Int {
    case ace = 3
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
    func simpleDescription() -> String {
        switch self {
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}
let ace = Rank.five
let aceRawValue = ace.rawValue
print(ace.simpleDescription())

enum rank {
    case one
    case two
}
let one = rank.one
//   
//let oneValue = one.rawValue

列挙初期化:if let値によって元の値と一致する列挙サイズが返され、一致するレベルがない場合はnilが返されます.

if let convertedRank = Rank(rawValue: 4) {
    let threeDescription = convertedRank.simpleDescription()
    
}

if let convertedRank2 = Rank(rawValue: 15) {
    let threeDescription = convertedRank2.simpleDescription()
}
else {
    print("nil")
}

は、列挙に初期値

を付与しなくてもよい.

enum Suit {
    //       
    case spades, hearts, diamonds, clubs
    func simpleDescription() -> String {
        switch self {
        case .spades:
            return "spades"
        case .hearts:
            return "hearts"
        case .diamonds:
            return "diamonds"
        case .clubs:
            return "clubs"
        }
    }
    func color() -> String {
        switch self {
        case .spades, .clubs:
            return "blackColor"
        case .hearts, .diamonds:
            return "redColor"
        }
    }
}
let hearts = Suit.hearts
let heartDescription = hearts.simpleDescription()
let heartsColor = hearts.color()

実際のニーズに基づいて列挙値のタイプを決定するために使用する必要がある場合、データ

が抽出される.

enum ServerResponse {
    case result(String, String)
    case failure(String)
    case disconnect(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")
let network = ServerResponse.disconnect("404")

switch network {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure... \(message)")
case let .disconnect(cause):
    print("Network failure \(cause)")
}

構造体はクラスと似ています.異なる点は、コードに構造が伝達されると、常に複製され、クラスは参照によって伝達されます.

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

Protocols and Extensions

プロトコルクラス、構造体、列挙はいずれもmutating機構体がプロトコルを遵守できる場合に

を用いる.

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

// 
class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

// 
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple struture"
    mutating func adjust() {
        simpleDescription += "(adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

// 
enum SimpleEnum: ExampleProtocol {
    mutating func adjust() {
        switch self {
        case let .Result(text):
            self = .Result(text + "(first case adjusted)")
        case let .Failure(text):
            self = .Failure(text + "(second case adjusted)")
        }
    }

    case Result(String)
    case Failure(String)
    
    var simpleDescription: String {
        get {
            switch self {
            case .Result("123"):
                return "13"
            case .Failure(" "):
                return " "
            default:
                return "get error"
            }
        }
        set {
            switch self {
            case .Result("123"):
                self = .Result("12")
            case .Failure(" "):
                self = .Failure("312")
            default:
                self = .Failure("3333")
            }
        }
    }
}

var enumConformToProtocolTest = SimpleEnum.Failure(" ")
enumConformToProtocolTest.adjust()
print("\(enumConformToProtocolTest)")
enumConformToProtocolTest.simpleDescription
enumConformToProtocolTest.simpleDescription = "test"

enumConformToProtocolTest = SimpleEnum.Result("ThirdVal")
enumConformToProtocolTest.simpleDescription
enumConformToProtocolTest.adjust()
enumConformToProtocolTest.simpleDescription

拡張は、システムクラス

を含む既存のタイプをプロトコルに遵守させ、機能を実現することができる.

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
var textExtension = 7
textExtension.simpleDescription
textExtension.adjust()
textExtension.simpleDescription

使用タイプがプロトコルタイプの値である場合、プロトコル定義以外の方法は使用できません.

let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
//print(protocolValue.anotherProperty)

Error Handling

Errorプロトコルは、このプロトコルを継承することによって、処理異常の列挙

を作成する.

enum PrinterError: Error {
   case outOfPaper
   case noToner
   case onFire
}

throws異常を放出する可能性のある関数を構築するには

を使用します.

throw異常

を放出できる

func mySend(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    else if printerName == "Gutenberg" {
        throw PrinterError.outOfPaper
    }
    else if printerName == "Dongdong" {
        throw PrinterError.onFire
    }
    return "Job sent"
}

tryタグは、異常なコード

を投げ出す可能性がある

do-catch文doブロック:try文catchブロックを書く:異常処理

do {
    try mySend(job: 5, toPrinter: "Never Has Toner")
} catch {
    print(error)
}

do {
    try mySend(job: 5, toPrinter: "Bi sheng")
} catch {
    print(error)
}

複数のcatchブロックはswitchと類似しており、処理エラー

do {
    try mySend(job: 15, toPrinter: "Gutenberg")
} catch PrinterError.outOfPaper {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}

try? 結果をオプションに変換します.関数がエラーを投げ出すと、特定のエラーが破棄され、nilとなります.そうでなければ、結果はオプションです.

let printerSuccess = try? mySend(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? mySend(job: 1885, toPrinter: "Never Has Toner")

deferは実行を遅らせ、呼び出し順序は下から上へ

である.

func lookforSomething(name: String) throws {
    print("1-1")
    
    if name == "" {
        print("2-1")
        defer {
            print("2-2")
        }
        print("2-3")
    }
    print("1-2")
    defer {
        print("1-3")
    }
    print("1-4")
    
    if name == "hello" {
        print("3-1")
        defer {
            print("3-2")
        }
        print("3-3")
        defer {
            print("3-4")
        }
    }
    
    defer {
        print("5-1")
    }
}
print("--------")
try? lookforSomething(name: "")
print("--------")
try? lookforSomething(name: "hello")

Generics

<>

汎用パラメータ

func makeArray(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..

汎用列挙

enum OptionalValue {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue = .none
possibleInteger = .some(100)

whereドキュメントのコードは

を理解していません.