视频：P9-16 日期：4.27/4.28
目录
2.guard 语句和 if 语句，在处理可选项绑定之间的区别比较
P9：while 循环和 repeat while 循环
1.while 循环
var a = 0
var b = true
while (b)
{
print(a)
a += 1
if (a > 5)
{
b = false
}
}
/*
0
1
2
3
4
5
*/2.repeat while 循环 （先运行再判断）
var a = 0
var b = true
repeat
{
print(a)
a += 1
if (a>5)
{
b = false
}
}
while(b)
/*
0
1
2
3
4
5
*/P10：String 基础操作
1.获取字符串长度
import UIKit
var str = "ABCDEF"
let size = str.count //获取字符串长度，有空格也算
print("字符串长度 = " + String(size))
/*
字符串长度 = 6
*/2.获取子字符串
值得注意的是，String类型的索引，不是Int类型，而是一个String.Index.
import UIKit
var str = "ABCDEF"
//获取第一个字符串str[str.startIndex]返回的是一个字符串，然后用String()转成字符串了
print("获取ABCDEF种第一个字符串 = " + String(str[str.startIndex]))
//print(str[str.endIndex])//这样不能获取最后一个字符
//注意str.index()方法，里面参数是before,而 str.endIndex表示结尾，那么传给before,表示结尾位置的前一个位置，是字符串的最后一个字符位置
print("获取ABCDEF中最后一个字符串 = " + String(str[str.index(before: str.endIndex)]))
//下面代码就会越界异常，因为str.index表示字符串结尾位置，传给after表示结尾位置的后一个位置，都超过整个字符串了，所以报错
//print(String(str[str.index(after:str.endIndex)]))
print("获取ABCDEEF中索引为4的字符串 = " + String(str[str.index(str.startIndex,offsetBy:4)]))
print("获取ABCDEF中，开始位置的后一位的字符串 = " + String(str[str.index(after:str.startIndex)]))
print("获取ABCDEF中，结束位置的前一位的字符串 = " + String(str[str.index(before:str.endIndex)]))
print("获取ABCDEF中，从0位置开始，长度为4的子字符串 = " + String(str.prefix(4)))
print("获取ABCDEF中，从0位置开始，长度为4的子字符串 = " + String(str.prefix(upTo: str.index(str.startIndex,offsetBy: 4))))
let inde = str.firstIndex(of: "E") ?? str.endIndex//返回第一次出现的E索引
print("获取ABCDEF中，从起始位置开始，到E结束的字符串 = " + String(str[str.startIndex...inde]))
let inde2 = str.index(str.endIndex,offsetBy:-2)
print("获取ABCDEF中，后2位的字符串 = " + String(str[inde2..<str.endIndex]))
let a = str.index(str.startIndex,offsetBy: 2)
let b = str.index(str.startIndex,offsetBy: 4)
print("获取ABCDEF中，索引为2到4的字符串 = " + String(str[a...b]))
/*
获取ABCDEF种第一个字符串 = A
获取ABCDEF中最后一个字符串 = F
获取ABCDEEF中索引为4的字符串 = E
获取ABCDEF中，开始位置的后一位的字符串 = B
获取ABCDEF中，结束位置的前一位的字符串 = F
获取ABCDEF中，从0位置开始，长度为4的子字符串 = ABCD
获取ABCDEF中，从0位置开始，长度为4的子字符串 = ABCD
获取ABCDEF中，从起始位置开始，到E结束的字符串 = ABCDE
获取ABCDEF中，后2位的字符串 = EF
获取ABCDEF中，索引为2到4的字符串 = CDE
*/3.其他常用操作
//其他常用操作
import UIKit
var str = "ABCDEF"
//判断是否包含某个字符串
print("判断ABCDEF是否包含某个字符串 = " + String(str.contains("ABC")))
print("判断ABCDEF是否包含某个字符串 = " + String(str.contains(where:String.contains("BK"))))//只要一个字符在str中，就返回true
print("判断ABCDEF是否包含某个字符串前缀 = " + String(str.hasPrefix("AB")))//只要一个字符在str中，就返回true
print("判断ABCDEF是否包含某个字符串后缀 = " + String(str.hasSuffix("EF")))//只要一个字符在str中，就返回true
str.append("GHIJK") //在原来的字符串中追加字符串
print("在原来的字符串中追加字符串 = " + str)
str.insert(contentsOf:"hello",at:str.index(str.startIndex,offsetBy:2))//在原来的字符串中，索引为2的位置插入新字符串
print("在原来字符串中索引为2的位置插入新字符串 = " + str)
let index1 = str.index(str.startIndex,offsetBy:1)
let index2 = str.index(str.startIndex,offsetBy:3)
let range = index1...index2
str.replaceSubrange(range,with:"123")//替换原字符串1-3的索引位置
print("将原来字符串中索引为1-3的位置，替换成字符串123 = " + str)
var new_value = str.replacingOccurrences(of:"IJ", with: "888")
print("在原来字符串中索引为2的位置插入新字符串 = " + new_value)
str.remove(at:str.index(str.startIndex,offsetBy:2))
print("删除原来字符串中的索引为2位置的字符串 = " + str)
str.removeSubrange((str.index(str.startIndex,offsetBy: 1)...(str.index(str.startIndex,offsetBy: 3))))
print("删除原来字符串中的索引为1-3位置的字符串 = " + str)
/*
判断ABCDEF是否包含某个字符串 = true
判断ABCDEF是否包含某个字符串 = true
判断ABCDEF是否包含某个字符串前缀 = true
判断ABCDEF是否包含某个字符串后缀 = true
在原来的字符串中追加字符串 = ABCDEFGHIJK
在原来字符串中索引为2的位置插入新字符串 = ABhelloCDEFGHIJK
将原来字符串中索引为1-3的位置，替换成字符串123 = A123lloCDEFGHIJK
在原来字符串中索引为2的位置插入新字符串 = A123lloCDEFGH888K
删除原来字符串中的索引为2位置的字符串 = A13lloCDEFGHIJK
删除原来字符串中的索引为1-3位置的字符串 = AloCDEFGHIJK
*/4.遍历字符串
import UIKit
var str = "ABCDEF"
//第一种方法，直接遍历
for value in str
{
print(value)
}
print("\n")
//第二种方法，利用索引
for index in 0..<str.count
{
print(String(str[str.index(str.startIndex,offsetBy: index)]))
}
print("\n")
//反向遍历
for index in (0..<str.count).reversed()
{
print(String(str[str.index(str.startIndex,offsetBy: index)]))
}
/*
A
B
C
D
E
F
A
B
C
D
E
F
F
E
D
C
B
A
*/
5.格式化文本输出
var value = """
hello
swift
world
"""
print(value)
/*
hello
swift
world
*/6.类转义输出
var value = #""hello""#
print(value)
var value2 = #""he""llo""#
print(value2)
/*
"hello"
"he""llo"
*/P11：Array 数组
1.数组的定义
import UIKit
var array:Array<Int> = [] //定义可以存放Int类型的空数组
print(array)
print("--------------------")
var arra1 = [Int]() //通过初始化器，定义可变的空数组
arra1.append(1)
arra1.append(2)
arra1.append(3)
print(arra1)
print("--------------------")
let arra2 = [4,5,6] //用let定义的常量，不可变数组，不能改变长度和数据，但是可以取值
//arra2.append(7) //报错，不能添加
//arra2[0] = 10 //报错，无法修改
print(arra2)
print("--------------------")
var arra3 = Array(repeating:-1,count:3) //通过Array初始化器，生成一个，初始值为-1，长度为3的数组
print(arra3)
arra3.replaceSubrange((0..<arra3.count),with:[7,8,9]) //全部替换成7，8，9
print(arra3)
print("--------------------")
//简单定义数组的方式-类型推断
var a = [1,2,3,4]
print(a)
//定义数组元素类型是String的定义方式
var b:[String] = ["hello","world"]
print(b)
//Double
var c:Array<Double> = [1.4,1.6]
print(c)
c[0] = 12.5 //修改数组Array的值
print(c[0]) //直接索引数组的值
print(c[1])
/*
[]
--------------------
[1, 2, 3]
--------------------
[4, 5, 6]
--------------------
[-1, -1, -1]
[7, 8, 9]
--------------------
[1, 2, 3, 4]
["hello", "world"]
[1.4, 1.6]
12.5
1.6
*/
2.数组的基本操作
import UIKit
var array = ["hello","world","swift"]
print(array.count) //获取数组长度
var value = array[0] //通过索引获得array数组中的第一个数据
print(value)
array[1] = "apple" //通过索引修改相应数据
print(array)
array.append("ipone") //在结尾处添加新数据
print(array)
array.insert("macbook",at:2) //在指定索引位置插入新数据
print(array)
array.replaceSubrange((1...3),with:["macos","windows"])
//将数组索引1，2，3位置的数据，替换成后面{"macos","windows"]数据
print(array)
array.replaceSubrange((0..<1),with:["android","linux"])
//将数组索引位置为0的数据替换为后面["android","linux"]数据
print(array)
var new_array = array + ["win10","win7"]//用+拼接数组，返回新数组
print(new_array)
new_array.remove(at:0) //删除指定索引位置上的数据
print(new_array)
var b = new_arrray.contains("macos") //数组中是否包含指定数据
print(b)
/*
3
hello
["hello", "apple", "swift"]
["hello", "apple", "swift", "ipone"]
["hello", "apple", "macbook", "swift", "ipone"]
["hello", "macos", "windows", "ipone"]
["android", "linux", "macos", "windows", "ipone"]
["android", "linux", "macos", "windows", "ipone", "win10", "win7"]
["linux", "macos", "windows", "ipone", "win10", "win7"]
true
*/3.数组排序
var array = ["A","C","D","B","F","E"]
//正序排序
array.sort(by:{(item1,item2) -> Bool in
if (item1 > item2)
{
return false
}
else
{
return true
}
})
print(array)
//倒序排序
array.sort(by:{(item1,item2) -> Bool in
if (item1 > item2)
{
return true
}
else
{
return false
}
})
print(array)
/*
["A", "B", "C", "D", "E", "F"]
["F", "E", "D", "C", "B", "A"]
*/4.数组过滤
//数组过滤
var array = [2,3,1,5,9,7]
//过滤数组，返回新的数组
var array2 = array.filter({(item) -> Bool in
if (item > 5 )
{
return true
}
else
{
return false
}
})
print(array) //保留了大于5的值
print(array2)
/*
[2, 3, 1, 5, 9, 7]
[9, 7]
*/5.数组比较
var array1 = [1,2,3]
var array2 = [1,2,3]
if (array1 == array2) //判断数组顺序内容和长度是否相等
{
print("array1与array2相等")
}
else
{
print("array1与array2不相等")
}
var array3 = [1,2,3]
var array4 = [1,2]
if (array3 == array4) //判断数组顺序内容和长度是否相等
{
print("array3与array4相等")
}
else
{
print("array3与array4不相等")
}
/*
array1与array2相等
array3与array4不相等
*/6.遍历数组
//遍历
var array = ["A","B","C","D"]
print("// 1 直接取值遍历")
//查看遍历数组
for item in array
{
print(item)
}
print("// 2 通过区间运算符直接取值遍历")
//利用区间运算符0...配合循环直接获取数组里的值
//这里需要注意的是0...虽然表示0到无限大，但是在数组内，就表示0..<array.count
for item in array[0...]
{
print(item)
}
print("// 3 利用区间运算符控制范围直接取值遍历")
for item in array[0...]
{
print(item)
}
print("// 4 通过区间运算符获取索引遍历")
//通过索引遍历数据
for index in 0..<array.count
{
print(array[index])
}
print("// 5 通过区间运算符获取索引，反向遍历")
//反向遍历数组
for index in (0..<array.count).reversed()
{
print(array[index])
}
/*
// 1 直接取值遍历
A
B
C
D
// 2 通过区间运算符直接取值遍历
A
B
C
D
// 3 利用区间运算符控制范围直接取值遍历
A
B
C
D
// 4 通过区间运算符获取索引遍历
A
B
C
D
// 5 通过区间运算符获取索引，反向遍历
D
C
B
A
*/P12：Set 集合
注意，swift中集合也是无序的。
1.集合的定义
//定义set集合
var a:Set = ["hello","world","swift"] //通过数字创建一个Set类型的集合
print(a)
var b:Set<Int> = [1,2,3] //通过数组创建一个Set类型的集合，并且明确指定Set集合里面的数据是Int类型
print(b)
let c:Set = ["a","b","c"] //创建不可修改的Set集合
print(c)
var d:Set<String> = [] //创建空Set集合
print(d)
/*
["hello", "swift", "world"]
[2, 3, 1]
["b", "c", "a"]
[]
*/2.集合常用操作
var set_list:Set = ["hello","world","swift"]
print(set_list.count) //获取长度
set_list.insert("ios") //添加新数据
print("set_list :" , set_list)
var b = set_list.contains("ios") //是否包含某个数据
print(b)
set_list.remove("hello") //删除某个数据
print("set_list去掉hello :" , set_list)
let data:Set = ["iphone","android","ios","swift"]
print("data = ",data)
//union()函数--取并集
var new_set1 = set_list.union(data) //将两个Set合并，返回新的Set
print("并集：", new_set1)
//intersection()函数--取交集
var new_set2 = set_list.intersection(data) //返回两个Set中相同的数据
print("交集: ", new_set2)
//symmetricDifference()函数--取不同的值
var new_set3 = set_list.symmetricDifference(data)//返回两个Set中不同的数据
print("取不同的值 :" , new_set3)
//subtracting()函数--返回前面set中与后面set不同的值
var new_set4 = set_list.subtracting(data) //两个set比较，返回前面Set中与后面Set中不同的数据
print("前面set中与后面set不同 : " , new_set4)
/*
3
set_list : ["world", "swift", "hello", "ios"]
true
set_list去掉hello : ["world", "swift", "ios"]
data = ["swift", "android", "iphone", "ios"]
并集： ["world", "iphone", "swift", "ios", "android"]
交集: ["swift", "ios"]
取不同的值 : ["world", "iphone", "android"]
前面set中与后面set不同 : ["world"]
*/3.集合相等判断
var a:Set = ["A","B"]
var b:Set = ["B","A"]
if (a == b)
{
print("两个集合相等")
}
else
{
print("两个集合不相等")
}
//因为是无序的，所以即使顺序不一样，只要元素相同，集合仍然是相等的。
/*
两个集合相等
*/4.集合过滤
//Set过滤
var set_list:Set = ["A","B","C","D"]
var new_set = set_list.filter({(item) -> Bool in
if(item == "B" || item == "D") //过滤掉B和D
{
return false
}
else
{
return true
}
})
print(new_set)
/*
["C", "A"]
*/5.遍历集合
//因为Set无序，所以不能用索引进行遍历
var set_list:Set = ["A","B","C","D"]
for item in set_list
{
print(item)
}
/*
A
C
B
D
*/P13：Dictionary 字典
1.字典的定义
var dic1:Dictionary<String,String> = ["a":"apple","b":"back","c":"call"] //指定键值对类型
print(dic1)
var dic2 = [1:"ios",2:"android",3:"windows"] //键值对类型推断
print(dic2)
var dic3:[Int:String] = [1:"ios",2:"android",3:"windows"]//指定类型
print(dic3)
var dic4:Dictionary<Int,String> = [Int:String]() //空字典
print(dic4)
var dic5 = [Int:String]() //空字典
print(dic5)
let dic6 = ["a":"A","b":"B","c":"C"] //空字典
print(dic6)
/*
["b": "back", "a": "apple", "c": "call"]
[2: "android", 3: "windows", 1: "ios"]
[2: "android", 1: "ios", 3: "windows"]
[:]
[:]
["a": "A", "c": "C", "b": "B"]
*/2.字典的基本操作
//字典基本操作
var dic = ["a":"A","b":"B","c":"C"]
print(dic.count) //获得长度
print(dic)
dic["a"] = "apple" //修改键对应的值
print(dic)
dic.updateValue("background",forKey:"b") //更新键对应的值
print(dic)
dic.updateValue("dicionary",forKey:"d") //如果key不存在就添加新的键值对
print(dic)
//可选项绑定，前面关于if语句的章节中介绍过，就不解释了
//简单来说如果有指定的key就返回值，赋给item，执行if语句，如果没有key就返回nil，不执行if语句
if let item = dic["c"]
{
print(item)
}
dic.removeValue(forKey:"c") //删除某个key对应的值
print(dic)
/*
3
["c": "C", "b": "B", "a": "A"]
["c": "C", "b": "B", "a": "apple"]
["c": "C", "b": "background", "a": "apple"]
["b": "background", "d": "dicionary", "a": "apple", "c": "C"]
C
["d": "dicionary", "a": "apple", "b": "background"]
*/3.字典过滤
//过滤
var dic = ["a":"A","b":"B","c":"C"]
//过滤字典集合，返回新的字典集合
var new_dic = dic.filter({(key,value) -> Bool in
if (key != "b")
{
return true
}
else
{
return false
}
})
print(new_dic)
/*
["a": "A", "c": "C"]
*/4.遍历字典
var dic = ["a":"A","b":"B","c":"C"]
//直接遍历
for (key,value) in dic
{
print("key = " + key + "value = " + value)
}
/*
key = avalue = A
key = bvalue = B
key = cvalue = C
*/P14：函数定义、函数参数名称、assert断言
1.函数定义
import UIKit
//不带参数直接定义
func test()
{
print("test()hhh")
}
test()
//不带参数返回指定Int类型
func test2() -> Int
{
return 100
}
print(test2())
//带String参数返回指定String类型
func test3(name:String) -> String
{
return name
}
print(test3(name:"hello world"))
//带String类型的很多个参数，不指定返回类型
func test4(name:String...)
{
for item in name
{
print(item)
}
}
test4(name:"a","b",String(3))
//下面这种情况报错，不能有多个...的类型，只能有一个
/*
func test5(name:String...,n:Int...)
{
for item in name
{
print(item)
}
}
test5(name:"a","b",String(3),n:1,2)
*/
//传人数组类型的参数，传出数组类型的参数，进行索引操作输出
func test5(name:(n1:String,n2:Int)) -> (String,Int)
{
var value:(a:String,b:Int)
value.a = name.n1 + "world"
value.b = name.n2 + 10
return value
}
var value = test5(name:("hello ",20))
print(value.0)
print(value.1)
/*
test()hhh
100
hello world
a
b
3
hello world
30
*/2.函数参数名称问题
import UIKit
//outname是外部调用名，inname是内部使用名，用空格分隔，与返回值无关
//且两个name的值完全相等，只是用的位置不同
func test(outname inname:String)
{
print(inname)
}
test(outname:"hello")
//若不穿入outname，可以直接用下划线代替，但是在调用函数的时候就不能传入outname了，会报错
/*
func test2(_ inname:String)
{
print(inname)
}
test2(outname:"swift")
*/
//应该改成：
func test2(_ inname:String) //表示忽略outname
{
print(inname)
}
test2("swift") //在这里直接传值就ok
//也不能写 test2(inname:"swift") 不能直接传入内部名称
//也不能写 func test2(outname _:String) 不能忽略inname
//正常使用：
func test3(outn1 inn1:String, outn2 inn2:Int)
{
print(inn1,inn2)
}
test3(outn1: "aaaaa", outn2: 123456)
/*
hello
swift
aaaaa 123456
*/3.assert断言
//assert断言：
//assert函数可以让程序停止运行
import UIKit
func play(param:Int)
{
if (param<10)
{
assert(false , "停止运行")
}
print("值 = " + String(param))
}
play(param: 10) //程序没有停止运行
play(param: 5) //整个程序停止运行
/*
值 = 10
Assertion failed: 停止运行: file __lldb_expr_1/MyPlayground1.playground, line 43
*/P15：guard 语句
1.guard 语句
import UIKit
//guard语句就是一个进行拦截的guard+else+return 语句
func test1(param:Int)
{
guard (param < 5) else
{
print("进入guard语句，param = " + String(param))
return
}
print("没有进入guard语句，param = " + String(param))
}
test1(param: 10) //没有进入guard语句
print()
test1(param: 3) //进入guard语句
print("--------------------------------")
//与if语句进行对比
func test2(param:Int)
{
if (param < 5)
{
print("进入if语句，param = " + String(param))
}
else
{
print("进入if else 语句，param = " + String(param))
return //进入if else 语句之后就return了，后面的就不会再执行了
}
print("在 if 语句外部") //进入if语句后没有return 还是会继续执行
}
test2(param: 10)
print()
test2(param: 3)
/*
进入guard语句，param = 10
没有进入guard语句，param = 3
--------------------------------
进入if else 语句，param = 10
进入if语句，param = 3
在 if 语句外部
*/2.guard 语句和 if 语句，在处理可选项绑定之间的区别比较
guard 语句也可以用 if 语句写
import UIKit
//优点：进行空值判断，如果变成了空值就进行拦截
var a:String? = "swift"
var b:String? = nil
func test1(param:String?)
{
guard let value = param else
{
print("进入guard语句里")
return //进行拦截
}
print(value)
}
test1(param: a)
//如果a有值就把a的值传给param，如果param有值就不拦截，如果value没值就被拦截
test1(param: b)
//因为b没值，所以进入guard语句进行拦截
/*
swift
进入guard语句里
*/P16：inout 关键字、函数类型
1.inout 关键字
相当于把值传递变为传“引用”
（别忘记inout 和 &）
import UIKit
//在一般情况下不能直接使用传入函数的参数param，会报错，例如：
/*
func test(param:Int)
{
param = param * 2 //Cannot assign to value: 'param' is a 'let' constant
print(param)
}
test(10) //Missing argument label 'param:' in call
*/
//但是inout关键字可以帮助我们使用传入参数本身：
func test2(param: inout Int)
{
param = param * 2
print(param)
}
var a = 10
print("传递前 a = " + String(a))
test2(param: &a)
print("传递后 a = " + String(a))
/*
传递前 a = 10
20
传递后 a = 20
*/2.函数类型
函数类型的定义
//定义几个函数类型
var a:() -> Void //最好带上Void，否则()可能会被误解为定义了一个元组
var b:(Int,String) -> String
var c:(Bool,Array<Int>) -> String
let d:([Int]) -> (Int,String)
let e:((name1:Int,name2:String)) -> Dictionary<String,String>
函数类型的使用: 函数类型的变量或常量赋值
func test1() -> Void
{
print( "test1()" )
}
var a:() -> Void = test1
a()
print("-------------------------")
//1 匿名函数使用
var b:() -> Void = ({() -> Void in //这个in不能省略
print("test1()")
})
b()
print("-------------------------")
//2 一般使用
func test2(param1:String,param2:Int)-> String
{
return param1 + String(param2)
}
var c:(String,Int) -> String = test2
print(c("hello",12))
print("-------------------------")
//2-匿名函数使用
var d:(String,Int) -> String = ({(param1:String,param2:Int) -> String in
return param1 + String(param2)
})
print(d("hello",13))
/*
test1()
-------------------------
test1()
-------------------------
hello12
-------------------------
hello13
*///也可以用常量
//3 一般使用
func test3(param:[Int]) -> String
{
var temp:String = "hao"
for item in param
{
temp = temp + String(item)
}
return temp
}
let e:([Int]) -> String = test3
print(e([1,2,3]))
print("-------------------------")
//3 匿名函数使用
let f:([Int]) -> String = ({(param:[Int]) -> String in
var temp:String = "hao"
for item in param
{
temp = temp + String(item)
}
return temp
})
print(f([3,4,5]))
/*
hao123
-------------------------
hao345
*/
2019
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
