变量申明

变量用var，常量用let；可以显示指明变量数据类型，也可以隐式由变量赋值决定。如果是可以为nil的变量，需要用可选符号?修饰。

 let a: NSInteger = 12
    var b = 13
    b = 15
    print(a+b)
    //2***********?
    var mayNilStr: String? = "hello"
//    var str: String = "world"
    mayNilStr = nil
//    str = nil
    print("\(mayNilStr)")
    //3********** ??(如果变量为nil，则取？？之后的值)
    var yourName :String? = nil
    yourName = "Tom"
    let defaultName = "Jack"
    let greet = "hello \(yourName ?? defaultName)"
    print(greet)

数组和字典

数组和字典申明时可以显示指明元素、键值的数据类型，也可以隐式由包含的元素决定。

//1.可变数组和字典
var shopping = ["catfish","water","tulips","blue paint"]
shopping[0] = "beer"
var dic1 = ["name": "Jack",
            "age": 12,
            "school": "Harverd"]
dic1["key1"] = 8888.88
print("shopping arr \(shopping)")
print("dic1 list is \(dic1)")

//2.空数组和空字典
var emptyArray = [String]()
var emptyDictionary = [String:Float]()
emptyArray.append("111")
emptyArray.insert("222", atIndex: 1)
emptyDictionary["salary"] = 112.0

/*
var shoppingList = []
var dicList = [:]
*/
print(emptyArray)
print(emptyDictionary)

类型转换

不同数据类型的转换，可以通过函数或者转义符实现。

//1*********  函数
let label = "the width is "
let width = 12
let widthLabel = label + String(width)
print(widthLabel)
//2**********  \()
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples.\n"
let orangeSummary = "I have \(oranges) oranges\n"
let summary = "I have \(apples+oranges) pieces of fruit."
print(appleSummary)
print(orangeSummary)
print(summary)

条件控制和

for循环中，..<表示小于，...表示小于等于。switch语句不在需要break并且支持模糊匹配等。

//1
   let scores = [12,35,86,98,13]
   for score in scores {
       if score < 60 {
           print("\(score) is C")
       }else if score < 80 {
           print("\(score) is B")
       }else {
           print("\(score) is A")
       }
   }

   //2
   var c = 1000;
   while (c > 0) {
       c -= 100;
   }
   print("final c value is \(c)")

   //3
   let vegetable = "red pepper"
   switch vegetable {
   case "celery" :
       print("Add some rausins 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("It is a spicy \(x)?")
   default :
       print("Everything tastes good in soup")
   }

   //4
   let numbers = [
       "num1":[1,2,3,5,6,4,9,8],
       "num2":[12,15,17,86,23,11,90],
       "num3":[876,123,234,124,242,634]
   ]
   var largestNum = 0
   for (_,kind) in numbers {
       for num in kind {
           if (num > largestNum) {
               largestNum = num;
           }
       }
   }
   print("the largest num is \(largestNum)");

   //5
   var n = 2
   repeat {
       n = n*2
   }while n < 100
   print("final n is \(n)")

   //6 ******  ..<小于   ...小于等于
   var loop1 = 0
   for i in 0..<4 {
       loop1 += i;
   }
   print("loop1 value is \(loop1)")

   var loop2 = 0
   for i in 0...4 {
       loop2 += i;
   }
   print("loop1 value is \(loop2)")

函数

函数参数动态确定。可以作为参数或者返回值。

func parameterFunction(name: String,age: Int16) -> String {
    return "your name is \(name), and age is \(age)"
}

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

func testDynamicParameter(numbers: Int...) -> Int {
    var sum = 0
    for num in numbers {
        sum += num
    }
    if numbers.count > 0 {
        return sum/numbers.count
    }
    return 0
}

/**
 返回值为函数
 */
func functionCanbeReturnType() -> ((Int) -> Int) {
    func theReturnFunc(age: Int) -> Int {
        return age + 5
    }
    return theReturnFunc
}

/**
 参数为函数
 */
func functionCanbeParameter(lists:[Int],condition:((Int) -> Bool)) -> Bool {
    for item in lists {
        if (condition(item)) {
            return true
        }
    }
    return false
}

类

类中可以声明属性和方法等，可以创建构造函数和析构函数等

//类
class Shape {
    //property
    var numberOfSides = 0
    var name: String? = nil
    var age: Int
    let extralProperty = 1

    //构造函数
    init(name: String){
        self.name = name
        self.age = 12
    }

    init(age: Int) {
        self.age = age;
    }

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    //实例销毁前的cleanup方法
    deinit {
        print("deinit method \(self.name)")
    }

    //fucntion
    func shapeDescription() ->String {
        return "the shape side num is \(numberOfSides),name is \(name)"
    }
}

继承

class Squar: Shape {
    var sideLength: Double = 0.0

    //property set and get method
    var perimeter: Double {
        get {
            return 4*sideLength
        }

        set {
            sideLength = sideLength/2
        }
    }

    //enum(支持嵌入方法)
    enum Rank: Int {
        case Ace = 1
        case Two,Three,Four,Five,Six,Seven,Eight
        case Jack,Tom

        func simpleDescription() -> String {
            switch self {
            case .Ace: return "ace"
            case .Jack: return "jack"
            case .Tom: return "tom"
            default: return String(self.rawValue)
            }
        }
    }

    //struct
    struct Card {
        var rank: Rank

        func simpleDescription() -> String {
            return "The \(rank.simpleDescription())"
        }
    }

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength;
        super.init(name: name)
    }

    override func shapeDescription() -> String {
        return "override shape description"
    }
}

协议

//声明协议
protocol testProtocol {
    var simpleProtocolMethod1: String {
        get
    }
    mutating func adjust()
}

//实现协议
class complishProtocol: testProtocol {
    var simpleProtocolMethod1: String = "a very simple class"
    func adjust() {
        simpleProtocolMethod1 += " Now 100% adjus"
    }
}