Swift4 노트-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

을 포함합니다.

iflet 처리가 비어 있을 수 있음

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 순환이 최소한 한 번 실행되도록 확보

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

매거 초기화: 값iflet을 통해 원시 값과 일치하는 매거 크기를 되돌려줍니다. 일치하는 등급이 없으면 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 문서의 코드를 이해하지 못했습니다