Swift
为什么要学习Swift
我是地理信息科学（Geography Information Science，简称GIS）专业出身的人，在大学期间主要学习的是应用计算机技术对地理信息进行处理、存储、提取以及管理和分析的相关知识。而我的学校开设的这个专业主要和测绘方面结合得更加紧密，因此大部分对学习都与测绘分不开，我们虽然也学习计算机编程语言，但是由于这些原因，从事开发方面的人并不多，也是近些年随着技术的发展，才开始又越来越多的同学开始往计算机开发方面发展。而我对开发也很感兴趣，于是便想学习一门好用的，新颖的编程语言，在这个时候，我关注到了Swift，于是我便开始了Swift语言的学习。
在我开始选择学习Swift语言之前，我学过C＃语言基础，有过那么一点点的基础，但是只能写得出一些简短的语句。也用过C＃语言进行过一些简单的开发，比如我们专业的基于GIS的二次开发，也学习过静态网页的制作，用的是html（不是html5）和css，以及空间数据库等等，看起来就有点乱，当然学起来也是相当恼火。最后我选择Swift，也是因为听说这个语言是一款易学易用的编程语言。
变量和常量
Swift 变量
变量是一种使用方便的占位符，用于引用计算机内存地址
Swift每个变量都指定了特定的类型，该类型决定了变量占用内存的大小，不同的数据类型也决定可存储值的范围。
变量声明
变量的关键字：var
var varA:Int = 1
var varB = "Hello,world!"
变量的命名规则
1.变量名可以由字母，数字和下划线组成。
2.变量名需要以字母或下划线开始。
3.Swift 是一个严格区分大小写的语言，所以字母大写与小写是不一样的。
4.变量名也可以使用简单的 Unicode 字符
如：
var red, green, blue: Double
var 你好 ＝ "Hello,world!"
var π = 3.14159265358979
常量
常量使用关键字：let
常量可以是任何的数据类型如：整型常量，浮点型常量，字符常量或字符串常量。同样也有枚举类型的常量：
常量类似于变量，区别在于常量的值一旦设定就不能改变，而变量的值可以随意更改。
运算符
运算符是一个符号，用于告诉编译器执行一个数学或逻辑运算。
Swift 提供了以下几种运算符：
1.算术运算符
2.比较运算符
3.逻辑运算符
4.位运算符
5.赋值运算符
6.区间运算符
7.其他运算符
算术运算符
+(加) -(减) *(乘) /(除) %(求余)
关系运算符
== != > < >= <=
短路运算符
&&(与) ||(或) !(非)
分支结构
分支结构中通过设定的一个或多个条件来执行程序，在条件为 true 时执行指定的语句，在条件为 false 时执行另外指定的语句。
if else语句
//输入月薪和五险一金判断个人月收入
print("请输入您的月薪s = ",terminator:"")
print("请输入您每个月需要交的五险一金f = ",terminator:"")
let diff = s - f - 3500
if diff <= 0 {
money(0, deduction: 0)
}
else if diff <= 1500 {
money(0.03, deduction: 0)
}
else if diff <= 4500 {
money(0.1, deduction: 105)
}
else if diff <= 9000 {
money(0.2, deduction: 555)
}
else if diff <= 35000 {
money(0.25, deduction: 1005)
}
else if diff <= 55000 {
money(0.3, deduction: 2755)
}
else if diff <= 80000 {
money(0.35, deduction: 5555)
}
else {
money(0.45, deduction: 13505)
}
}
func money(rate:Double,deduction:Double) {
let salary = salaryField.text!
let fund = insurance.text!
let s = Double(salary)!
let f = Double(fund)!
let diff = s - f - 3500
let tax = diff * rate - deduction
print("个人所得税为：¥\(tax)")
print("实际到手收入：¥\(s - f - tax)")
}
三元运算符 ？：
//三元条件运算的?前面一定要加空格!!!
let msg = name == "admin" && password == "123456" ? "登陆成功！" : "登陆失败！"
// var msg:String
// if name == "admin" && password == "123456" {
//
// msg = "登陆成功！"
// }
// else if name == "" || password == "" {
// msg = "请输入用户名或密码！"
// }
// else{
// msg = "登陆失败！"
// }
switch case语句
// 猜拳：
var humanWin = 0 , computerWin = 0
repeat {
var computer = Int(arc4random_uniform(3)) + 1
var human:Int
repeat {
print("(1 = 👙,2 = ✂️,3 = 👊)请出拳：",terminator:"")
human = inputInt()
}while human < 1 || human > 3
switch computer {
case 1:
print("计算机出了👙")
switch human {
case 1:
print("你出了👙")
print("平局，别走，再来一把！")
case 2:
print("你出了✂️")
print("你赢了！")
humanWin += 1
case 3:
print("你出了👊")
print("你输了！")
computerWin += 1
default:
break
}
case 2:
print("计算机出了✂️")
switch human {
case 1:
print("你出了👙")
print("你输了！")
computerWin += 1
case 2:
print("你出了✂️")
print("平局，别走，再来一把！")
case 3:
print("你出了👊")
print("你赢了！")
humanWin += 1
default:
break
}
case 3 :
print("计算机出了👊")
switch human {
case 1:
print("你出了👙")
print("你赢了")
humanWin += 1
case 2:
print("你出了✂️")
print("你输了！")
computerWin += 1
case 3:
print("你出了👊")
print("平局，别走，再来一把！")
default:
break
}
default:
break
}
}while computerWin < 3 && humanWin < 3
if humanWin == 3 {
print("恭喜您战胜了计算机！")
}
else {
print("败！")
}
循环结构
循环语句允许我们多次执行一个语句或语句组。
有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。所以，在多次执行同一块代码的时候我们就需要用到循环语句了。
Swift的循环结构主要有：for..in循环、repeat..while循环和while循环。
for..in循环和穷举法
for in循环：遍历一个集合里面的所有元素，例如由数字表示的区间、数组中的元素、字符串中的字符。
比如：要花100元买100只鸡，假设公鸡5块钱一只，母鸡3块钱一只，小鸡一块钱3只，要用100块钱买100只鸡，要怎么买？
我们通常会列出两个方程：（设需要买的公鸡为x只，母鸡为y只，小鸡为z只）：
那么--> 100 = x + y + z
100 = 5x + 3y + z/3
从方程组中可以看出，两个方程有3个未知数，解出的答案就不只一组，这时候，我们就可以使用穷举法（穷尽所有的可能性直到找到所有的正确答案）。
for x in 0...20 { //假设全买公鸡，最多只能买20只
for y in 0...33{ //假设全买母鸡，最多只能买33只
let z = 100 - x - y
if 5 * x + 3 * y + z / 3 == 100 && z % 3 == 0 {
print("🐓：\(x) ,🐔：\(y) ,🐤\(z) ")
}
}
}
程序运行结果
while循环
运行一系列语句，如果条件为true，会重复运行，直到条件变为false
下面时一个例子，也用到来穷举法：五个人某一天一起抓鱼，扔到筐子里没有计数，太黑了，五个人就地过夜，第二天，第一个人先起来就把鱼平均分成了5份并拿走了自己的那一份先走了，第二个人起来以为他是第一个起来的，又把鱼分成了5份并拿走了自己的那一份，第三个人、第四个人直到第五个人都是这么做的，问：至少有多少条鱼？（个人感觉题目有点傻）
var fishTotal = 1
while true {
// 用当次循环时fishtotal的值作为鱼的总数
var fishSum = fishTotal
// 假设鱼的数量足够5个人分
var isEnough = true
// 通过循环模拟五个人分鱼的过程
for _ in 1...5 {
//检查剩下的鱼是否够分
if (fishSum - 1) % 5 == 0 {
fishSum = (fishSum - 1) / 5 * 4
}
else {
//如果鱼不够分就将isenough赋值为false并提前结束分鱼的循环
isEnough = false
break
}
}
//当鱼够分的时候跳出循环
if isEnough {
print(fishTotal)
break
}
fishTotal += 1
}
repeat..while循环
类似 while 语句区别在于判断循环条件之前，先执行一次循环的代码块。
以下是一个赌博游戏：Craps
游戏规则如下：玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜，如果点数和为2、3或12，则玩家输，如果和 为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点数和，则玩家胜，如果在这之前掷出了点数和为7，则玩家输。
//生成1到6到随机数的函数用来充当骰子的点数
func roll() -> Int {
return Int(arc4random_uniform(6)) + 1
}
//游戏初始金钱：1000
var money = 1000
repeat {
//每局游戏开始前显示玩家总资产
print("玩家总资产：¥\(money)")
//设置下注金额为debt
var debt:Int
repeat {
print("请下注：",terminator:"")
debt = inputInt()
}while debt <= 0 || debt > money
//设置一个bool型的变量，当一方获胜之后用于跳出循环
var needsGoOn = false
let firstPoint = roll() + roll()
print("玩家摇出了\(firstPoint)点")
switch firstPoint {
case 7,11:
print("玩家胜")
money += debt
case 2,3,12:
print("庄家胜")
money -= debt
default:
needsGoOn = true //游戏继续
}
while needsGoOn {
let currentPoint = roll() + roll()
print("玩家摇出了\(currentPoint)点")
if currentPoint == 7 {
print("庄家胜")
money -= debt
needsGoOn = false
}
else if currentPoint == firstPoint {
print("玩家胜")
money += debt
needsGoOn = false
}
}
}while money > 0
print("玩家破产！")
数组
Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
Swift 数组会强制检测元素的类型，如果类型不同则会报错。
如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可更改，并且数组的大小和内容都不可以修改。
//1.创建数组
var array1 = [Int]()
var array2 : [Int] = []
var array3 = [99,12,3,24,134]
var array11 = [99,12,3,24,134]
var array4 = [Int](count :100,repeatedValue: 1)
var array5 = [String]()
var array6 : [String] = []
var array7 = ["aefw","weew","wewef","weewf"]
var array8 = [String](count : 100,repeatedValue:"abc")
array7[1...3] = ["egg","water","tomato"]
print(array7)
//对数组进行索引(给每个元素标一个下标)
for (index, value) in array7.enumerate() {
print("\(index + 1).\(value)")
}
//2.获取数组元素的个数
print(array5.count)
print(array6.count)
print(array7.count)
print(array8.count)
//3.对数组中的元素进行遍历
for index in 0..<array7.count {
//[]是对数组进行下标运算（取出指定位置的元素）
print(array7[index])
if index == 1 {
array7[index] = "apple"
}
}
print(array7)
//只读循环（在循环过程中不能修改数组元素）
for str in array3 {
print(str)
}
//4.向数组中添加元素
array5 += ["strawberry"]
array5.append("pear")
array5.insert("waxberry", atIndex: 0)
array5.insert("watermelon", atIndex: 2)
array5.insert("lemon", atIndex: array5.count)
print(array5)
//5.从数组中删除元素
array5.removeAtIndex(3)
print(array5)
array5.removeFirst()
print(array5)
//array5.removeAll()
//print(array5)
//数组的复制
var array9 = array5
array9[1] = "elephant"
print(array5)
print(array9)
var array10 = array5[0...1]
print(array5)
print(array10)
//数组之间的加法
let array12 = array3 + array11
print(array12)
下面是几个数组的实例：可以计算投掷一颗骰子每个面出现的次数
func roll() -> Int {
return Int(arc4random_uniform(6)) + 1
}
//定义一个放整数的数组（6个元素，初始值都是0）
var f = [Int](count: 6,repeatedValue: 0)
for _ in 1...600000 {
let face = roll()
f[face - 1] += 1
}
for i in 0..<f.count {
print("\(i + 1)点摇出了\(f[i])次")
}
程序运行结果
翡波拉切数列：
//翡波拉切数列
var fibArray = [Int](count:20,repeatedValue:0)
//var fibArray = Array<Int>(count:20,repeatedValue:0)
fibArray[0] = 1
fibArray[1] = 1
for i in 2..<fibArray.count {
fibArray[i] = fibArray[i - 1] + fibArray[i - 2]
}
// 只取值
//for value in fibArray {
// print(value)
//}
// 取值 ＋ 下标
for (index,value) in fibArray.enumerate() {
print("\(index + 1).\(value)")
}
约瑟夫环的变种：
将30个人排成一排，这30个人中有15个基督教徒和非基督教徒，从1开始报数，报到第9的就杀掉，然后接着从1开始报数到9又杀掉，直到最后只剩15个人，这15个人恰好是基督教徒，据说是上帝的保佑，请问：他们是怎么站的位置？
// 约瑟夫环的变种：
var humanArray = [Bool](count:30,repeatedValue:true)
var counter = 0 // 死人的数量
var num = 0 // 报数的数字
var index = 0 // 数组的下标
while counter < 15 {
// 报数 ＋ 杀人
if humanArray[index] {
num += 1
if num == 9 {
humanArray[index] = false
counter += 1
num = 0
}
}
index += 1
index %= humanArray.count
// if index == humanArray.count {
// index = 0
// }
}
for human in humanArray {
print(human ? "是" : "否" ,terminator:"")
}
程序运行结果
将学生成绩录入数组并求平均分、最高分、最低分
var namesArray = ["张三","李四","王二","何五","赵六"]
var scoresArray = [Double](count:5,repeatedValue:0.0)
for (i,name) in namesArray.enumerate() {
print("请输入\(name)的成绩：",terminator:"")
scoresArray[i] = inputDouble()
}
var sum = 0.0
var max = scoresArray[0]
var maxIndex = 0
var min = scoresArray[0]
var minIndex = 0
for (index,score) in scoresArray[0..<scoresArray.count].enumerate() {
sum += score
if score > max {
max = score
maxIndex = index
}
if score < min {
min = score
minIndex = index
}
}
print("平均分：\(sum / Double(scoresArray.count))")
print("\(namesArray[maxIndex])🉐最高分：\(max)")
print("\(namesArray[minIndex])🉐最低分：\(min)")
排序
Swift的排序比较简单，因为Swift本身就自带了了排序的方法
如：
var array = [29,96,33,685,56,654,46,4684,2542]
let newArray = array.sort(>)
print(array)
print(newArray)
array.sortInPlace()
print(array)
var array1 = ["acew","ewf","ggg","heihei","abc","yuo","didi","papi"]
let array2 = array1.sort()
print(array2)
//这是Mac OS 系统附带的表情，对于表情包子排序只是顺手试试，也有点不太懂，可能是按照它们在包子库里的序号排的
var array3 = ["🚜","🚲","🚚","🚈","🚃","🚁"]
let array4 = array3.sort()
print(array4)
//上面是复制数组进行排序，下面是数组本身排序
var array1 = [15,20,81,55,33,45,12,1,6,98,57,84,37]
array1.sortInPlace()
print(array1)
程序运行结果
Swift也可以自己写相关代码进行排序：
比如：简单选择排序和冒泡排序
//简单选择排序：每次从剩下元素中找最小的元素放到对应的位置
var array = [29,96,33,685,1,654,46,4684,2542,5,444,33,52,16,13,1315,46,8489,48]
for i in 0..<array.count - 1 {
var minIndex = i
for j in i + 1..<array.count {
if array[j] < array[minIndex] {
minIndex = j
}
}
(array[i],array[minIndex]) = (array[minIndex],array[i])
}
print(array)
// 冒泡排序：两两比较，前面的元素比后面的元素大酒交换位置
var array = [29,96,33,685,1,654,46,4684,2542,5,444,33,52,16,13,1315,46,8489,48]
for i in 0..<array.count - 1 {
var swapped = false
for j in 0..<array.count - 1 - i {
if array[j] > array[j + 1] {
(array[j],array[j + 1]) = (array[j + 1],array[j])
swapped = true
}
}
//优化
if !swapped {
break
}
}
print(array)
程序运行结果
总结
学习的时间总是过得很快，不知不觉一个星期就过去了，在这个星期我学习了很多，收获了很多。
在这一周的时间里我充分体验到了学习的快乐，最开始其实也觉得挺好学的，但是有的时候也有点恼火，
比如循环有的时候能够很快的写出来，有的时候想半天也没有头绪。
感觉还是代码写得太少，练习得太少了，在接下来的时间里，我会一直努力练习，争取早日出世。
网友评论