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开发的步骤、思想、框架都没有改变。

 

1、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提供了八、1六、3二、64位的有符号和无符号整数，好比

UInt8：8位无符号整型

Int32：32位有符号整型

Int八、Int1六、Int3二、Int6四、

UInt八、UInt1六、UInt3二、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

第二、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行代码的意思：num一、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