Swift学习笔记

打印常量/变量值使用 \()

    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 = Dictionary<String, Float>()

2 Control Flow
条件判断 if / switch
循环控制 for-in for  while  do-while
   

 let individualScores = [75, 43, 103, 87, 12]
    var teamScore = 0
    for score in individualScores {
    if score > 50 {
    teamScore += 3
    } else {
    teamScore += 1
    }
    }
    teamScore


switch case
    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-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
    }
    }
    }
    largest


while/do-while
var m = 2
do {
m = m * 2
} while m < 100
m
for 

传统格式：
var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop
新的格式：
var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop


3 Functions and Closures
    函数名(参数1，参数2)->返回类型
 

   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)<pre name="code" class="objc">    class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) {
    self.name = name
    }
    func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
    }
    }

用另一个函数作参数：

    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 in 3 * number })


sort([1, 5, 3, 12, 2]) { $0 > $1 }
4 Objects and Classes
类实现.构造和析构函数 init/deinit

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

类使用:

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

类的继承和函数重载：

<pre name="code" class="objc">class EquilateralTriangle: NamedShape {
   var sideLength: Double = 0.0

   子类中初始化需要执行：
   1）设置子类属性值
   2）父类初始化
   3）设置父类属性值
 

  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 triagle with sides of length \(sideLength)."
  }
}

预设置 willSet和 didSet
 

willSet {
square.sideLength = newValue.sideLength
}


When working with optional values, you can write ? before operations like methods, properties, and subscripting. If the value before the ? is nil, everything after the ? is ignored and the value of the whole expression is nil. Otherwise, the optional value is unwrapped, and everything after the ? acts on the unwrapped value. In both cases, the value of the whole expression is an optional value.
    let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
    let sideLength = optionalSquare?.sideLength

5 Enumerations and Structures
enum的定义和使用

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

enum值和raw值的转换（toRaw和fromRaw）
  

  if let convertedRank = Rank.fromRaw(3) {
    let threeDescription = convertedRank.simpleDescription()
    }

struct 和class的区别：
struct使用的时候是拷贝，class使用的时候是引用。


6 Protocols and Extensions
声明一个protocol

  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 structure"
    mutating func adjust() {
    simpleDescription += " (adjusted)"
    }
    }
    var b = SimpleStructure()
    b.adjust()
    let bDescription = b.simpleDescription
Notice the use of the mutating keyword in the declaration of SimpleStructure to mark a method that modifies the structure.


Use extension to add functionality to an existing type
    extension Int: ExampleProtocol {
    var simpleDescription: String {
    return "The number \(self)"
    }
    mutating func adjust() {
    self += 42
    }
    }
   simpleDescription

7  Generics
参数类型待定：

    func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
    result += item
    }
    return result
    }
    repeat("knock", 4)

使用where带参数列表：

    func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
    for rhsItem in rhs {
    if lhsItem == rhsItem {
    return true
    }
    }
    }
    return false
    }
    anyCommonElements([1, 2, 3], [3])