Swift 大约历经 4 年的开发期，2014 年 6 月发步
- 苹果宣称 Swift 的特点是：快速、现代、安全、互动，而且明显优于 Objective-C 语言
- 可以使用现有的 Cocoa 和 Cocoa Touch 框架
- Swift 取消了 Objective C 的指针及其他不安全访问的使用
- 舍弃 Objective C 早期应用 Smalltalk 的语法，全面改为句点表示法
- 提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载（operator overloading）
- Swift 被简单的形容为 “没有 C 的 Objective-C”（Objective-C without the C）
目录
- 常量和变量
- 基本数据类型
- 类型转换
- Bool类型
- 元祖
- 可选值
- 字符和字符串
- 字符串常用方法
- 运算符
- 数组的基本使用
- 数组其他操作
- 字典
- if
- while循环
- for循环
- break-continue
- Switch
- 函数定义
- 闭包
- 枚举
- 结构体
- 懒加载
常量和变量
- var 定义变量，设置之后可以修改
- let 定义常量，设置之后不可以修改
变量
01> 先定义，再初始化
var num: Int
num = 1002> 定义的同时进行初始化
var num2 = 20
// 如果要显式的指定变量的类型，可以在定义是使用 var 变量名: 类型 = 值
var num3: Int = 30常量
Swift中的常量必须在定义时初始化
格式：let num : Int
let num4 = 30
let num5: Int = 30常量&变量的使用原则：尽量先用 let，只有需要变的时候，再用 var，能够更加安全
基本数据类型
整型
var intValue: Int = 10浮点型
var floatValue1:Double = 99.99 // 表示64位浮点数
var floatValue2:Float = 8.8 // 表示32位浮点数如果按长度分，swift中的长短比OC更加精确
var intValue1:Int8 = 8
var intValue2:Int16 = 16
var intValue3:Int32 = 32
var intValue4:Int64 = 64有无符号划分，默认是有符号的
- 无符号（UInt8/UInt16/UInt32/UInt64）
var uintValue:UInt8 = 100注意：无符号的数比有符号的数取值范围更大，因为符号位也用来存储值
类型转换
隐式类型转换
OC:
int intValue = 10;
double doubleValue = (double)intValueSwift 不允许隐式类型转换，但可以使用显式类型转换（强制类型转换）
var intValue: Int = 10
// var doubleValue: Double = intValue 报错
var doubleValue: Double
doubleValue = Double(intValue)
// 注意：Double(）不会修改 intValue 的值，而是通过 intValue 的值生成一个临时的值赋值给 doubleValue
print(intValue) // 10
print(doubleValue) // 10.0Bool类型
C语言的Bool类型是非0即真
OC语言的Bool类型是typedef signed char BOOL
Swift 引入了真正的Bool类型
真：true
假：false
let isOpen = true
if isOpen {
print("打开")
} else {
print("关闭")
}元祖
将多个相同或者不同类型的值用一个小括号括起来就是一个元祖
- 元祖其实和结构体很像，只是不需要提前定义类型。
- 元祖其实是复合类型，小括号中可以写任意类型
元祖的其他定义方式：
01>指明元祖内部每个元素的类型
let student1: (String,Int,Double) = ("Larry",20,59.5)02>指明对应元祖元素的名称
let student2 = (name:"Vivian",age:18,score:99.5)03>通过指定的名称提取元祖对应的值，会将对应位置的值，赋值给对应位置的名称
let(name,age,score) = ("Eric",26,88.5)04>如果不关心元祖中某个值，可以利用通配符(_)来忽略提取
let(name1,age1,_) = ("Owen",30,77.5)可选值
可选值：optionals 有两种状态
- 1.有值
- 2.没有值,没有值就是 nil
// 有值
var optionalValue1: Int? = 9
// 没有值
var optionalValue2: Int?
var optionalValue3: Int? = nil可选类型的值的提取（强制解析）”!”
var optValue2: Int? = 8
var result: Int = optValue2!可选绑定：
为了更安全的解析可选类型的值，一般情况下使用可选绑定
如果optValue没有值就不会做任何操作，如果optValue有值会返回true并将optValue的值赋值给result，然后执行大括号值的内容
var optValue: Int? = 88;
if let result3 = optValue {
print(optValue) // Optional(88)
}字符和字符串
字符
单个字符
var charValue1:Character = "a"
var charValue2:Character = "王" // 正确字符串
字符是单个字符的集合，字符串是多个字符的集合，想要存放多个字符需要使用字符串
var stringValue3 = "abc"
var stringValue4:String = "abcdef"字符串常用方法
计算字符串的长度
var stringValue = "swift学习"
print(stringValue.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
// 打印结果11 字符占一个字节，汉子占3个字节字符串拼接
var str1 = "abc"
var str2 = "123"
var str = str1 + str2
print(str) // abc123格式化字符串
var name = "Mazy"
var str3 = "\(name) have fun"
print(str3) // Mazy have fun字符串比较
Swift: (== / != / >= / <=)
var str4 = "have fun"
var str5 = "have fun"
if str4 == str5 {
print("相等")
} else {
print("不相等")
}
var str6 = "abc"
var str7 = "abd"
if str6 >= str7 {
print("大于或者等于")
} else {
print("小于")
}判断前后缀
var urlString = "http://www.baidu.com"
if urlString.hasPrefix("http") {
print("是URL")
}
if urlString.hasSuffix(".com") {
print("是域名")
}大小写转换
var str8 = "Study Swift"
print(str8.lowercaseString) // study swift
print(str8.uppercaseString) // STUDY SWIFT转换为基本数据类型
var str9 = "12306"
// 如果string不能转换为整数，那么可选类型返回nil
// 当str9 = "12306a" 不能转换为整型，所以转换结果为nil
var number: Int? = Int(str9)
if (number != nil) {
print(number) // Optional(12306)
}运算符
算术运算符
+ - * / % += 1 -= 1var result = 10 + 10
print(result) // 20
result = 10 - 10
print(result) // 0
result = 10 * 10
print(result) // 100
result = 10 / 10
print(result) // 1
result = 10 % 10
print(result) // 0取模
print(10 % 3.0) // 3.0
// 10 / 3.5 = 2-->3
// 如果分子和分母有一个是小数，最后的结果就是浮点型自增自减
- Swift 2.0 可以用 ++ 和 –
- Swift 3.0 以后用 += 1 和 -= 1
var number = 10
number += 1
print(number)
number -= 1
print(number)赋值运算
= += -= /= *= %=var number1 = 10
number1 = 20
print(number1) // 20
number1 += 10
print(number1) // 30
number1 -= 10
print(number1) // 20
number1 *= 10
print(number1) // 100
number1 /= 10
print(number1) // 20
number1 %= 10
print(number1) // 0关系运算符
- 运算结果是Bool值，基本语法和OC一样
> < >= <= == != ?:(三目运算符)var result1:Bool = 20 > 10
print(result1)
// MARK: - 三目运算符
var result2 = 20 > 10 ? 20 : 10
print(result2)逻辑运算符
var open = false
if !open {
print("打开")
}
var age = 20
var heiget = 170
var weight = 160
if (age > 18 && age < 30 && heiget > 165) || weight < 160 {
print("合格")
}区间
闭区间：包含区间的所有值 a...b 例如：1...5 ->（1,2,3,4,5）
半闭区间：包含头不包含尾 a..<b 例如：1..<5 ->（1,2,3,4）注意：区间只能用于整数，写小数会出问题
应用场景：遍历，数组等
for i in 1...5 {
print(i)
}
for i in 1..<5 {
print(i)
}数组的基本使用
数组定义
// 有值数组
var arr1 = [1,2,3]
var arr2: Array = [1,2,3]
var arr3: Array<Int> = [1,2,3]
var arr4: [Int] = [1,2,3]
// 空数组
var arr5 = []
var arr6 = [Int]()
var arr7 = Array<Int>()
// 可变数组
var arr8 = []
// 不可变数组
let arr9 = []数组的操作
01 获取长度
var arr12 = [1,2,3]
print(arr12.count) // 302 判断是否为空
var arr13 = [1,2,3]
print(arr13.isEmpty) // false03 检索数组内部元素
var arr14 = [1,2,3]
print(arr14[0])
print(arr14[2])
print(arr14.first)
print(arr14.last)
print(arr14.minElement())
print(arr14.maxElement())04 追加元素
var arr15: Array<Any> = [1,2,3]
arr15 .append(4)
arr15 .append("a")
print(arr15) // [1, 2, 3, 4, "a"]05 插入元素
var arr17 = [1,2,3]
arr17.insert(4, atIndex: 0)
print(arr17) // [4, 1, 2, 3]06 更新元素
var arr18 = [1,2,3]
arr18[1] = 9
print(arr18) // [1, 9, 3]07 删除元素
var arr19 = [1,2,3]
arr19.removeAtIndex(0)
print(arr19)
var arr20 = [1,2,3]
arr20.removeLast()
print(arr20)
var arr21 = [1,2,3]
arr21.removeFirst()
print(arr21)
var arr22 = [1,2,3]
arr22.removeAll()
print(arr22)
var arr23 = [1,2,3]
arr23.removeAll(keepCapacity: false) // 是否保持容量，如果是true,即使删除了容量依然存在，容量是2的倍数
print(arr23)
print(arr23.capacity)
// 注意：如果数组是一个不可变数组，不能更新、插入、删除数组其他操作
Range 范围
var arr24 = [1,2,3]
arr24.removeRange(Range(1..<2))
print(arr24) // [1,3]
var arr25 = [1,2,3]
arr25.removeRange(Range(0...0))
print(arr25) // [2,3]
var range = 0...5
var range1: Range<Int> = 0...5
var range2: Range<Int> = 0..<5
print(range) // 0..<6
print(range1) // 0..<6
print(range2) // 0..<5数组的批量操作
var arr = [1,2,3]
arr.replaceRange(1..<2, with: [99,98,97,96])
print(arr) // [1, 99, 98, 97, 96, 3]遍历
var arr1 = [1,2,3]
for i in 0 ..< arr1.count {
print(arr1[i])
}
for number in arr1 {
print(number)
}
var arr2 = [1,2,3]
for number in arr2[0..<3] {
print(number)
}字典
字典的定义
// 注意：key一定是可以hash的(String,Int,Float,Double,Bool),value没有要求
var dict = ["name":"Eric","age":28]
print(dict) // ["age": 28, "name": Eric]
var dict1: Dictionary = ["name":"Larry","age":26]
print(dict1) // ["age": 26, "name": Larry]
// key必须是String类型，value任意
var dict2: Dictionary<String,AnyObject> = ["name":"Vivian","age":24]
print(dict2) // ["age": 24, "name": "Vivian"]
// key必须是String类型，value任意
var dict3: [String:AnyObject] = ["name":"Vivian","age":24]
var dict4: [String:AnyObject] = Dictionary(dictionaryLiteral:("name","Owen"),("age",30))
print(dict4)
// 可变字典
var dict5 = [:]
// 不可变字典
let dict6 = [:]字典操作
01.获取
var dict7 = ["name":"Eric","age":28]
print(dict7["name"])02.修改
dict7["name"] = "Brouth"
print(dict7)
dict7.updateValue("Lucy", forKey: "name")
print(dict7)03.更新
// updateValue返回一个可选类型，如果字典中不存在需要更新的key，那么返回nil，如果存在，返回原始值
var dict8 = ["name":"Vivian","age":24]
if let original = dict8.updateValue("Marry", forKey: "name") {
print(dict8["name"])
}
print(dict8)04.添加
var dict9 = ["name":"Eric","age":28]
dict9["weight"] = 13005.删除
var dict10 = ["name":"Eric","age":28]
dict10.removeValueForKey("age")
// 注意：removeValueForKey() 返回一个可选类型，如果字典中不存在需要删除的key，那么返回nil并且不会执行任何操作，如果存在则删除key对应的值，并且返回被删除的值
var dict11 = ["name":"Eric","age":28]
if let orignal = dict11.removeValueForKey("name") {
print(dict11)
print(orignal)
}06.遍历字典
var dict12 = ["name":"Eric","age":28,"sex":"male","height":170.5]
// 取出所有的key和value
for (key,value) in dict12 {
print("key = \(key) value = \(value)")
}
// 取出所有的key
for key in dict12.keys {
print(key)
}
// 取出所有的value
for value in dict12.values {
print(value)
}if
if 条件表达式 {指令}
if 条件表达式 {指令} else {指令}
- 1.if后面的圆括号可以省略
- 2.只能以Bool作为条件语句
- 3.如果只有一条指令，if后面的大括号不可以省略
var age1: Int = 10
var age2: Int = 8
var max: Int?
if age1 > age2 {
max = age1
}
print(max) // 10
if age1 > age2 {
max = age1
} else {
max = age2
}
print(max) // 10while循环
- 1.while后面的圆括号可以省略
- 2.只能bool作为条件语句
- 3.如果只有一条条件语句，while后面的大括号不可以省略
while i <= 10 {
i = i+1
sum = i
print("\(sum)")
}do while 循环
格式：do while (循环保持条件) {执行的语句}
Swift 2.0之后变为repeat while, do用于捕捉异常
- 1.while后面的圆括号可以省略
- 2.只能bool作为条件语句
- 3.如果只有一条条件语句，while后面的大括号不可以省略
var j:Int = 0
var sum1:Int = 0
repeat {
j = j + 1
sum1 = j
print(sum1)
} while (j <= 10)
repeat {
j = j + 1
sum1 = j
print(sum1)
} while j <= 10for循环
格式1: for (初始化表达式;循环保持条件;循环后表达式) {需要执行的语句} // swift3.0弃用
格式2: for in
- 1.for后面的圆括号可以省略
- 2.只能Bool作为条件语句
- 3.for后面的三个参数都可以省略，如果省略循环保持语句，那么默认为真
var sum: Int = 0
for i in 0..<10 {
sum += i
print(i)
print(sum)
}
for dict in ["name":"Vivian","age":18] {
print(dict)
}
for (key,value) in ["name":"Lucy","age":19] {
print("\(key) = \(value)")
}break-continue
- break: 跳出循环，无论循环保持条件是否还为真都不会再执行循环
- continue: 跳出本次循环，如果循环保持条件还为真会继续执行循环
var array:Array<Int> = [1,3,5,8,9]
for num in array {
if num == 8 {
print("找到幸运数字-\(num)")
break
}
print("没有找到幸运数字-\(num)")
}
var arr: Array<Int> = [1,3,5,8,9]
var count:Int = 0
for num in arr {
if num % 2 != 0 {
print("\(num)-不能被2整除")
continue
}
print("\(num)-能被2整除")
}Switch
格式： switch(需要匹配的值) case 匹配的值: 需要执行的语句 break
- 不可以穿透
- 可以不写break
var rank = "A"
switch rank {
case "A": // 相当于if
print("优")
case "B": // 相当于else if
print("良")
case "C": // 相当于else if
print("中")
case "D": // 相当于else if
print("差")
default: // 相当于else
print("没有评级")
}可以这样写
var rank1 = "A"
switch rank {
case "A","B": // 相当于if
print("优")
case "C","D": // 相当于else if
print("中")
default: // 相当于else
print("没有评级")
}函数定义
函数：完成某个特定任务的代码块，给代码块起一个合适的名称称为函数名称。以后需要执行代码块只需要利用函数名称调用即可。好比每个人都有一个名字，叫名字就能找到对应的人
格式：func 函数名称(参数名:参数类型,参数名:参数类型…) -> 函数返回值 {函数实现部分}
无参无返回值
func say() -> Void {
print("hello")
}有参无返回值
func sayWithName(name:String) {
print("hello \(name)")
}
sayWithName("word")
func sayWithName1(name:String, age:Int) {
print("hello \(name) my age is \(age)")
}
sayWithName1("Eric", age: 25)无参有返回值
func info() -> String {
return "name = Larry, age = 26"
}
info()有参有返回值
func info(name:String,age:Int) -> String {
return "name is \(name), age is \(age)"
}
print(info("Owen",age:30))闭包
函数是闭包的一种
类似于OC语言的block
闭包表达式(匿名函数) – 能够捕获上下文的值
语法：
in 关键字的目的是便于区分返回值和执行语句
闭包表达式的类型和函数的类型一样，是参数加上返回值，也就是in之前的部分
{
(参数) -> 返回值类型 in
执行语句
}完整写法：
let say:(String) -> Void = {
(name: String) -> Void in
print("hi \(name)")
}
say("Mazy")没有返回值写法
let say2:(String) -> Void = {
(name: String) in
print("hi \(name)")
}
say2("Lerry")
// 简写
let say2:(String) = {
(name: String) in
print("hi \(name)")
}
say2("Lerry")没有参数没有返回值写法
let say3:() -> Void = {
print("hello world")
}
say3()枚举
// 格式：
enum Method {
case 枚举值
}enum Method {
// case Add
// case Sub
// case Mul
// case Div
// 可以连在一起写
case Add,Sub,Mul,Div
}利用switch匹配枚举值
// 注意：如果case中包含了所有的值，可以不写default。如果case中没有包含枚举中的所有的值，必须写default
switch (Method.Add) {
case Method.Add:
print("加")
case Method.Sub:
print("减")
case Method.Mul:
print("乘")
case Method.Div:
print("除")
}原始值
OC中枚举的本质就是整数，所以OC中的枚举是有原始值的，默认是从0开始的
而swift值的枚举值默认是没有原始值的，但是可以在定义时告诉系统让枚举有原始值
enum Method: 枚举的原始值类型 {
case 枚举值
}enum Method1: Int {
// 可以连在一起写
case Add,Sub,Mul,Div
}
// 和OC的枚举一样，也可以指定原始值，后面的值默认+1
enum Method2: Int {
// 可以连在一起写
case Add = 5,Sub,Mul,Div
}
// swift 中的枚举除了可以指定整形以外还可以指定其他类型，但是如果指定了其他类型，必须给所有的枚举值赋值，因为不能自动递增
enum Method3: Double {
case Add = 5.0,Sub = 8.0,Mul = 9.0,Div = 10.0
}结构体
结构体是用于封装不同或相同类型的数据的，swift中的结构体是一种类型，可以定义属性和方法(甚至构造方法和析构方法等)
格式：
struct 结构体名称 {
结构体属性和方法
}struct Rect {
var width: Double = 0.0
var height:Double = 0.0
}懒加载
格式：
lazy var 变量: 类型 = { 创建变量代码 }()lazy var demoView: UIView = {
let view = UIView(frame: CGRectMake(10, 10, 100, 100))
view.backgroundColor = UIColor.redColor()
return view
}()懒加载的写法本质上是定义并执行一个闭包
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
