一.常量和变量
[代码]
let maximumNumberOfLoginAtAttempts = 10 #用let声明常量
var currentLoginAttempt = 0 #用var声明变量
［类型注释］
声明常量或者变量的时候提供类型注释，明确存储值的类型。常量或者变量名后依次添加 冒号，空格，类型名称来实现。
var welcomeMessage： String
welcomeMessage ＝ "Hello"
其实，可以不适用类型注释，因为在给常量或者变量提供初始值的时候，swift可以推测出他的类型。
［打印］
println(welcomeMessage) #打印变量
#字符串插值 用“ \(变量名) ” 来占位，swift会用变量的值来替换这个占位符
println("The current value of welcomeMessage is \(welcomeMessage)")
二.注释和分号
［注释］
//单行注释
／＊多行 注释＊／
［分号］
语句结束后不需要；去标志结束
但是如果多个语句写在一行，可以使用分号去分割
三.整数和浮点数
［整数］
swift提供 8 16 32 64位有符号和无符号的整数
Eg.
UInt8 8位无符号整数
Int32 32位有符号整数
let minValue = UInt8.min
let maxValue = UInt8.max
在swift中，UInt , Int类型 与 当前系统的字长相等，
32位系统，Int ＝＝＝ Int32
64位系统，Int ＝＝＝ Int64
［浮点数］
Double 64位浮点数
Float 32位浮点数
四.类型安全和类型推断
类型安全：编译的时候会进行类型检查，标记不匹配的类型。
类型推断：根据初值推断类型
［数字的字面量］
不带前缀的十进制数
0b前缀的二进制数
0o前缀的八进制数
0x前缀的十六进制数
［指数］
1.25e2 --> 1.25 * (10^2) #10进制基数是以10为底
1.25e-2 --> 1.25 * (10^-2)
0xFp2 --> 15 * (2^2) #16进制基数是以2为底
［数值类型的转化］
整数间的转化demo：
let twoThousand: UInt16 = 2_000 #_不会改变字面值，辅助提高可读性
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one) #加号两边都是UInt16可以相加
浮点数的转化demo
let three = 3
let pointNum = 3.1415
let pi = Double(three) + pointNum
let intPI = Int(pi)
上面这种SomeType(ofInitialValue) ［eg. Double(three) ］
是一种调用swift类型构造器的默认方法，我们为他传入初值，比如 UInt16 的构造器可以用来接收UInt8类型的值，
所以可以将UInt8类型的值转化成UInt16,此处必须传UInt16支持的类型，不是随便什么类型都可以的。当然可以通过扩展让构造器支持自定义类型。
[类型别名]
typealias AudioSample = UInt16
var maxUInt16Num = AudioSample.max #UInt16.max
五.布尔值
［声明和初始化］
let oragesAreOrange = true #不需要制指定具体的Bool类型，编 译器会帮助我们推断的
let oragesAreOrange = false
[判断语句与Bool]
错误写法：编译器不允许非bool值替换Bool,这个跟java等其他语言不同
let i = 1
if i {
}
正确写法：
if i==1 {}
六.元组Tuple
多个值组合成一个复合值，元组中的值可以是任何类型，并且可以是相互不同的类型。
场景：比如一个处理访问网页响应的函数，需要返回（Int,String）元组来描述成功失败的结果。
let http404Error = (404,"Not Found") #类型是 (Int , String)
#下标访问
println("The status code is \(http404Error.0)") #The status code is 404
println("The status msg is \(http404Error.1)") #The status msg is Not Found
let http200Status = (statusCode:200,description:"OK")
#元素名称访问
println("The status code is \(http200Status.statusCode)") #The status code is 200
println("The status msg is \(http200Status.description)") #The status msg is OK
let (statusCode,statusMsg) = http404Error
println("The status code is \(statusCode)") #The status code is 404
println("The status msg is \(statusMsg)") #The status msg is Not Found
let （justTheStatueCode, _) = http404Error # 用( _ ) 来忽略不关心的部分
println("The status code is \(justTheStatueCode)") #The status code is 404
七.Optional类型
Optional 类型是swift独有的 ，表示一个基础类型可能有值也可能没有值，当他没有值的时候就是nil。
［Optional定义］
定义一个Optional的值很容易，只需要在类型后面加上问号(?)就行了：
var str : String?
[显式拆包]
Optional类型的值不能被直接使用，当需要用时要显式拆包，以表明我知道这个Optional是一定有值的，拆包用！：
var str: String? = "Hello World!"
str! //Hello World!
ps，Optional类型其实是一个枚举
［隐式拆包］
除了显式拆包，Optional还提供了隐式拆包，通过在声明时的数据类型后面加一个感叹号(!)来实现：
var str: String! = "Hello World!"
str //Hello World!
［可选绑定Optional Binding］
如下两个demo来讲述一下为甚么要Optiona Binding：
看下面这个demo，当count != nil条件成真后接着在上下文中使用count，会被要求进行拆包 String(count!) ，
var count: Int?
count = 100
if count != nil {
"count is " + String(count!) //count is 100
} else {
"nil"
}
为了避免在条件判断语句后执行一次或更多次的拆包，Swift引进了Optional Binding，我们就可以这样做：
var count: Int?
count = 100
if let validCount = count {
"count is " + String(validCount) //count is 100
} else {
"nil"
}
［Optional Chaining］
暂时还没办法秒懂，mark一下，回头看
http://blog.csdn.net/zhangao0086/article/details/38640209
八.断言
用于运行时校验对应条件是否等于true的判断。
let age = -3
assert(age>=0,"A person age can not less than zero")
只有断言的条件 age>=0的时候 才会继续执行，否则 age是负数 断言是false 那么就会触发断言 程序终止。
九.运算符
赋值 let b = 10
算数 ＋ － ＊ ／
取余 ％
这个符号要特殊说明一下，因为他与别的语言的取模不一样，他表示（ a％b） a中包括多少个b 并返回剩余的值，公式是
a = (b * some multiplier) + remainder
9 = (4 * 2) + 1 [9 % 4 = 1]
-9=(4 * -2) + -1 [-9 % 4 = -1] #可见 跟正负号没甚么关系
8 = (2.5 * 3) + 0.5 #浮点数也一样的
自增 ++
自减 --
var a = 0
let b = ++a # b = 1 ; a = 1
let c = a++ # c = 1 ; a = 2
一元减 － 理解成负号
一元加 ＋ 对操作数没甚么变化
复合赋值运算 ＋＝
比较运算符 相等(a==b) 不相等(a!=b) 大于(a>b) 小于(a=b) 小于等于(a<=b) 完全等(===) 不完全等(!==)
三元条件 question ? answer1 : answer2
范围运算符 闭合范围运算符
for index in 1...5 {} #[1,5]
半闭合范围运算符
for index in 1..5 {} #[1,5)
逻辑运算符 逻辑非 !a
逻辑与 a &&
逻辑或 a || b
十.字符串和字符
［初始化空字符串］
var emptyString = ""
var anotherEmptyString = String()
if emptyString.isEmpty { #判断字符串为空
emptyString += "给字符串加点内容"
}
string是拷贝类型，即 赋值，参数传递等 string值是生成一个副本的，不是原始的版本。与Cocoa的NSString不同。
［字符］
let yenSign: Character = "¥" #需要类型注释 和 字面量
for character in "一个字符串" {
println(character)
}
#countElements统计字符数,全局函数
let unusualMsg = "slfjasfjslafjasfj"
println("\(countElements(unusualMsg))")
［字符串的比较］
字面值相等 if str1 == str2 { ...... }
前缀相等 if str1.hasPrefix("Act 1") { ........ }
后缀相等 if str1.hasSuffix("Act 1") { ........ }
字符串大写 let strUpper = str.uppercaseString
字符串小写 let strLower = str.lowercaseString
[Unicode]
关于Unicode 和 三种兼容unicode的字符串 自行查找资料进一步学习～
三种兼容字符串是：UTF-8 编码单元集合 for c in str.utf8 { ... }
UTF-16编码单元集合 for c in str.utf16 { ... }
21位Unicode标量值的结合 for c in str.unicodeScalars { ... }
十一.集合
集合有两类：
数组：相同类型的有序列表
字典：相同类型的无序列表
[数组定义]
var shoppingList: String[] = ["Eggs","Milk"]
var shoppingList: Array = ["Eggs","Milk"]
var shoppingList = ["Eggs","Milk"] #类型推断的存在，可以不用定义类型
var someInts = Int[] () #空数组
var someInts = [] #空数组
#构造器，创建有若干默认值的数组
var threeDoubles = Double[] (count:3 ,repeatedValue: 0.0)
var anotherThreeDoubles = Array(count:3 ,repeatedValue: 2.5)
var sixDoubles = threeDoubles + anotherThreeDoubles
[数组操作]
shoppingList.count #元素个数
shoppingList.isEmpty #是否为空
shoppingList.append("flower") #追加元素
shoppingList += "Baking Powder" #添加元素
shoppingList +=［"str1","str2"］ #添加多个
var firstItem ＝ shoppingList[0] #获取第一个元素
shoppingList[0] ＝ "Egg2016" #修改
shoppingList[4...6] = ["huhu","fafa"] #修改下标4到6的三个元素为 huhu , fafa
shoppingList.insert("tomato",atIndex: 0) #在指定位置插入
let mapleSyrup = shoppingList.removeAtIndex(0) ＃删除index位置的元素
let apples = shoppingList.removeLast() #删除最后一个元素，他会避免对count属性的查询，推荐使用这个 而不是 removeAtIndex(count-1)
[数组的遍历]
for item in shoppingList { ... }
#enumerate为每个元素返回一个元组
for (index,value) in enumerate(shoppingList) {
println("item \(index+1) : \(value) ")
}
[字典的定义]
var airports: Dictionary = ["a":"b","c":"d"]
var airports = ["a":"b","c":"d"]
var airports = Dictionary() #空字典
airports ＝ ［:］ # 空字典字面量[:]，前提是字典已经指定了类型
[字典的操作]
airports["e"] = "f" #追加，如果key不存在
airports["e"] = "g" ＃修改，如果key存在
#updateValue更新某个key对应的值，返回字典值类型的可选
if let oldValue = airports.updateValue("new value", forKey:"a") {
println("\(oldValue)")
}
#删除键值对
airports["APL"] = nil #通过设置值为nil来删除键值对
if let removedValue = airports.removeValueForKey("a"){
println(" \(removedValue) ")
}else {
println("does not contain value for key a")
}
［字典的遍历］
for (airportCode,airportName) in airports {
}
for airportCode in airports.keys { .... }
for airportName in airports.values { .... }
let airportCodes = Array(airports.keys)
let airportValues = Array(airports.values)
十二.流程控制
［for index in 集合］
for index in 1...5 { ... }
for _ in 1...n { ... } #下划线来占位，前提是 你需要用到集合中的元素值
for arrItem in oneArray ｛ ... ｝
for (code,msg) in oneDic { ... }
for character in "Hello" { ... }
=================================
[for 循环]
for var index = 0;index < 3; ++index { .... }
=================================
[while 循环]
while a < b {
a++
}
do{
a++
} while a十三.函数
［定义］
# ->指定函数的返回值
func sayHello (personName: String) -> String {
let greeting = "Hello," + personName + "!"
}
[参数]
#多参，返回多个返回值
func count(str: String,str2: String) -> (vowels: Int,consonants: Int,others: Int){
return (vowels, consonants, others)
}
#外参,外部参数名可以在函数调用的时候对于参数有更加直观的认识。即该参数名对外部可见。
import Foundation
func sayHello(username name:String)->String{
let result = "Hello," + name
return result
}
var nickname:String = "Jack"
println(sayHello(username: nickname)) #调用
#同时可以使某个参数名同时是内部参数名和外部参数名：使用#号。
func sayHello(#name:String)->String{
let result = "Hello," + name
return result
}
var nickname:String = "Jack"
println(sayHello(name: nickname))
#默认行参值,swift会给你定义的默认行参提供一个自动外部名，比如joiner 会有一个外部名 joiner，跟加#类似
fun join(str1: String,str2: String,joiner: String = "") -> String {
return str1 + joiner + str2
}
join("hello","world")
#
十四.闭包
十五.枚举
［定义］
enum CompassPoint {
case North
case South
case East
case West
}
var directionToHead = CompassPoint.West ＃directionToHead就是CompassPoint类型的变量
directionToHead = .East ＃directionToHead的类型是已知的了，所以你可以忽略它的类型来给他赋值了
［使用Switch语句来匹配枚举值］
directionToHead = .South
switch directionToHead {
case .North:
println("Lots of planets have a north")
case .South:
println("Watch out for penguins")
case .East:
println("Where the sun rises")
case .West:
println("Where the skies are blue")
}
［关联值］
enum Barcode {
case UPCA(Int, Int, Int)
case QRCode(String)
}
定义了一个叫做Barcode的枚举类型，它可以有一个UPCA成员，这个成员关联了一个包含三个整型数值的元组，同时这个枚举类型还有一个QRCode成员，关联了一个字符串。
var productBarcode = Barcode.UPCA(8, 85909_51226, 3) ＃可以用任意其中一个类型来生成一个新的
productBarcode = .QRCode("ABCDEFGHIJKLMNOP") ＃还可以被赋值为另一个类型，一旦定义了变量类型，再次赋值的时候不需要带类型Barcode
switch productBarcode
{
case .UPCA(let numberSystem, let identifier, let check): ＃let可以提前 let .UPCA(numberSystem, identifier, check)
println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
case .QRCode(let productCode): ＃let .QRCode(productCode)
println("QR code with value of \(productCode).")
}
［原始值］
enum ASCIIControlCharacter: Character {
case Tab = "\t"
case LineFeed = "\n"
case CarriageReturn = "\r"
}
enum Planet: Int {
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
let earthsOrder = Planet.Earth.toRaw() ＃toRaw()方法来获取他的原始值，eathsOrder is 3
let possiblePlanet = Planet.fromRaw(7) ＃fromRaw()方法来尝试通过一个原始值来寻找他所对应的枚举成员
＃ possiblePlanet is of type Planet? and equals Planet.Uranus”
＃ possiblePlanet是一个Planet?类型，可能会是nil，因此需要判断：
let positionToFind = 9
if let somePlanet = Planet.fromRaw(positionToFind) { ＃可选绑定
switch somePlanet {
case .Earth:
println("ostly harmless")
default:
println("Not a safe place for humans")
}
} else {
println("There isn't a planet at position \(positionToFind)") ＃Planet.fromRaw(positionToFind) 如果是 nil ，那么就会走到这
}
十六.类和结构体
反馈一个问题：
binary operator === can not be applied
［swift语言详解］http://c.biancheng.net/cpp/html/2427.html 在数组的===比较这一块是错误的，恒等用在引用类型上，而数组是值类型，可以看下这个demo：
Paste_Image.png
［定义］
struct Resolution { ＃Resolution的结构体，用来描述一个显示器的像素分辨率
var width = 0
var heigth = 0
}
class VideoMode { ＃VideoMode的类，用来描述一个视频显示器的特定模式
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}
let someResolution = Resolution()
let vga = resolution(width:640, heigth: 480)
let someVideoMode = VideoMode()
someVideoMode.resolution.width = 12880
print(someResolution.width)
［属性］
存储属性：
struct FixedLengthRange {
var firstValue: Int
let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
延迟存储属性：
延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用@lazy来标示一个延迟存储属性。
必须将延迟存储属性声明成变量（使用var关键字），因为属性的值在实例构造完成之前可能无法得到。
class DataImporter {
/*
DataImporter 是一个将外部文件中的数据导入的类。
这个类的初始化会消耗不少时间。
*/
var fileName = "data.txt"
// 这是提供数据导入功能
}
class DataManager {
@lazy var importer = DataImporter()
var data = String[]()
// 这是提供数据管理功能
}
let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
// DataImporter 实例的 importer 属性还没有被创建
DataManager的一个功能是从文件导入数据，该功能由DataImporter类提供，DataImporter需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。DataManager也可能不从文件中导入数据。所以当DataManager的实例被创建时，没必要创建一个DataImporter的实例，更明智的是当用到DataImporter的时候才去创建它。由于使用了@lazy，importer属性只有在第一次被访问的时候才被创建。比如访问它的属性fileName时：
println(manager.importer.fileName)
// DataImporter 实例的 importer 属性现在被创建了
// 输出 "data.txt”
计算属性：
类、结构体和枚举可以定义计算属性，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。
struct Point {
var x = 0.0, y = 0.0
}
struct Size {
var width = 0.0, height = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set(newCenter) { ＃(newCenter) 可以省略不写，用默认的newValue
origin.x = newCenter.x - (size.width / 2) ＃origin.x = newValue.x - (size.width / 2)
origin.y = newCenter.y - (size.height / 2)
}
}
}
var square = Rect(origin: Point(x: 0.0, y: 0.0),size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
println("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// 输出 "square.origin is now at (10.0, 10.0)”
属性监视器:
暂时不知道哪里用到，先不说了
类型属性：
略