swift的语法确实高端，用习惯了编程特别顺手。
swift中的变量分为两类，变量（var）和常量（let）,常量声明时必须有一个初值，变量声明时不必有初值，但要指定类型。
1.Int 和 Float
let a:Int = 1
let b:Float = 1.1
let var
let str = "hello"
str.characters.count // 字符串长度
str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
1.2大小写
str.uppercaseString
str.lowercaseString
let str2 = String(format: "%02d:%03d", 1,2)
let str3 = String(format: "%02d:%02d", arguments: [1,2])
str2.substringToIndex(
字符串的其他操作全部转化为NSString再去操作
1.3转换
let str4:NSString = str2 as NSString //str4是str2转化为NSString的值
2数组 Array
2.1不可变数组
let array1 = ["A","2","3","4"]
let array2:Array = ["A","2","3","4"]
let array3:[String] = ["A","2","3","4"]
initWith/init在swift里面全部转化成 ( )
let array4 = [String]() // 指定是String类型数组
元素个数 .count 来访问
数组遍历 for-in（要明确指出数组的）
for temp in array3 as [String]{
print(temp.characters.count)
print(temp)
}
元组遍历 **针对下标的时候 推荐**
for (index,value) in array3.enumerate()
{
print("index = \(index), value = \(value)")
}
2.2可变数组
var mutableArray = [String]()
mutableArray.append("hello")
mutableArray.append("world")
mutableArray.append(23)
mutableArray.removeAll()
mutableArray.removeAll(keepCapacity: true)
mutableArray.removeFirst(0)
print(mutableArray)
3.字典 Dictionary
3.1不可变字典
let dict = ["key1":"value1", "key2":"value2", "key3":"value3"]
print(dict)
通过key值访问value值
print(dict["key1"])
字典遍历不用在dict后面加.enumerate()
for (key,value) in dict
{
print("key = \(key), value = \(value)")
}
3.2可变字典
var dict3 = ["key":"value"]
3.3合并字典
for (tempKey,tempValue) in dict{
如果key存在的则是一个更新键值对操作，否则是一个增加键值对操作
dict3[tempKey] = tempValue
}
print(dict3)
4 .可选类型
如果一个值可能为nil，那么这个值就是可选类型，用？标识
Optional包围的就是一个可选类型 （打印出来有Optional）
可选类型不能直接使用，必须进行强制解包，!强制解包，对nil强制解包会造成崩溃
unexpectedly found nil while unwrapping an Optional value 出现这个错误的时候就是对一个空的可选类型进行强制解包 ，不能对空的可选类型进行强制解包！
(a1 ?? "234") 对可选类型进行判断，如果可选类型值为nil,则给它一个默认值（"23456"）
var a1:String?
a1 = "123"
print(a1)
print(a1!)
print(a1!.characters.count)
print((a1 ?? "23456").characters.count)
5.条件分支
if 条件语句()可以省略， {} 不能省略
if 没有非零即真的概念，只有true false的两种情况
let tempValue = 10
if tempValue > 5{
print("tempValue > 5")
}
可选类型的条件分支
let str:String? = "hello"
(1) if-let是对可选类型的判断，如果可选类型为nil,则不执行代码块。如果不为空则用tempStr来接受此刻这个可选类型的解包后的值
if let tempStr = str{
print(tempStr)
}
(2) if-let-where 跟if-let相似，where是对前面定义的这个局部变量再做一层判断
if let tempStr = str where tempStr.characters.count > 2 {
print("tempStr.length = \(tempStr.characters.count)")
}
(3) guard-let-else (守护)
如果可选类型str为nil，则执行code代码块，最后一定要return，如果不为nil则强制解包后的值赋值给tempStr，这样在{}外面就可以使用tempStr
guard let tempStr = str else {
code
return
}
tempStr....
6.switch
* switch 不局限判断整型，可以是浮点型，也可以是字符串等等
* switch 后面的小括号可以省略，大括号不能省略
* case 后面至少要有一条执行语句！！并且case后面的大括号可以省略，break可以不写，不会造成贯穿
* default一定要写，并且只能写在最后
let f = 3.2
switch f {
case 3.0:
print("==3.0")
case 3.1:
print("==3.1")
case 3.2:
print("==3.2")
default:
print("unknow")
}
该写法在swift2.2的时候被废弃掉了
for (var i = 0 ; i < 5; i++){}
for var i = 0; i < 5; i+1 { print(i) }
用下面这个
for i in 0..<5 { // 0..<5 --- [0,5) 0...5 --- [0,5]
print("i=\(i)")
}
7.枚举（枚举值可以关联浮点，字符串等,没有默认的关联值）
关联如果是Int，会默认的递增上去；如果不是Int类型，必须每个枚举值都关联上对应的值
enum Month:Float {
case January = 11.2
case February = 12.2
case March = 13.6
case April = 14.2
case May = 15.4
case June = 17.6
}
如果明确指出一个变量/常量是属于哪种枚举类型的话，可以直接用 .枚举值 来赋值，否则就用 枚举类型.枚举值
let month = Month.January
let month2:Month = Month.January // let month2:Month = .January
var month1 = Month.January
month1 = .February
switch month{
case .January:
print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
print(month)
case .February:
print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
print(month)
case .March:
print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
print(month)
case .April:
print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
print(month)
default :
print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
print("noValue")
}
8.懒加载
* lazy var 变量名：变量类型 = {
* code
* return
* }( )
lazy var btn:UIButton = {
var tempBtn = UIButton(type: UIButtonType.ContactAdd)
tempBtn.frame = CGRectMake(90, 100, 50, 50)
tempBtn.backgroundColor = UIColor.cyanColor()
return tempBtn
}()
9.异常捕获
let path = NSBundle.mainBundle().pathForResource("iOS", ofType: "json")
let data:NSData = NSData(contentsOfFile: path!)!
do{
let rootArray = try NSJSONSerialization.JSONObjectWithData(data, options: .MutableContainers) as! [[String:String]]
print(rootArray)
}catch{
// 异常捕获，序列化出错的时候就自动来到这里
print("error")
}
10.闭包
{
(参数名：参数类型) -> 返回值类型
in
code,执行代码
}
无参无返
let closure = {
()->() // ()->void // () 3种
in
print("无参无返")
}
closure()
有参无返
let closure1 = {
(str:String,str1:String)->Void
in
print("有参无返\(str),\(str1)")
}
closure1("hello","world")
无参有返
let closure2 = {
()->String
in
print("无参有返")
return "无参有返"
}
print(closure2())
有参有返
let closure3 = {
(str:String,str1:String)->String
in
print("有参有返\(str),\(str1)")
return str+str1
}
print(closure3("1","2"))
练习
定义一个方法 （输入参数color，frame，closure（是将刚才的color，frame当做参数，返回一个UIView），返回一个UIView）
func creatUIView(color:UIColor,frame:CGRect,closure:(tempColor:UIColor,tempFrame:CGRect)->UIView)->UIView{
let view:UIView = closure(tempColor: color, tempFrame: frame)
return view
}
调用函数：
let view = creatUIView(UIColor.redColor(), frame: CGRectMake(100, 100, 100, 100)) { (color, frame) -> UIView in
let tempView = UIView(frame: frame)
tempView.backgroundColor = color
return tempView
}
view.addSubview(view)
11.函数
func 方法名（参数列表）-> 返回值类型{
code
}
无参无返
func func1()->Void{
print("无参无返")
}
有参无返
func func2(str:String)->Void{
print("\(str)")
}
有参有返
func func3(str:String)->String{
return str+"有参有返"
}
无参有返
func func4()->String{
return "无参有返"
}
12.字典转模型
class Person: NSObject {
字典转模型，模型中如果有基本数据类型的话，基本数据类型不可以为可选类型，否则在KVC赋值中会找不到对应的key值.如果为可选类型的话应该给初始值
var name:String?
var age:Int = 0
var gender:String?
字典转模型
init(dict:[String:AnyObject]) {
super.init()
setValuesForKeysWithDictionary(dict)
}
this class is not key value coding-compliant for the key age.'出现这个错误一般都是字典转模型的时候出错
如果自定义了初始化方法并且没有实现系统默认的初始化方法，那么外界访问不到该类的默认初始化方法，想要访问的话必须手动实现
override init() {
super.init()
}}
13.创建单例
class SingleDog: NSObject {
var name:String?
单例第一种写法
static var shareSingleDog:SingleDog = {
let instance = SingleDog()
return instance
}()
单例第二种写法
static let instance = SingleDog()
static func shareSingleDog()->SingleDog{
return instance
}
}