Swift - 1 (常量变量字符串数组字典元组循环枚举函数）

Posted 2020-07-10 不忘初心，方得始终

Swift 中导入类库使用import，不再使用<>,导入自定义不再使用""

import Foundation

1> 声明变量和常量

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

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

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

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

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

 1 //MARK: - 定义常量、变量
 2 // 定义常量（使用完第一次就不能修改他的值了） 
 3 // 用let最好给定初始值，因为使用一次不能在修改
 4 let myGender = "♂"
 5 //myGender = "男"
 6 
 7 // 定义变量
 8 var carName = "BMW"
 9 carName = "Audi"
10 print(carName)    // 加不加引号都可以
11 
12 //MARK: - 定义常量变量：变量类型的隐式转换
13 // 在swift中如果定义常量变量不给定相关的类型，它会隐式转换成你给定的初始值
14 let name = "Rose"    // 如果这样自定义出来一个常量，它会隐式转换成string类型
15 let name1 : String = "Jack"   // 如果给定类型，后边赋值的时候需要根据类型进行赋值
16 
17 let age : Int = 18   // 如果定义常量最好给初始值，定义变量可以不给初始值
18 
19 var age1 : Int?    // ? 表示age1 的类型为可选类型，其值可以为空
20 print(age1)
21 
22 var char : Character =  "a"  // 赋值字符类型的时候仅需一个字母即可
23 
24 // 定义一个BOOL类型的变量 [在swift中 bool类型只有true or false]
25 var flag : Bool = true

2> 字符串

• String是有序的字符集合

• Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合

• \(变量名)输出相关内容【插入式取值】

 1 //MARK: - 字符串string
 2 //(1)创建一个空字符串
 3 var str_empty = ""
 4 var str1_empty = String()
 5 
 6 //(2)判断一个字符串为空字符串
 7 if str_empty.isEmpty{
 8     print("str_emrty is empty")
 9 }
10 
11 //(3)字符串的拼接
12 var str_url = "http://"
13 var str = "www.baidu.com"
14 
15 let str_new_url = str_url + str
16 print(str_new_url)
17 print("百度网址：\(str_new_url)")   //  \（变量名）输出相关的内容【插入式取值】
18 
19 //(4)获取字符串的长度
20 var str1 : String = "abcde"
21 print(str1.characters.count)
22 
23 //(5)字符串的比较
24 var str2 = "MBBoy"
25 var str3 = "GBLW"
26 
27 if str2 != str3 { // == 相等   != 不相等
28     print("这两个不相等")
29 }

3. 数组、字典

　1> 数组

 1 //MARK: - 数组
 2 //Swift 中数组的元素类型必须相同
 3 //定义一个数组
 4 var nameArray = ["yuanyuan","GBLW","WYW"]
 5 print(nameArray)
 6 
 7 var nameArray1 : Array<String> = ["YaQian","ZhaTian"]
 8 print(nameArray1)
 9 
10 //定义一个空数组(字符串)
11 let array : Array = Array<String>()
12 print(array)
13 
14 //访问数组的元素
15 print(nameArray[1])
16 
17 //向数组中添加元素
18 var int_array = Array<Int>()
19 int_array.append(520)
20 int_array.append(123)
21 print(int_array)
22 
23 //使用运算符添加数组元素
24 int_array += [100]
25 //使用运算符添加多个数组元素
26 int_array += [111,222]
27 print(int_array)
28 
29 //插入元素到具体位置
30 int_array.insert(521, atIndex: 1)
31 print(int_array)
32 
33 //移除某个元素
34 int_array.removeAtIndex(3)
35 print(int_array)
36 
37 // 移除所有元素
38 int_array.removeAll()
39 print(int_array)

2> 字典

 1 //MARK: - 字典
 2 //定义一个字典类型的变量
 3 var dic : Dictionary<String,Int> = ["a":18,"b":16,"c":38]
 4 print(dic)
 5 
 6 //定义空字典
 7 var dic1 : Dictionary<String,Int> = [:]
 8 print(dic1)
 9 var dic2 = Dictionary<String,Int>()
10 print(dic2)
11 
12 //向字典里添加键值对
13 dic["d"] = 30
14 print(dic)
15 
16 //修改字典中的内容（根据键值去修改）
17 dic["a"] = 90
18 print(dic)
19 //打印某个元素的值
20 print(dic["a"])
21 
22 //删除字典中的内容(根据键去删除)
23 dic.removeValueForKey("c")
24 print(dic)

4. 元组

 1 //MARK: - 元组
 2 //定义一个元组
 3 //方法一：直接初始化一个元素（使用Swift隐式转换的特点）
 4 let tuples = ("苹果",["ios","html5","android"])
 5 print(tuples)
 6 //方法二：显示初始化的方式
 7 let tuples1 : (String,Array) = ("安卓",["iOS","html5","Android"])
 8 print(tuples1)
 9 
10 //可变元组和不可变元组
11 var superTuples = (name:"asd", 12, ["111", "222"])
12 superTuples.name = "qwe"
13 print(superTuples.name)  //会打印name变成qwe
14 
15 //let superTuples = (name:"asd", 12, ["111", "222"])
16 //superTuples.name = "qwe"
17 //print(superTuples.name)  //会报错
18 
19 ////需要注意的是，可变元组虽然可以修改数据，但却不能改变其数据的数据类型：
20 //var superTuplesType = (name:"asd", 12, ["111", "222"])
21 //superTuplesType.name = 1
22 //print(superTuples.name)  //会报错
23 
24 //取出元组中的值
25 //第一种取值方式：直接把元组赋值给另外一个常量，根据相关的标记进行取值
26 let tuples_new : (appStyle:String,course:Array) = tuples
27 var classInfo = tuples_new.appStyle + tuples_new.course[0] + tuples_new.course[1] + tuples_new.course[2]
28 print(classInfo)
29 
30 //第二种取值方式：直接根据下标进行取值
31 let classInfoNew = tuples_new.0 + tuples_new.1[0] + tuples_new.1[1] + tuples_new.1[2]
32 print(classInfoNew)

5. 循环结构

　1> 概述

　　Swift里面的循环结构包含：for、for-in、while、repeat-while

　2> 循环

 1 //MARK: - 循环
 2 //第一种形式：
 3 for var i = 1; i < 10; i++
 4 {
 5     print(i)
 6 }
 7 
 8 // 第二种形式
 9 // 1到9
10 for number in 1..<10
11 {
12     print("number:\(number)")
13 }
14 
15 //第三种形式
16 // 1到10
17 for number in 1...10
18 {
19     print("number:\(number)")
20 }
21 
22 //while循环和repeat...while
23 var i = 8
24 while i > 0
25 {
26     i--
27     print(i)
28 }
29 
30 repeat
31 {  // 限制性一次循环体，在进行相关的循环
32     print("woaini")
33 }while 1 < 0
34 
35 //使用循环遍历数组
36 var animalArray = ["cat","dog","tiger","monkey","fish"]
37 for animal in animalArray
38 {
39     print(animal)
40 }
41 
42 //使用循环遍历字典
43 var animalDic = ["pig":"??","dog":"??","fish":"??"]
44 for (key,value) in animalDic
45 {
46     print("key: \(key), value: \(value)")
47 }

6. 分支结构

1> if分支结构

2> switch结构

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

 1 //MARK：- 分支结构（if结构和switch格式）
 2 //if形式的
 3 let flag1 = true
 4 if flag1 == true
 5 {
 6     print("我是真的")
 7 } else {
 8     print("不可描述")
 9 }
10 
11 print("=====================================================")
12 //特点1：switch形式的使用fallthrough实现贯穿每种可能
13 let value = 0
14 switch value
15 {
16 case 0:
17     print("0")
18     fallthrough
19 case 10:
20     print("10")
21     fallthrough
22 default:
23     print("other")
24 }
25 
26 //特点2：case后可以使用一个范围
27 switch value
28 {
29 case 0..<10:
30     print("0 到 9")
31 case 10...100:
32     print("10 到 100")
33 default:
34     print("other")
35 }
36 
37 //特点3：case后可以使用（let和var修饰的常量或者变量）where是满足某种条件
38 switch value
39 {
40 case var i where value >= 0 && value < 6:
41     i = 99
42     print(i)
43 default:
44     print("other")
45 }
46 
47 //特点4：case后还可以匹配一个元祖
48 let point = (10,10)
49 switch point
50 {
51 case (10,0):
52     print("111111")
53 case (10,8):
54     print("222222")
55 case (_,10):    // 横杠代表可以忽略某个元素
56     print("333333")
57 case (10,10):
58     print("444444")
59 default:
60     print("other")
61 }

注意：

• 不需要添加break关键字，也不会贯穿

• 添加fallthrough，可以实现贯穿

• switch要求每个分支必须包含代码

7. 枚举

　1> 概述

• C 语言中，枚举类型将枚举名和一个整型值相对应。

• Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个确定的值。

• 如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。

　2> 代码

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

8. 函数

1> 概述

• Swift里面用 func 表示声明一个函数。

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

　2> 函数定义格式

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

　3> 函数类型 五种

//MARK: - 函数
//表示函数的关键字 func
//函数的类型有：五种

//1:无返回值，无参数
func function1() ->Void
{
    print("无返回值，无参数")
}
function1()

//2:无返回值，有参数
func function2(name str:String) ->Void
{
    print("无返回值，有参数 = \(str)")
}
function2(name: "GBLW")

//3:有返回值，无参数
func function3() ->String
{
    print("有返回值，无参数")
    return "炸天"
}
print(function3())

//4:有返回值，有参数
func function4(num1:Int, num2:Int) ->Int
{
    print("有返回值，有参数")
    return num1 + num2
}
print(function4(6, num2: 9))

//5：函数返回值为元组类型的
func function5(num1:Int, num2:Int) ->(Int,Int,Int)
{
    return (num1+num2, num1-num2, num2*num1)
}
print(function5(7, num2: 6))

3> 外部参数和内部参数

• Swift中，一个参数有两个名字，内部参数名和外部参数名

• 内部参数名：在函数内部使用的参数名称。

• 外部参数名：在函数调用时候，显示的参数名称

1 //外部参数和内部参数
2 //first、second就叫做外部参数：在函数调用的时候会显示出来这两个名称
3 //one、two内部参数：在函数内部使用的
4 //默认的情况下，第一个外部参数在调用的时候不显示，其余的均显示，而且和你定义的名字一样
5 func function6(first one:Int, second two:Int)
6 {
7     print((one,two))
8 }
9 function6(first: 10, second: 2)

4>函数的嵌套

 1 //函数的嵌套
 2 func test1()
 3 {
 4     func test2()
 5     {
 6         func test3()
 7         {
 8             print("哈哈，我穿了好多层")
 9         }
10         test3()
11     }
12     test2()
13     print("哈哈，好有意思")
14 }
15 test1()

5> 忽略外部参数

• 默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名一致

• 如果不想要显示外部参数名，可以使用“_”忽略掉

• 注意：函数的第一个参数不能使用“_ ”忽略掉外部参数名。

1 //若果都不想显示外部参数  "_"的作用是忽略外部参数
2 func function7(one:Int,_ two:Int)
3 {
4     print("忽略外部参数")
5 }
6 function7(8, 8)

6> inout参数

　　inout参数:

　　　参数默认是用let修饰,即常量

　　　在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.

　　　如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.

 1 //inout修饰的参数
 2 func test(inout name:String)
 3 {
 4     name = "girl"
 5     print(name)
 6 }
 7 var myName = "yuanyuan"
 8 print("myName = \(myName)")
 9 test(&myName)
10 print("myName = \(myName)")
11 
12 func admin (var name:String)
13 {
14     name = "lol"
15     print("nameOld = \(name)")
16 }
17 var lolName = "LOL"
18 print("lolName = \(lolName)")
19 admin(lolName)
20 print("lolName = \(lolName)")