Swift基础
swift:（颜色标记：蓝色——紫色—褐色 红色标记重点，黑色正常输入）
笔记正文：
2010年7月开始设计，2014年wwdc(苹果开发者大会)上发布，译为：“雨燕”，可以跟object-c一样，用于开发iOS，Mac应用程序。
特点：
从中可以看到Objective-C，JavaScript，C#，Python等语言的影子；
借鉴了上面这些语言的优点；
同时具备编译型语言的高性能和脚本语言的灵活交互性；
可以轻松地与Objective-C、C混合使用（相互调用）。
开发的目的：取代Objective-C；让应用开发更简单、更高效、更稳定。
相关数据：
使用Swift语言开发的条件是什么：
Xcode版本>=6.0;
Mac版本>=10.9.3
Swift自从发布之后，备受开发者关注，发布当天(1天的时间内)
Xcode 6 beta下载量突破1400万次；
官方发布的电子书《The Swift Prongramming Language》下载量突破37万次；
一个国外开发者使用Swift实现了Flappy Bird游戏(这位开发者上手Swift的时间只有4个小时，编程加上休息时间，接近9个小时)。
相关人物：Chris Lattner
Swift的首席架构师；LLVM项目的主要发起人与作者之一；Clang编译器的作者；苹果[开发工具]部门的主管；领导Xcode、Instruments和编译器团队；2010年7月开始住到开发Swift编程语言；Swift的大部分基础架构均由他1人完成。 ————大神中的大神
性能：
官方给出的是性能非常好，但是对此表示怀疑？？？
忠告：
目前的性能不是卡开发者最需要担心的问题；
苹果已经全盘掌握了这个语言的方方面面：从底层编译框架再到语言设计；
优化之路才刚刚开始，作为开发者，需要给这门新语言一点点耐心和信心
Swift和Objective-C代码格式对比
添加一个按钮为例：
Objective-C
1.UIButton *btn = [[UIButton alloc] init];
2.btn.frame = CGRectMake (20,20,20,20);
3.btn.backgoundColor = [UIColor blueColor];
4.[self.view addSubview:btn];
Swift:
1.var btn = UIButton()
2.btn.frame = CGRectMake (20,20,20,20)
3.btn.backgoundColor = UIColor.blueColor()
4.self.view addSubview(btn)
使用，学习Swift：
从学习Swift的语言角度看：
Swift是一门新语言，语法难度对每个程序员都差不多；
从使用Swift开发iOS程序的角度看：
使用Object-C的老牌iOS程序员更占优势；
因为从Object-C转为Swift去开发iOS程序，仅仅是书写的格式变换了，iOS开发的步骤、思想、框架都没有改变。
一、Swift变量和常量<语法须知>
Swift的源文件扩展名是.swift
2个不需要：
不需要编写main函数(默认从上往下按顺序执行，所以最前面的代码会被自动当作程序的入口)；
不需要在每一条雨具后面加上分号(喜欢的话加上也是可以的；有一种情况必须加分号：同一行代码上有多条语句时)；
注释：
单行注释：// 单行注释
多行注释：/* 多行注释 */
注：多行注释可以嵌套多行注释 (C和OC中这样是会报错的)：
/* 外层注释
/* 内层注释
多行注释 */
外层注释 */
常量和变量
如何声明常量和变量：
用let来声明常量：let radius = 10
用var来声明变量：1.var age = 20 2.var x = 0.0,y = 0.0,z = 0.0
PlayGroud的使用：
Xcode自带的一个工具，可以在屏幕右边框内直接看到左边代码的执行结果,点后边的加号可以在下边更加直观的显示，UI也可以。(练习的时候可以使用，还是挺好的)。
字符串：
字符串是String类型的数据，用双引号“”包住文字内容
let website = "http://ios.itcast.cn”
字符串的常见操作：
用加号+做字符串拼接
1.let scheme = “http://“
2.let path = “iOS.itcast.cn”
3.let website = scheme + path //website的内容是： "http://ios.itcast.cn”
用反斜线\和小括号()做字符串插值(把常量\变量插入到字符串中)
1.let hand = 2
2.var age = 20
3.let str = “我今年\(age)岁了,有\(hand)只手” //str的内容是：“我今年20岁了，有2只手”。
整数转成字符串：var str = String(age);var str2 = “\(age)”；这两种方法都可以。
打印输出：Swift提供了2个打印输出函数
println：输出内容后会自动换行；
print：对比println，少了个自动换行的功能；
常量和变量的命名：
基本上可以用任何你喜欢的字符来作为常量和变量名
1.let 网址 ＝ “http://ios.itcast.cn”
2.let 🐶🐮 = “小狗和母牛”
🐶和🐮是emoji表情，是一种特殊的Unicode字符；
可以在Mac上通过快捷键：control + command + 空格，弹出emoji键盘；
常量和变量名的注意点：
不能包含数学符号（比如 +、-、*、\）;
不能包含箭头（比如←、→、↑、↓）
不能包含非法无效的Unicode字符(比如⚽️)
不能是关键字(比如let、var)
不能以数字开头(比如123go)
不能是单独一个下划线_ （比如var _ = 10）
数据类型：
Swift中常用的数据类型有：
Int Float Double Bool Character String
Array Dictionary 元组类型(Tuple) 可选类型(Optinal)
可以看出：数据类型的首字母都是大写的
如何指定变量\常量的数据类型
在常量\变量名后面加上 冒号（：）和类型名称
let age: Int = 10
上面代码表示：定义了一个Int类型的常量age，初始值是10
一般来说，没有必要明确指定变量\常量的类型
如果在声明常量\变量时赋了初始值，Swift可以自动推断出这个常量\变量的类型
let age = 20
//Swift会推断出age是Int类型，因为20是个整数
变量的初始化：
Swift严格要求变量在使用之前必须进行初始化
下面代码是错误的
1.var a: Int
2.let c = a + 10
解析：1>第1行代码中：Swift并不会为变量a赋初值，a没有初始化
2>第2行代码会报错
下面代码是正确的
1.var a: Int ＝ 20
2.let c = a + 10
整数：
整数分为2种类型：
有符号(signed)：正、负、零
无符号(unsigned)：正、零
Swift提供了8、16、32、64位的有符号和无符号整数，比如
UInt8：8位无符号整型
Int32：32位有符号整型
Int8、Int16、Int32、Int64、
UInt8、UInt16、UInt32、UInt64
最值：
可以通过min和max属性来获取某个类型的最小值和最大值
1.let minValue = UInt8.min 最小值等于0
2.let maxValue = UInt8.max 最大者等于255
Int和UInt
Swift还提供了特殊的有符号整数类型Int和无符号整数类型UInt
Int\UInt的长度和当前系统平台一样
>在32位系统平台上，Int和UInt的长度是32位
>在64位系统平台上，Int和UInt的长度是64位
Int在32位系统平台的取值范围：-214783648～214783647
建议：
在定义变量时，别总是在考虑有无符号、数据长度的问题
尽量使用Int，这样可以保证代码的简介、可复用性。
存储范围：
每种数据类型都有泽子的存储范围，比如：
Int8的存储范围是：-128～127
UInt8的存储范围是：0～255
如果数值超过了存储范围，编译器会直接报错
下面的语句都会直接报错
1.let num1: UInt8 = -1
2.let num2: Int8 = Int8.max + 1
第1行代码报错原因：UInt8不能存储负数
第2行代码报错原因：Int8能存储的最大值是Int8.max
整数的表示形式：
十进制数：没有前缀
let i1 = 10 //10
二进制数：以0b为前缀
let i2 = 0b1010 //10
八进制数：以0o为前缀
let i3 = 0o12 //10
十六进制数：以0x为前缀
let i4 = 0xA //10
浮点数：
浮点数，就是小数。
Swift提供了两种浮点数类型
Double：64位浮点数，当浮点值非常大或需要非常精确时使用此类型
Float：32位浮点数，当浮点值不需要使用Double的时候使用此类型
精确程度
Double：至少15位小数
Float：至少6位小数
如果没有明确说明类型，浮点数默认就是Double类型
let num ＝ 0.14 //num是Double类型的常量
浮点数的表示形式
浮点数可以使用十进制和十六进制2中进制来表示
十进制(没有前缀)
没有指数：let d1 = 12.5
有指数：let d2 = 0.125e2
//0.125e2 =＝ 0.125 * 10² MeN ==M * 10的N次方
十六进制(以0x为前缀，且一定要有指数)
let d3 = 0xC.8p0
//0xC.8p0 == 0xC.8 * 2º == 12.5 * 1 0xMpN ＝＝ 0xM * 2的N次方
let d3 = 0xC.8p1
//0xC.8p1 == 0xC.8 * 2^1== 12.5 * 2 =＝ 25.0
数字格式：
数字可以增加额外的格式，使它们更容易阅读
可以增加额外的零 0
1.let money ＝ 0019999 //1999
2.let money2 = 001999.000 //1999.0
可以增加额外的下划线_,以增加可读性
1.let oneMillion1 = 1_000_000 //1000000
2.let oneMillion2 = 100_0000 //1000000
3.let overOneMillion = 1_000_000.000_001 //1000000.000001
增加了额外的零 0和下划线_，并不会影响原来的数值大小。
类型转换
两个类型不相同的数值，是不能直接进行运算的
下面的语句是错误的
1.let num1:UInt8 = 10
2.let num2:Int = 20
3.let sum :Int = num1 + num2（×） 改正：let sum :Int = Int（num1） + num2（√）
第3行会报错
报错原因：num1是UInt8类型，num2是类型Int，类型不同，不能相加
解决方案：将num1转为Int类型，就能与num2进行相加
下面的语句是错误的
1.let num1 = 3
2.let num2 = 0.14
3.let sum = num1 + num2（×） 改正：let sum = Double（num1） + num2（√）
第3行会报错
报错原因：num1是Int类型，num2是类型Double，类型不同，不能相加
解决方案：将num1转为Double类型，就能与num2进行相加
注意：下面的写法是正确的
let sum ＝ 3 + 0.14
➹ 3和0.14相加得到结果3.14，等赋值以后，编译器才会自动推断出sum是Double类型
类型别名
可以使用typealias关键字定义类型的别名，跟C语言的typedef作用类似
typealias MyInt ＝ Int //给Int类型起了个别名叫做MyInt
原类型名称能用在什么地方，别名就能用在什么地方
声明变量\常量类型
let num：MyInt ＝ 20
获得类型的最值
let minValue ＝ MyInt.min
类型转换
let num ＝ MyInt（3.14） //3
运算符：
Swift所支持的部分运算符有：
赋值运算符：＝
复合赋值运算符：+＝、—＝
算数运算符：+、—、*、/
求余运算符：%
自增、自减运算符：++、— —
比较运算符：＝＝、！＝、>、<、>=、<＝
逻辑运算符：&&、||、！
三目运算符：？：
范围运算符：..<、...
溢出运算符：&+、&—、&*、&/、&%
赋值运算符：
1对1赋值
var a ＝ 5
N对N赋值
let （x，y）＝｛1，2｝ //x的值是1，y的值是2，并且都是常量
跟C\OC不一样的是：Swift的赋值运算符没有返回值
if（x，y）｛｝ //左边的代码是错误的，因为x＝y并没有反悔具体的值
注：这样的好处是防止误用＝和＝＝
求余运算符：
%在Swift中叫“求余运算符”，也有语言叫做“模运算符”
9 % 4 //1
-9 % 4 //-1
9 % -4 //1
-9 %- 4 //-1
注：求余结果的正负跟%左边数值的正负一样
跟C语言不一样的是，Swift的%支持浮点数的计算
8 % 2.5 //0.5
BOOL
Bool类型，也被称为逻辑类型(Logical),就2种取值
true：真
false：假
在C语言中：0是假，非0就是真；而在Swift中没有这种概念
if语句的条件必须是Bool类型的值
错误写法
if （10）｛
println（“条件成立”）
｝
正确写法：
if（true）｛
println（“条件成立”）
｝
比较运算符\逻辑运算符\三目运算符
比较运算符\逻辑运算符会返回Bool类型的值，取值有2中可能
true：真，6 > 5,(7 > 6) && (9 != 7)
false：假，6 < 5,(7 >= 6) && (9 == 7)
三目运算符的条件必须是Bool类型的值
错误写法：
let a ＝ 10
let c ＝ a ？ 100 ： 200
正确写法：
let c = a != 0 ? 100 : 200
let c = false ? 100 : 200
范围运算符：
范围运算符用来表示一个范围，有2中类型的范围运算符
闭合范围运算符：a...b,表示[a,b],包含a和b
半闭合范围运算符：a..<b,表示[a,b),包含a，不包含b
举例：
for index in 1…5{
println(index)
} //index的值从1～5
for index in 1..<5{
println(index)
} //index的值从1～4
溢出运算符
每种数据类型都有自己的取值范围，默认情况下，一旦赋了一个超出取值范围的数值，会产生编译或者运行时错误
下面的写法是错误的
1.let x ＝ UInt8.max
2.let y ＝ x + 1
第2行代码会在运行时报错
Swift为整型计算提供了5个&开头的一出运算符，能对超出取值范围的数值进行灵活处理。
值的上溢出
1.let x ＝ Uint8.max
2.let y ＝ x &+ 1
第1行代码过后：x 的值是255(最大值)
第2行大妈过后：y 的值是0(最小值)
如下图分析：
值的下溢出：
1.let x ＝ Uint8.min
2.let y ＝ x &- 1
第1行代码过后：x 的值是0(最小值)
第2行代码过后：y 的值是255(最大值)
有符号整数也有类似的溢出现象:
1.let x ＝ Int8.min
2.let y ＝ x &- 1
第1行代码过后：x 的值是-128(最小值)
第2行代码过后：y 的值是127(最大值)
除零溢出
默认情况下，一个数除以0，或者对0求余数，编译器会直接报错
1.let x ＝ 10
2.let y ＝ x / 0
3.let z = x % 0
第2、3行代码：编译器都会报错
如果使用溢出运算符，就不会报错
1.let x = 10
2.let y = x &/ 0
3.let z = x &% 0
y和z的值最终都是0
Swift元组类型
什么是元组类型？？？？
定义：元组类型那个有N个任意类型的数据组成(N >= 0)，组成元组类型的数据可以称为“元素”
let position ＝ （x：10.5，y ： 20）
//position有2个元素，x、y是元素的名称
let person ＝ （name：“Jack”）
//person只有name一个元素
let data ＝ （） //空元组
元素的访问
var position ＝ （x：10.5，y：20）
用元素名称
let value ＝ position.x //取值
position.y = 50 //设值
用元素位置
var value = position.0 //相当于var value = position.x
position.1 = 50 //相当于position.y = 50
注意：如果用let来定义一个元组，那么就是常量，就无法修改它的元素
元组的输出
可以输出整个元组来查看所有元素的值
1.var point ＝ （x：10.5，y：20）
2.point.x = 30
3.point.1 = 50
4.println(point)
输出结果是（30.0，50）
使用细节
可以省略元素名称
1.let position ＝ （10，20）
2.let person ＝ （20，“jack”）
可以明确hiding元素的类型
var person：（Int，String）＝（23，“rose”）
person的第0个元素只能是Int类型、第1个元素只能是String类型
注意：
在明确指定元素类型的情况下不能加上元素名称
因此，下面的语句是错误的
var person：（Int，String）＝（age：23，name：“rose”）
可以用多个变量接受元组数据
1.var（x，y）＝（10，20） //x是10，y是20
2.var point ＝ （x，y） //point由2个元素组成，分别是10和20
可以将元素分别赋值给多个变量
1.var point ＝ （10，20）
2.var （x，y）＝ point
//x是10，y是20
可以使用下划线_忽略某个元素的值，取出其他元素的值
1.var person ＝ （20，“jack”）
2.var （_,name）＝ person
//name的内容是“jack”，person中的元素20被忽略
Swift流程机构：
Swift支持的流程结构
循环结构：for、for-in、while、do-while
选择结构：if、switch
注意：这些语句后面一定要跟上大括号｛｝
跟C语言对比：
用法基本一样的有：for、while、do-while、if
因此只需要关注for-in、switch即可
for - in
for - in和范围运算符
1.for i in 1. . .3{
2. println(i)
3.}
//按顺序从fanwie中取值赋值给i，每取1次值，就执行1次循环体
//范围的长度就是循环体执行的次数
如果不需要用到范围中的值，可以使用下划线_进行忽略
1.for _ in 1. . .3{
2. println(“**********")
3.}
Switch的一般结构
1.let grade ＝ “B”
2.switch grade｛
3.case “A”：
4. println（“优秀等级”）
5.case “B”
6. println（“良好等级”）
7.case “C”
8. println（“中等等级”）
9.default
10. println（“未知等级”）
11.｝
Switch语句在Swift和C中的区别
在C语言中
√如果case的结尾没有break，就会接着执行下一个case
在Swift中
√不需要在每一个cse后面增加break，执行完case对应的代码后默认会自动退出switch语句。
Switch的注意
在Swift中，每一个case后面必须有可以执行的语句
1.let grade ＝ “B”
2.switch grade ｛
3.case “A”：
4.case “B”：
5. println（“良好等级”）
6.default：
7. println（“未知等级”）
8. ｝
//第3行代码会报错
case的多条件匹配
1个case后面可以填写多个匹配条件，条件之间用都逗号，隔开
1.let score ＝ 95
2.switch score/10 {
3.case 10，9
4. println（“优秀”）
5.case 8，7，6：
6. println（“及格”）
7.default：
8. println（“不及格”）
9.}
//打印结果是：优秀
case 的范围匹配
case后面可以填写一个范围作为匹配条件
1.let score ＝ 95
2.switch score/10 {
3.case 90…100:
4. println（“优秀”）
5.case 60…89
6. println（“及格”）
7.default：
8. println（“不及格”）
9.}
//打印结果是：优秀
注意：
switch要保证处理所有可能的情况，不然编译器直接报错。
因此，这里的default一定要加，不然就出现了一些处理不到的情况。
case匹配元组
case还可以用来匹配元组
//比如判断一个点是否在矩形框内？？？
1.let point ＝ （1，1）
2.switch point ｛
3.case（0，0）
4. println（“这个点在圆点上”）
5.case（_，0）
6. println（“这个点在x轴上”）
7.case（0,_）
8. println（“这个点在y轴上”）
9.case（-2…2,-2…2)
10. println(“这个点在矩形框内”)
11.default：
12. println（“这个点在其他位置”）
13.｝
第5，7行代码中_的作用(2中理解方式)
➹能匹配任何值
➹忽略对应位置元组元素
case的数值绑定
在case匹配的同时，可以将switch中的值绑定给一个特定的常量或者变量，以便在case后面的语句中使用
1.let point ＝（10，0）
2.switch point｛
3.case （let x，0）
4. println（“这个点在x轴上，x 的值是\（x）”）
5.case （0，let y）
6. println（“这个点在y轴上，y的值是\（y）”）
7.case let（x，y）
8. println（“这个点的x值是\（x）,y的值是\（y）”）
9.｝
//打印：这个点在x轴上，x 的值是10
where
switch语句可以使用where来增加判断的条件
//比如判断一个点是否在下图的绿线或紫线上？？？
1.var point ＝ （10，-10）
2.switch point｛
3.case let（x，y）where x＝＝y：
4. println（“这个点在绿线上”）
5.case let（x，y）where x ＝＝y：
6. println（“这个点在紫线上”）
7.default：
8. println（“这个点不在这2条线上”）
9.｝
//打印：这个点在紫线上
fallthrough
fallthrough的作用
执行完当前case后，会接着执行fall through后面的case或者default语句
1.let num ＝ 20
2.var str ＝“\（num）是个”
3.switch num｛
4.case 0…50:
5. str += “0~50之间的”
6. fallthrough
7.default：
8. str +＝“整数”
9.｝
//打印：20是个0～50之间的整数
注意：fallthrough后面的case条件不能定义变量和常量
标签
使用标签的其中1个作用：可以用于明确指定要退出哪个循环
//做2组俯卧撑，每组3个，做完一组就休息一会
1.group：
2.for _ in 1…2｛
3. for item in 1…3｛
4. println（“做1个俯卧撑”）
5. if item ＝＝2｛
6. break group
7. ｝
8. ｝
9. println（“休息一会”）
10.｝
输出结果是：跳出了内循环
//做一个俯卧撑
//做一个俯卧撑
//如果没有group，只有break，输出结果：
做1个俯卧撑，休息一会
做1个俯卧撑，休息一会
函数：
函数的定义格式
1.func 函数名（形参列表）->返回值类型｛
2. //函数体…
3.｝
形参列表的格式
形参名1：形参类型1，形参名2：形参类型2，.......
举例：计算2个整数的和
C：
1.int sum（int num1，int num2）｛
2. return num1 + num2
3.｝
Swift：
1.func sum（num1：Int，num2：Int）-> Int｛
2. return num1 +num2
3.｝
没有返回值的函数
如果函数没有返回值，有3中写法：
1.func 函数名（形参列表）->Vodi｛
2. //函数体...
3.｝
1.func 函数名（形参列表）->（）｛
2. //函数体...
3.｝
1.func 函数名（形参列表）｛
2. //函数体..
3.｝
注：typealias Void ＝（）
没有形参的函数
一个函数如果没有形参，函数名后面的小括号也不能省略
1.func 函数名（）-> Int｛
2. //函数体
3.｝
上面的函数没有形参、返回值Int类型
返回元组的函数
一个额函数也可以返回元组数据
1.func find（id：Int）->（name：String，age：Int）
2. if id > 0｛
3. return（“jack”，20）
4. ｝else｛
5 return（“nobody”，0）
6. ｝.
7.｝
8.var people ＝ find（2）
9.println（“name＝\（people.name），age＝\（people.age）”）
外部参数名
一般情况下，通过形式参数的的名字，就能推断出这个参数的含义和作用
1.func addStudent（name：String，age：Int，no：Int）｛
2. println（“添加学生：name＝\(name), age＝\(age), no＝\(no)”）
3.｝
在函数内部一看参数名就知道这3个参数的作用
但是，形式参数是用在函数内部的，当调用函数是就看不到形参的名字，有可能导致以后会不太明白每个参数的含义
addStudent（“jack”，20，19）
一眼望去，能才出第1个参数“jack”是指姓名，后面的20，19分别代表什么含义？
为了解决上述问题，Swift提供了外部参数名语法
外部参数名可以在调用函数时提醒每个参数的含义
1.func 函数名（外部参数名 形式参数名：形式参数类型）->返回值类型｛
2. //函数体...
3.｝
➹外部参数名写在形式参数名的前面，与形式参数名之间用空格隔开
举例：
1.func sum（number1 num1：Int，number2 num2：Int）->Int
2.｛
3. return num1+num2
4.｝
5.sum（number1：10，number2：20） //调用函数
注意：一旦定义了外部参数名，在调用函数式就必须加上外部参数名
外部参数名的简写
使用#能建华外部参数名的定义
1.func sum（#num1：Int，#num2：Int）
2.｛
3. return num1+num2
4.｝
第1行代码的意思：num1、num2即使形式参数名，又是外部参数名
//调用函数 sum（num1：10，num2：20）
默认参数值
可以在定义函数时，给形参指定一个默认值，调用函数时，就可以不用给这个形参传值
1.func addStudent（name：String，age：Int ＝ 20）｛
2. println（“添加1个学生：name＝\(name), age＝\(age)”）
3.｝
4.addStudent（“jack”）
age参数有个默认值20，所以第4行调用函数时可以不传值给age参数
输出结果：添加1个学生：name＝ jack，age＝20
带有默认参数值的形参，Swift会自动给它生成一个跟形参名相同的外部参数名
age：Int ＝ 20相当于#age：Int ＝ 20
因此，如果要传入age参数值时，只能这么调用
addStudent（“jack”，age：25）
在带有默认参数值的参数名前加个下划线_,调用函数时就不用写外部参数名
1.func addStudent（name：String，_ age：Int ＝ 20）｛
2. println（“添加1个学生：name＝\(name), age＝\(age)”）
3.｝
4.addStudent（“jack”，25）
常量和变量参数
默认情况下，函数的参数都是常量参数，不能在函数内部修改
1.func test（num：Int）｛
2. num ＝ 10
3.｝
func test（num：Int）参数相当于func test（let num：Int）
第2行代码会报错
在有些情况下，可能需要在函数内部修改参数的值，这时需要定义变量参数
在参数名前面加个var即可
1.func test（var num：Int）｛
2. num ＝ 10
3.｝
举例：//编写函数在某个字符串的尾部拼接N个其他字符串
1.func append（var string：String，suffix：String，count：Int）-> String
2.｛
3. for _ in 0. . < count｛
4. string +＝ suffix
5. ｝
6. return string
7.｝
8.var destStr ＝ append（“jack”，“+”，4）
//输出结果：jack++++
输入输出参数：
什么是输入输出：
在C语言中，利用指针可以在函数内部修改外部变量的值
在Swift中利用输入输出参数，也可以在函数内部修改外部变量的值
输入输出参数，顾名思义，能输入一个值进来，也可以输出一个值到外部
输入输出参数的定义
在参数名前面加个inout关键字即可
1.func swap（inout num1：Int，inout num2：Int）｛
2.｝
举例：写一个函数交换外部2个变脸的值
1.func swap（inout num1：Int，inout num2：Int）｛
2. let tempNum1＝num1
3. num1 = num2
4. num2 = tempNum1
5.｝
6.var a ＝ 20
7.var b ＝ 10
8.swap（&a，&b） //传入的参数前面必须加上&
9.a
10.b
//执行完swap函数后，a的值是10，b的值是20
面试题
//如何在不利用第3方变量的前提下，交换2个变量的值
第1种做法：
1.func swap（inout num1：Int，inout num2：Int）｛
2. num1 =num1 + num2
3. num2 =num1 - num2
4. num1 =num1 - num2
5.｝
6.var a ＝ 20
7.var b ＝ 10
8.swap（&a，&b）
9.a
10.b
第2种做法：
1.func swap（inout num1：Int，inout num2：Int）｛
2. num1 =num1 ^ num2
3. num2 =num1 ^ num2
4. num1 =num1 ^ num2
5.｝
输入输出参数的使用注意：
➹传递实参时，必须在实参的前面加上&
➹不能传入常量或者字面量（比如10）作为参数值（因为它们都不可改）
➹输入输出参数不能有默认值
➹输入输出参数不能是可变参数
➹输入输出参数不能再使用let、var修饰（intout和let、var不能共存）
输入输出参数的价值之一：
可以实现函数的多返回值（其实让函数返回元组类型，也能实现返回多个值）
代码1：
1.func sumAndMinus（num1：Int，num2：Int）-> （sum：Int，minus：Int）｛
2. return（num1+num2，num1-num2）
3.｝
4.var result ＝ sumAndMinus（10，20）
5.result.sum
6.result.minus
代码2：
1.func sumAndMinus（num1：Int，num2：Int，inout sum：Int，inout minus：Int）｛
2. sum ＝ num1+num2
3.minus ＝num1-num2）
4.｝
5.var sum ＝ 0，minus ＝ 0
6.sumAndMinus（20，5，&sum，&minus）
7.sum
8.minus
