swift语法好麻烦 swift语言语法

一、Swift简介

2010年的夏天，苹果公司的开发人员Chris Lattne接到了一个特别的任务，为OS X 和iOS平台开发下一代的编程语言，也就是Swift。

苹果公司于2014年WWDC（苹果开发者大会）发布的新开发语言Swift，可与Objective-C共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。
2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swfit完全开源。

自从Swift发布以来，在http://www.tiobe.com中的排行一直处于上升的状态。

二、声明变量和常量

在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;

let修饰常量的值是不可以更改的；

var修饰的变量的值是可以更改的；

在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。

Swift里不会自动给常量变量赋初始值，也就是说常量变量不会有默认值，所以定义常量的时候一定要给定初始值

Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。

因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换

 

1、声明常量变量

 

1 // MARK: - 定义常量变量：变量类型的隐式转换
 2 
 3 // 在Swift中如果不给定变量常量的类型，该常量变量的类型就是其初始值的类型
 4 var name = "Jack"    // 隐式转换为String类型
 5 
 6 var name1 : String = "Rose"  // 给定name1的类型为String，不能赋值其他类型
 7 
 8 var age : Int = 18  // 整型变量
 9 
10 var age1 : Int?   // ?表示age1的类型为可选类型，其值可以为空
11 print(age1)
12 
13 var gender : Character = "f"  // 字符变量，字符用""括起来，""中只能写一个字符
14 
15 var flag : Bool = true   // Bool类型，其值只有true 和 false

 

2、定义字符串，以及常用到的函数

1. String是有序的字符集合，例如“Hello World”
2. Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合

1 // MARK: - 字符串
 2 // 1、创建一个空的字符串
 3 var str_empty = ""
 4 var str2_empty = String()
 5 
 6 // 2、判断字符串是否为空
 7 if str_empty.isEmpty {
 8     print("空")
 9 } else {
10     print("非空")
11 }
12 
13 // 3、字符串的拼接
14 var url : String = "http://"
15 var str : String = "www.baidu.com"
16 // 方式1：
17 //url.appendContentsOf(str)
18 // 方式2：
19 var newUrl = url + str
20 // 方式3：字符串插值  --  \(变量名)
21 var newURL = "百度网址:\(newUrl)"
22 
23 print(newURL)
24 
25 // 4、获取字符串长度
26 var str1 : String = "abcdef"
27 print(str1.characters.count)
28 
29 // 5、字符串的比较
30 var str2 : String = "MBBoy"
31 var str3 : String = "GBLW"
32 if str2 == str3 {
33     print("\(str2)和\(str3)相等")
34 } else if str2 > str3 {
35     print("\(str2)大于\(str3)")
36 } else {
37     print("\(str3)大于\(str2)")
38 }

3、Float 和 Double

1 // MARK: - float与double
2 var num1 = 3.14   // 不指定类型，默认是double类型
3 // 如果想定义float类型的变量，必须要指定类型
4 var num2 : Float = 2.14
5 // 因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换
6 //var sum = num1 + num2  // 报错
7 var sum = num1 + Double(num2)  // 不会报错
8 print("和是\(sum)")

 

 

4、小结

• 常量或者变量的类型必须和你赋给它们的值的类型一样;
• 声明时类型是可选的，声明的同时赋值的话，编译器会自动推断类型;
• 如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割;
• 使用let来声明常量，使用var来声明变量;
• 常量只能赋值一次，使用的时候可以直接获取到这个值;
• 数据只能进行显示类型转换;

三、声明一个数组、字典

在Swift中使用“let”或者“var”声明一个数组或者字典;
数组必须指定数据类型，如果没有指定类型则会根据数组的初值去推断数据类型;
字典所有的key值必须是同一数据类型;
字典所有的value必须是同一数据类型。

1、数组

1 // MARK: - 数组
 2 // Swift中数组的元素类型必须相同，如果想存放不同类型的元素，用OC
 3 
 4 // 定义一个数组
 5 var nameArray = ["yuanyuan", "GBLW", "WYW"]
 6 print(nameArray)
 7 
 8 // 指定数组元素类型
 9 var ageArray : Array<Int> = [1, 4, 5]
10 print(ageArray)
11 
12 // 定义一个空数组
13 // 方式1：
14 var carArray = Array<String>()
15 // 方式2：
16 var carArray1 = [Int]()
17 print(carArray)
18 
19 // 访问数组元素
20 print(nameArray[1])
21 
22 // 给数组添加元素
23 carArray.append("bb")
24 print(carArray)
25 
26 // 使用运算符添加数组元素，可以添加多个
27 carArray += ["cc", "dd"]
28 print(carArray)
29 
30 // 插入元素到具体位置
31 carArray.insert("aa", atIndex: 0)
32 print(carArray)
33 
34 // 移除某个元素
35 carArray.removeAtIndex(2)
36 print(carArray)
37 
38 // 移除所有元素
39 carArray.removeAll()
40 print(carArray)
41 
42 // 数组排序
43 print(nameArray)
44 nameArray.sortInPlace()
45 print(nameArray)

 

2、字典

1 // MARK: - 字典
 2 // 定义一个字典类型的变量
 3 var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
 4 print(dic)
 5 
 6 // 定义空字典
 7 // 方式1
 8 var dic_empty = Dictionary<String, Int>()
 9 // 方式2
10 var dic_empty2 : Dictionary<String, Int> = [:]
11 
12 // 向字典中添加键值对
13 dic["d"] = 66
14 print(dic)
15 
16 // 修改字典中的值
17 dic["d"] = 9
18 print(dic["d"])
19 
20 // 删除一个键值对
21 dic.removeValueForKey("a")
22 print(dic)

四、元组

元组是Swift里面独有的一种数据格式。
是一个可以返回多个值的数据格式。
在Swift里面声明的时候使用“（）”声明。
元组可以通过下标去访问元素，也可以通过key值去访问元素;
整体的数据结构有点类似于C语言里面的结构体。

1 // MARK: - 元组
 2 
 3 // 定义一个元组
 4 // 方法1：直接初始化一个元组，使用Swift隐式转换
 5 var tuples = ("水果",["香蕉", "苹果", "西瓜"])
 6 // 方法2：初始化元组的时候给元组指定类型
 7 var tuples1 : (String, Array) = ("动物", ["?", "?", "?"])
 8 print(tuples1)
 9 
10 
11 // 取值
12 // 方式1: 直接把元组赋给另外一个常量，根据相关标记进行取值，
13 let newTuples : (animals : String, pet : Array) = tuples1
14 print("\(newTuples.animals)里有\(newTuples.pet[0])、\(newTuples.pet[1])、\(newTuples.pet[2])")
15 
16 // 也可以在定义元组的时候给单个元素命名
17 var tuples2 = (city : "北京", area : ["海淀区", "朝阳区"])
18 // 取值时可以直接用名字来获取元素的值
19 print("\(tuples2.city)包括\(tuples2.area[0]),\(tuples2.area[1])")
20 
21 // 常量名可以省略, 要忽略的元组元素可直接用_表示
22 let (_, fruit) = tuples
23 print(fruit)
24 
25 // 方式2：直接根据下标取值
26 print("\(tuples.0)里有\(tuples.1[0]),\(tuples.1[1]),\(tuples.1[2])")

五、循环结构和分支结构

Swift里面的循环结构包含：for、for-in、while、repeat-while
Swift里面的分支结构包含：if、if－else

1、循环结构

1 var nameArray = ["yuanyuan", "GBLW", "WYW"]
 2 var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
 3 // MARK: - 循环结构
 4 // 1、for 循环
 5 // 第一种:
 6 // i++后面不能直接接{ 会报错，要打一个空格或者换行
 7 for var i = 1; i < 10; i++ {
 8     print(i)
 9 }
10 
11 // 第二种: ..< 半闭集范围操作符
12 for number in 1..<10 {
13     print(number)  // 不包括10
14 }
15 
16 // 第三种:  ... 闭集范围操作符
17 for number in 1...10 {
18     print(number)  // 包括10
19 }
20 
21 // 2、while 循环
22 var i = 8
23 while i > 0 {
24     print(i)
25     i--
26 }
27 
28 // repeat...while 相当于do...while，限制性一此循环体，再去判断条件语句，循环体至少走一次
29 repeat {
30     print("我爱你们")
31 }while 1 < 0
32 
33 // 使用循环遍历数组
34 for newName in nameArray {
35     print(newName)
36 }
37 
38 // 使用循环遍历字典
39 // 第一种：
40 for newAge in dic {
41     print(newAge)
42 }
43 // 第二种
44 for (key, value) in dic {
45     print("key = \(key), value = \(value)")
46 }

 

2、分支结构

switch分支结构：在Swift里面，switch的每个case后面会自动的添加一个break，所以不需要手动的去添加了。Swift里面的枚举是可以范围枚举的，系统会根据给定的数据自动的匹配相近的范围  

1 // MARK: - 分支结构
 2 // if
 3 let flag1 = true
 4 if flag1 == true {
 5     print("是真哒！")
 6 } else {
 7     print("嘿嘿，假哒，骗你哒")
 8 }
 9 
10 // switch
11 // 要求每个分支必须有代码
12 // switch形式使用fallthrough关键字，实现OC中没有break关键字的情况，每个case都执行
13 // 不写fallthrough，实现OC中有break关键字的情况
14 let value = 0
15 switch value {
16 case 0 :
17     print("0")
18     fallthrough
19 case 1 :
20     print("1")
21 //    fallthrough
22 default :
23     print("other")
24 }
25 
26 // case 后面可以使用一个范围
27 switch value {
28 case 0..<10 :
29     print("0 - 9")
30 case 10...20 :
31     print("10 - 20")
32 default :
33     print("额，不在范围内")
34 }
35 
36 // case 后面可以使用常量或者变量
37 switch value {
38 case var i where value >= 0 && value <= 6 : i = 99
39     print(i)
40 default :
41     print("other")
42 }
43 
44 // case 后面还可以使用元组
45 let point = (1, 10)
46 switch point {
47 case (10, 0) :
48     print("x = 10, y = 0")
49 case (2, 10) :
50     print("x = 2, y = 10")
51 case (_, 10) :
52     print("x = ?, y = 10")
53 default :
54     print("没")
55 }

六、枚举

C 语言中，枚举类型将枚举名和一个整型值相对应。
Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个确定的值。
如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。

注意：只有枚举值是Int类型时才会有递增

1 // MARK: - 枚举(enum)
 2 
 3 // 原始类型为int
 4 enum Direction : Int {
 5     case east = 0
 6     case south = 1
 7     case west = 2
 8     case north = 3
 9 }
10 // rawValue -- 枚举的原始值
11 print(Direction.east.rawValue)
12 
13 // 原始类型为string
14 enum Seasen : String {
15     case spring = "春天"
16     case summer = "夏天"
17     case autumn = "秋天"
18     case winter = "冬天"
19 }
20 print(Seasen.spring.rawValue)
21 
22 // 根据原始值获取相对应的枚举
23 print(Direction(rawValue: 2))

 七、函数

Swift里面用 func 表示声明一个函数。
Swift的文件格式里面没有类似于OC的.h文件。所以，如果需要定义一个私有的函数，可以在func前面添加private 修饰。

• 函数类型：函数定义格式

• 无参无返回值
• 无参有返回值
• 有参无返回值
• 有参有返回值
• 有参多个返回值（返回一个元组）

• 
  

func 函数名（参数名：参数类型，参数名：参数类型....）->返回值类型 {
　　函数实现
　　return 返回值
}

• 外部参数和内部参数

　　Swift中，一个参数有两个名字，内部参数名和外部参数名
　　内部参数名：在函数内部使用的参数名称。
　　外部参数名：在函数调用时候，显示的参数名称

• 忽略外部参数

　　默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名一致
　　如果不想要显示外部参数名，可以使用“_”忽略掉
注意：函数的第一个参数不能使用“_ ”忽略掉外部参数名。

• 函数嵌套

　　函数嵌套：Swift里面可以函数嵌套定义
注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的

• inout参数

inout参数:
　　1.参数默认是用let修饰,即常量
　　2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.
　　3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.此时实参必须是变量，且调用函数的时候传的参数是实参的地址

1 // MARK: - 函数
 2 // 表示函数的关键字 func 
 3 // 函数的类型有五种：
 4 // 1、无返回值无参数  ->Void 可省略
 5 func function1() -> Void {
 6     
 7 }
 8 
 9 // 2、无返回值有参数  ->Void 可省略
10 func function2(str: String) -> Void {
11     print(str)
12 }
13 
14 function2("baekhyun")
15 
16 // 3、有返回值无参数
17 func function3() -> String {
18     return "boom sky"
19 }
20 
21 print(function3())
22 
23 // 4、有返回值有参数
24 func function4(num1 : Int, num2 : Int) -> Int {
25     return num1 + num2
26 }
27 
28 print(function4(1, num2: 2))
29 
30 // 5、有参，返回值为元组类型
31 func function5(a : Int, b : Int) -> (Int, Int, Int, Int) {
32     return (a - b, a + b, a * b, a / b)
33 }
34 
35 print(function5(5, b: 6))
36 
37 // 外部参数和内部参数
38 // 内部参数名：在函数内部使用的参数名
39 // 外部参数名：在函数调用的时候，显示的参数名
40 func function6(first one : Int, second two : Int) {
41     print(one, two)
42 }
43 
44 function6(first: 2, second: 5)
45 
46 // 忽略外部参数
47 // 默认情况下，函数调用时，函数的第一个参数不显示外部参数名，其余参数显示外部参数名，并且和内部参数名一致，如果不想要显示外部参数名，可以使用 _ 忽略掉
48 // 注意：函数的第一个参数不能使用 _ 忽略掉外部参数名
49 func function7(one : Int, _ two : Int) {
50     print(one, two)
51 }
52 function7(3, 6)
53 
54 // 函数嵌套 : Swift里函数可以嵌套定义
55 // 注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的
56 func function8() {
57     print("第一层")
58     func function9() {
59         print("第二层")
60     }
61     // 调用function9, 不调用的话function9不会执行
62     function9()
63 }
64 
65 function8()
66 
67 // inout参数
68 // 如果形参使用inout来修饰，就变成了输入输出参数，在函数内部改变形参的值，实参的值也会变
69 func function10 (inout name : String) {
70     name = "Baek"
71     print(name)
72 }
73 // 实参要定义为变量，不能定义成常量，否则不能传参给输入输出参数
74 var myName = "Hyun"
75 function10(&myName)  // 传入的是个地址
76 print("myName : " + myName)

补充：

Swift中导入类库使用import，不再使用<>。不需要导入自定义类。
语句结尾的分号可有可无