一. 认识Swift
1.标识符的命名规则
1. 字母(Unicode字符)、数字、下划线,数字不能开头
2. 大小写敏感
3. 不能使用关键字做标识符
4. 驼峰标识 - 第一个单词全小写以后每个单词首字母大写
5. 见名知意
2.终止符
关键字 terminator --打印完成后如有其它打印文字不会换行,继续打印。print打印函数默认打印完成后自动换行
print("Hello, World", terminator: "")
3.字符串插值
关键字 (成员变量) 将成员变量值插入字符串中
let a = 10, b = 10
print("\(a) + \(b) = \(a + b)")
//成员变量作除法时的一些特殊情况
let x = 5
let y = 0
print(x / y) // 运行时异常
// 整数除以0产生运行时异常
// 小数除以0可能的结果是inf/-inf/nan
// inf - infinity(无穷大)
// nan - not a number(不是一个数)
4.转义字符
转义字符一般全面都会带一个/。
/n 代表换行符
/t 代表制表符
//print("Hello, World!", terminator: "\n")
//print("大家好", terminator: "\t")
//print("我是制表符")
二.变量和常量
常量关键字 let
变量关键字 var
Swift具有根据你的数据来判断类型进行保存的特点(类型推断)
let m = 10 //不可变的整型变量
var n = 10 //可变整型变量
let m = true //不可变的Bool值
var n = true //可变Boll值的变量
let m = 5.2 // double - 不可变
var n = 5.2 // double - 可变
let m = "Hello World" // String - 不可变
var n = "Hello World" // String - 可变
正常情况下表示整数首选Int, 表示小数首选Double
表示字符串首选String, 表示真假首选Bool
元组(tuples)用一个变量或一个常量保存多项数据信息的的类型
//方式1
let stu = (1001, "学生1", true, 23)//定义元组
let number = stu.0 // 取出元组中学号
//方式2
let stu : (id: Int, name: String, gender: Bool, age: Int) = (1001, "学生1", true, 23)//定义元组
let name = stu.name // 取出元组中的名字
// 用元组交换两个变量的值
var x = 5, y = 10
(x, y) = (y, x)
print(x)
print(y)
三.运算符
运算符（运算符两边的变量或常量类型必须一致才能做运算）
- 算术运算符: + - * / %
- 关系运算符: == != > >= < <=
- 短路运算符: && ||
//
//算术运算符
var str1 = "Hello"
var str2 = "world"
str1 = str1 + " " + str2 //字符串拼接
print(str1)
//关系运算符
print(str1 > str2)//是一个Bool
//查看字符串的大小 - utf16
var str5 = "王大锤"
for temp in str5.utf16 {//str5.utf16 - 查看字符串大小
print(temp)
}
var str6 = ""
for temp in str6.utf16 {
print(temp)
}
print(str5 < str6)
let year = 2000
let c1 = year % 4 == 0 // 四年一闰
let c2 = year % 100 != 0 // 百年不闰
let c3 = year % 400 == 0 // 四百年又闰
//短路运算符
// && - 短路与运算(而且)
// || - 短路或运算(或者)
if (c1 && c2) || c3 {
print("\(year)年是闰年")
}
else {
print("\(year)年不是闰年")
}
三元运算符
let msg = username == "admin" && password == "123456" ? "登录成功!!!" : "非法用户!!!"
//提醒: 三元条件运算的?前面一定要加空格!!!
四.分支结构
1.if语句控制的分支结构
格式
if true {
}
else if ture {
}
else{
}
//优先执行true， 如果Bool值为假就往下继续判断，直到else都为假执行else语句
2.switch语句控制的分支结构
格式
switch(num) //num为一个变量用作于判断
{
//case的值与变量的值做判断,如果想等执行.case的值可以为一个范围
case 0：
print(num) //如果num等于0，执行
case 1:
print(num)
case 2..<5 :
print(num) //如果num的值在大于等于2且小于5的时候,执行
default：
print("最后执行") //如果前面分支都没有执行,最后会执行default
}
五.循环结构
1.for in 循环
该循环可以带变量也可不带变量,如果有变量类型只能为Int,每循环一次变量+=1.
in后面是变量范围 1...5,代表该变量的值是从1增加到5，循环5次. 1..<5,代表该变量值从1到4(不包括5),循环4次。循环的次数是由in后面的范围决定的
for _ in 0...5 {
print("代码执行6次循环，没有变量")
}
for i in 0..<5 {
print(i) // i - 0 ~ 4
}
2.while循环
当while后面的值为true时代码会进入循环,如果为false结束循环。
var i = 1
var judge = true
while judge {
if i = 10 {
judge = false
}
i += 1
print（"循环在继续"）
}
//当i = 10时, judge为false.等到下次执行到while时,不会执行循环内的语句.循环终止
3.repeat while 循环
repeat while 循环与while循环的最大区别是,他的判断条件是写在循环最后面的,意思就是说每次循环结束后进行判断,如果条件为true,继续循环.反之,结束循环,执行后面的代码.当第一次进入循环时,不论条件真假都会至少执行一次循环内的代码
var judge = false
repeat { //至少执行一次循环
print("正在循环内")
}while judge //该代码会执行一次打印语句
var judge1 = true
var num = 1
repeat { //先执行,后判断
num += 1
if num == 10 {
print("我已经循环了10次啦")
judge1 = false
}
}while judge1
六.数组
1.swift的数组有多种定义方法
var numArray :[Int] = [] // 创建一个可变空数组
var numArray = [Int]() //创建一个可变空数组
var numArray = [4, 6, 3, 7] //类型判段,你传入的数组是什么类型数组num就为什么类型
var numArray = [Int](count: 10, repeatedValue: 0)) //创建一个可变整型数组,数组元素为10个,每个元素的初始值都为0.
2.获取数组元素个数
方法为count
var numArray = [1, 2, 3, 4, 5]
let number = numArray.count
3.遍历数组
1.直接遍历(遍历出来的值为只读属性,不能修改数组元素的值)
var numArray = [1, 2, 3, 4]
for num in numArray {
print(num) //每次遍历的num是从数组中按顺序依次遍历出来的.
}
2.利用元素下标进行遍历
var numArray = [1, 2, 3, 4, 5]
for index in 0..<numArray.count {
print(numArray[index]) // index代表数组元素编号,利用编号能够拿到数组中每个元素的值
}
3.取到下标及元素值遍历
var numArray = [1, 2, 3, 4, 5]
for (index, value) in numArray.enumerate() {
print("\(index + 1). value") // index代表元素下标,value代表数组中该下标对应的值
}
4.增加数组中的元素
方法名append， insert
var numArray = [1, 2, 3, 4, 5]
numArray.append(3) // 默认将数字3添加到数组中最后一个元素
numArray.insert(2, atIndex:0) // 通过下标控制,可以使添加的元素添加到任意位置
并且swift数组还可以利用+=运算符进行添加元素
var numArray = [1, 2, 3, 4, 5]
numArray += [2] //默认也是加到数组中最后一个元素
5.删除元素
方法名remove
var numArray = [1, 2, 3, 4, 5]
numArray.removeAll(keepCapacity:Bool) //删除数组中所以元素如果Bool值是true,不会删除其空间
numArray.removeFirst(n:Int) //删除前面n个元素
numArray.removeRange //删除范围,需传入一个范围
6.数组的复制
var numArray = [1, 2, 3, 4, 5]
let numArray1 = numArray //全部复制
var numArray2 = numArray[0..3] //辅助一部分
7.数组做加法
var numArray = [1, 2, 3, 4, 5]
let numArray1 = [1, 2]
let numArray2 = numArray + numArray1
8.数组排序
方法名sort
var numArray = [1, 2, 3, 4, 5]
let numArray1 = numArray.sort() //返回一个新的数组且已经排好序,默认为升序
numArray.sortInPlace() //在原有数组上进行排序
9.冒泡法,简单排序法
1.冒泡法
主要思想是每次进行相邻元素之间的比较,将较大的数交换到右边.单次循环结束后,最大的数被移到右边去.依次循环,达到排序的目的
var numArray = [9, 8, 7, 6, 5, 4, 3, 2, 1]
for i in 1..<numArray.count {
for j in 0..<numArray.count - i {
if numArray[j] > numArray[j + 1]{
(numArray[j], numArray[j + 1]) = (numArray[j + 1], numArray[j]) //交换元素
}
}
}
冒泡法可进行优化
var numArray = [9, 8, 7, 6, 5, 4, 3, 2, 1]
for i in 1..<numArray.count {
var judge = false
for j in 0..<numArray.count - i {
if numArray[j] > numArray[j + 1]{
(numArray[j], numArray[j + 1]) = (numArray[j + 1], numArray[j])
judge = true
}
}
if !judge { //当judge为false的时候,表示一次排序都没有进行.意味着该数组的顺序已经排好,不需要再进行排序
break
}
}
2.简易选择排序
主要思想是每次选出最小的元素,记录其下标,将最小的依次与最前面的元素调换
var numArray = [9, 8, 7, 6, 5, 4, 3, 2, 1]
for i in 0..<numArray.count - 1 {
var index = i //记录最小数下标,用于交换
for j in i + 1..<numArray.count {
if numArray[index] > numArray[j]{
index = j //刷新下标
}
}
(numArray[index], numArray[i]) = (numArray[i], numArray[index]) //交换元素
}
10.数组三大实用方法(闭包)
1.过滤
let array = [23, 37, 96, 55, 40, 92, 68, 88]
let newArray = array.filter{ (a: Int) -> Bool in
return a > 50 // 过滤掉小于50的数字
}
let newArray1 = array.filter{a in a > 50} // 省略掉括号,return，参数类型
let newArray2 = array.filter{$0 > 50} //省略参数
2.映射
let array = [23, 37, 96, 55, 40, 92, 68, 88]
let newArray = array.map{$0 * $0}
3.缩减
let array = [23, 37, 96, 55, 40, 92, 68, 88]
let newArray = array.reduce(0, combine: +) //合并所以值,求和。0为初始值
let newArray = array.reduce(array[0]){$0 > $1 ? $0 : $1} // 输出最大项,初始值为array[0]
