虽然Swift这门语言还很年轻，但是不可否认的是Swift很强大，也很便捷，但是习惯于OC编程之后再去写swift难免会觉得别扭，今天有时间，我就来把Swift的一些知识点加以整理，也便于自己以后查阅和重新温习，争取每天一篇，第一天就从最基础的开始整理

首先是新建一个swift工程，这个和OC是一样的，只不过在建的过程中把OC语言改成swift，这里就不再赘述

1.swift的基本操作

1.字符串操作

在swift中 let表示常量 var 表示变量

let str = "hello"

//长度str.characters.count

//长度 str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)

//大小写转换

//str.uppercaseString

//str.lowercaseString

//相等 ==  拼接 +

//插入 "123\(str)4567"

//格式化创建字符串 加占位符的

let str3 = String(format: "%02d:%02d", arguments: [1,2])

let str2 = String(format: "%02d:%02d", 1,2)

print(str2)

print(str3)

//字符串的其他操作全部转换为NSString再去操作
//转换 的方法
let str4:NSString = str2 as NSString

2.数组的操作

Swift的数组和OC的数组可以互相转化

//不可变数组

let array1 = ["A","3","C"]

//可变数组

var mutableArray = [String]()

//往数组中添加元素

mutableArray.append("world")

在这里要说一下的是这个 let array= [String]()

这个式子表示的是 初始化一个存放字符串类型的空白数组

()代表初始化 OC里的initWith/init 在swift里面全部转化成()

在对数组操作有个要注意的点

1.for -in遍历数组的时候一定要明确的指出数组的类型

for temp in array1 as [String]{

print(temp.characters.count)

}

2.元组遍历数组中的值

for (index, value) in array1.enumerate()

{

print("index = \(index),value = \(value)")

}

3.字典的操作

在OC中字典要用 {} 表示 但是在swift中我们依然用[ ] 表示字典，这是一个不想同的点

1.不可变字典

let dict = ["key1":"value1","key2":"value2","key3":"value3"]

//通过key值访问value值

print(dict["key1"])

1.1 for-in 元组遍历字典的时候和数组有不同的地方，不用在后面加枚举，直接遍历即可

//for -in 遍历 (不用在后面加枚举)

for (key,value) in dict

{

//print("key = \(key), value = \(value)")

}

2.可变字典

var dict2 = ["key":"value"]

2.1如果可变字典合并另一个字典

这里要注意的时 如果key存在于原字典则是一个更新键值对的操作，否则是增加键值对操作

//合并

for (key,value) in dict

{

dict2[key] = value

}

4. 可选类型 封包 解包

//如果一个值可能为nil，那么这个值就是可选类型，用？标识

//Optional包围的就是可选类型

//可选类型不能直接使用，必须进行强制解包，！强制解包，对nil进行强制解包就会崩溃

如果swift出现了这个错误 fatal error: unexpectedly found nil while unwrapping an Optional value

那么原因就是对一个空的可选类型进行强制解包

下面举个例子

var a1:String?

a1 = "皮卡皮卡"

print(a1!.characters.count)

补充：有人经常会看到这样的语句 (a1 ?? "123") 这个语句是什么意思呢

这个语句的意思就是对可选类型进行判断，如果为空就给一个值"123",这是对可选类型进行一个保护让它解包时不至于崩溃

print((a1 ?? "123").characters.count)

5. 判断

1.if判断

swift的if判断和OC有两点的不同

1.1 if 条件语句()可省略，{}不能省略

1.2 判断没有非零即真的概念,只有true false的两种情况这样可以使判断更准确效率更高更有针对性

let tempValue = 10

if tempValue > 5

{

print("这很Swift")

}

2.三种可选类型的条件分支

2.1 if-let

if-let 是对可选类型的判断，如果可选类型为空，则不执行代码块，如果不为空时，用tempStr来接收此刻这个可选类型的解包后的值 只能判断可选类型

let string:String? = "比比鸟"

if let tempStr = string

{

print(tempStr)

}

2.2 if-let-where

跟 if-let 相似，where是对前面定义的这个局部变量再做一层判断

如果不为空且位数大于2

let string:String? = "比比鸟"

if let tempStr1 = string where tempStr1.characters.count > 2

{

print("tempStr1.length = \(tempStr1.characters.count)")

}

 2.3 guard-let-else(守护)

跟 if-let 相反 如果可选类型str为nil，则执行代码块，最后一定要return，如果不为nil则强制解包后的值赋值给tempStr，这样在{}外面就可以使用tempStr

let str:String? = nil

guard let tempStr = str else

{

print("str = nil")

return

}

print(tempStr)

3.switch

在这里我们也着重注意下swift中的switch和OC中的switch的区别

3.1 在swift中

(1).switch不局限判断整型，可以是浮点型，也可以是字符串等等

(2).switch 后面的小括号可以省略，大括号不能省略

(3).case后面至少要有一条执行语句，并且case后面的大括号可以省略，break可以不写，不会造成贯穿

(4).default一定要写，且只能写在最后

写法为

let f = 3.2

switch f

{

case 3.0:

print("凑数的判断语句")

case 3.1:

print("这还是一个凑数的")

case 3.2:

print("这又是一个凑数的")

default:

print("这是default的判断语句")

}

6.循环

因为OC的while和do while和swift相差并不大所以就不再赘述 我简单总结下for循环

下面的写法虽然最熟悉但是这个写法在2.2版本已经废弃了

for (var i = 0;i < 5;i++){

}

现在我的swift的写法是这样的 但是好像最新版本的swift好像也会报错，这个我等会看一下

for var i = 0 ; i < 10 ; i++

{

print(i)

}

2种for in循环

注意区分两者的不同 差别在" ."  和 "< "

这是0-4的遍历

for i in 0..<5

{

print("i = \(i)")

}

这是0-5的遍历

for i in 0...5

{

print("i = \(i)")

}

7.枚举

老规矩，先对比OC来看

相对于OC来说swift的枚举更加强大 swift的枚举值可以关联浮点型，字符串,并且没有默认的关联值

注意观察下面两个代码的差别

关联如果是int，会默认的递增上去，如果不是int类型的话，必须每个枚举值都关联上

enum Month:Init

{

case January = 3

case February

case March

case April

}

enum Month:Float

{

case January = 11.2

case February = 12.2

case March = 13.2

case April = 14.2

}

调用枚举

如果明确指出一个变量/常量是属于哪种枚举类型的话，可以直接.枚举值赋值,否则就 枚举类型.枚举值

let month = Month.April

let month1:Month = .January

switch month

{

//hasValue 代表第几个枚举

case .January:

print("hasValue = \(month.hashValue),rawValue = \(month.rawValue) ")

print(month)

case .February:

print("hasValue = \(month.hashValue),rawValue = \(month.rawValue) ")

print(month)

case .March:

print("hasValue = \(month.hashValue),rawValue = \(month.rawValue) ")

print(month)

case .April:

print("hasValue = \(month.hashValue),rawValue = \(month.rawValue) ")

print(month)

}

2.常用swift的操作

1.懒加载

swift的懒加载格式为

lazy var 变量名:变量类型 = {

code 初始化

return

}()

以 初始化一个button为例

lazy var btn:UIButton = {

var tempBtn = UIButton(type:UIButtonType.ContactAdd)

tempBtn.frame = CGRectMake(90,100,50,50)

tempBtn.backgroundColor = UIColor.cyanColor()

return tempBtn

}()

2.闭包

闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。

在Swift中的闭包与C、OC中的blocks和其它编程语言（如Python）中的lambdas类似。

闭包格式  闭包作用回调传值

var 闭包变量 ={

（参数名：参数类型）-> 返回值类型 in

代码块

}

具体实现

//无参无返

let closure = {

()->()//() -> void , ()

in

print("无参无返")

}

closure()

//有参无返

let closure1 = {

(tempStr1 str:String,tempStr2 str2:String) -> ()

in

print("有参无返")

}

closure1(tempStr1: "hello",tempStr2: "world")

//无参有返

let closure2 = {

() -> String

in

print("无参有返")

return "aaaaa"

}

print(closure2())

//有参有返

let closure3 =

{

(str:String) -> Int

in

return 32

}

print(closure3("给我打印个数吧"))

3.方法 的声明和实现

格式

func 方法名(参数列表) ->返回值类型{

}

具体的实现代码

func text(str:String) ->String

{

return "有参有返"

}

func text1()->String

{

return "无参有返"

}

func text2()

{

print("无参无返")

}

func text3(str:String)

{

print("有参无返")

}

print(text("啦啦啦"))

print(text1())

text2()

text3("哈哈哈哈")

把闭包作为参数的方法实现示例

假如我们要实现两个string的拼接

首先声明一个方法在方法内部执行闭包

func combineString(str1:String,str2:String,closure:(tempStr1:String,tempStr2:String)->String)

{

//执行闭包

let string =  closure(tempStr1: str1, tempStr2: str2)

print(string)

}

调用的时候实现函数

combineString("hello", str2: "world") { (tempStr1, tempStr2) -> String in

return "\(tempStr1) \(tempStr2)"

}

4.单例的创建

首先创建一个继承与NSObject的类 因为swift没有 .h文件所以直接就在文件中创建单例

创建单例有两种写法

写法1

var name:String?

 static var shareSingleDog:singleDog = {

  let instance = singleDog()

   return instance

写法2

static let instance = singleDog()

static func shareSingleDog()->singleDog{

return instance

}

写法1的调用

let s1 = singleDog.shareSingleDog

s1.name = "皮卡"

let s2 = singleDog.shareSingleDog

print(s2.name)

写法2的调用

let s3 = singleDog.shareSingleDog()

s3.name = "水箭龟"

let s4 = singleDog.shareSingleDog()

print(s4.name)

5.KVC异常捕获

在OC中我们经常使用KVC在swift中也有需要注意的点

1.字典转模型

（1）新建模型类 以person为例

var name:String?

var age:Int = 0

var gender:String?

这里需要注意模型中如果有基本数据类型的话，基本数据类型不可以为可选类型，否则在KVC赋值中会找不到对应的key值.如果为可选类型的话必须给个初始值

（2）重写初始化方法

init(dict:[String:AnyObject]) {

super.init()

setValuesForKeysWithDictionary(dict)

}

重写完初始化方法后，系统自带的默认初始化方法就不能被调用，如果还想调用默认的初始化方法则需要写下以下的方法

override init() {

}

(3)外界字典转模型

let dict = ["name":"zhangsan","age":12,"gender":"男"]

let person = Persone(dict: dict)

//let person = Persone() （系统自带的初始化方法）

print(person.name)

print(person.age)

print(person.gender)

2.解析

1.获取路径

let path = NSBundle.mainBundle().pathForResource("iOS04", 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")

}

最后需要注意的一点就是

swift里面尽量不要写self一般只有在闭包内部才会强制要求写self

以上就是swift基础部分的简单总结