试想一下，在代码学习Swift！

文件

      https://itunes.apple.com/us/book/the-swift-programming-language/id881256329?mt=11

      http://download.csdn.net/detail/surfsky/7440835

 

 

helloWorld

    println("Hello, world")

 

 

-------------------------------------------------------------

基础

-------------------------------------------------------------

凝视

    //

    /**/

 

分号

    单行无需加分号

    多个语句放在一行，须要加分号

 

 

变量

    var myVariable = 42

 

常量

    let myConstant = 42

    let explicitDouble: Double = 70

 

 

-------------------------------------------------------------

数据类型

-------------------------------------------------------------

数字类型

    类型

          Int: Int32, Int64

          UInt: UInt32, Uint64

          Double

          Float

    各种表示方法

      let decimalInteger = 17

      let binaryInteger = 0b10001 // 17 in binary notation

      let octalInteger = 0o21 // 17 in octal notation

      let hexadecimalInteger = 0x11 // 17 in hexadecimal notation

      let decimalDouble = 12.1875

      let exponentDouble = 1.21875e1

      let hexadecimalDouble = 0xC.3p0

      let paddedDouble = 000123.456

      let oneMillion = 1_000_000

 

布尔（boolean）

    let orangesAreOrange = true

    let turnipsAreDelicious = false

 

向量

    let (statusCode, statusMessage) = (404, "Not Found")

    let (x, y) = (1, 2)

    let http200Status = (statusCode: 200, description: "OK")

    println("The status code is \(http200Status.statusCode)")

 

字符串

    let label = "The width is "

    let width = 94

    let widthLabel = label + String(width)

    字符串相加

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

    shoppingList = []

 

字典

    let emptyDictionary = Dictionary<String, Float>()

    emptyDictionary = [:]

 

 

空（nil）和可为空对象

    var serverResponseCode: Int? = 404

    serverResponseCode = nil

    ----------------------------------------------    

    let possibleString: String? = "An optional string."

    println(possibleString!)

    let assumedString: String! = "An implicitly unwrapped optional string."

    println(assumedString)

 

     

 

     

-------------------------------------------------------------

数据流

-------------------------------------------------------------

if

    if i == 1 {

        // this example will compile successfully

    }

 

 

switch

    let vegetable = "red pepper"

    switch vegetable 

    {

        case "celery":

            let vegetableComment = "Add some raisins and make ants on a log."

        case "cucumber", "watercress":

            let vegetableComment = "That would make a good tea sandwich."

        case let x where x.hasSuffix("pepper"):

            let vegetableComment = "Is it a spicy \(x)?

"

        default:

            let vegetableComment = "Everything tastes good in soup."

    }

 

 

for

    var firstForLoop = 0

    for var i = 0; i < 3; ++i {

        firstForLoop += 1

    }

    for i in 0..3 {

        firstForLoop += i

    }

 

 

for(遍历数组)

    let individualScores = [75, 43, 103, 87, 12]

    var teamScore = 0

    for score in individualScores {

        if score > 50 {

            teamScore += 3

        } else {

            teamScore += 1

        }

    }

     

for(遍历字典)

    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

            }

        }

    }

 

 

 

while

    var n = 2

    while n < 100 {

        n = n * 2

    }

 

do...while

    var m = 2

    do {

        m = m * 2

    } while m < 100

     

     

断言（assert）

    let age = -3

    assert(age >= 0, "A person's age cannot be less than zero")

 

     

-------------------------------------------------------------

函数

-------------------------------------------------------------

函数定义和调用

    func greet(name: String, day: String) -> String {

        return "Hello \(name), today is \(day)."

    }

    greet("Bob", "Tuesday")

 

 

返回多个数据

    func getGasPrices() -> (Double, Double, Double) {

        return (3.59, 3.69, 3.79)

    }

    getGasPrices()

 

不限个数參数

    func sumOf(numbers: Int...) -> Int {

        var sum = 0

        for number in numbers {

            sum += number

        }

        return sum

    }

    sumOf()

    sumOf(42, 597, 12)

 

 

嵌套函数

    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

    }

    var increment = makeIncrementer()

    increment(7)

 

函数作为输入參数（类似lambda表达式）

    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]

    hasAnyMatches(numbers, lessThanTen)

 

闭包

    numbers.map({

        (number: Int) -> Int in

        let result = 3 * number

        return result

    })

 

用编号替代名字

    sort([1, 5, 3, 12, 2]) { $0 > $1 }

 

 

-------------------------------------------------------------

对象和类

-------------------------------------------------------------

类定义

    class Shape {

        var numberOfSides: Int = 0

        var name: String

        init(name: String) {

            self.name = name

        }

        func simpleDescription() -> String {

            return "A shape with \(numberOfSides) sides."

        }

    }

 

使用

    var shape = Shape()

    shape.numberOfSides = 7

    var shapeDescription = shape.simpleDescription()

 

 

self/super

    self  -> this

    super -> parent

     

 

继承

    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 square")

    test.area()

    test.simpleDescription()

 

属性

    var perimeter: Double {

        get {return 3.0 * sideLength}

        set {sideLength = newValue / 3.0}

    }

 

 

方法重载

    override func simpleDescription() -> String {

        return "An equilateral triagle with sides of length \(sideLength)."

    }

 

willSet和didSet（属性的值设置前后处理）

    var triangle: EquilateralTriangle {

        willSet {

            square.sideLength = newValue.sideLength

        }

    }

 

可为空对象方法调用

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

    let sideLength = optionalSquare?.sideLength

 

 

 

-------------------------------------------------------------

枚举和结构体

-------------------------------------------------------------

枚举

    enum Rank: Int {

        case Ace = 1

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

            }

        }

    }

    let ace = Rank.Ace           

    let aceRawValue = ace.toRaw()

    if let convertedRank = Rank.fromRaw(3) {

        let threeDescription = convertedRank.simpleDescription()

    }

 

 

看得有点晕

    enum ServerResponse {

        case Result(String, String)

        case Error(String)

    }

    let success = ServerResponse.Result("6:00 am", "8:09 pm")

    let failure = ServerResponse.Error("Out of cheese.")

     

    switch success {

        case let .Result(sunrise, sunset):

        let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."

        case let .Error(error):

    }

 

 

结构体

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

版权声明：本文博客原创文章，博客，未经同意，不得转载。