Swift全面深入详解视频教程

独家

下载课程

下载学院APP

缓存视频离线看

收藏(191)

Swift全面深入详解视频教程

适用人群: 想要轻松、系统、全面、深入地学习Swift编程语言的朋友

共305课时 共40小时2分钟 更新时间:2018-06-25

价  格

¥398

优惠活动

会员95折,立省20元

2424小时内答疑

课时永久观看

退15分钟内无条件退款

  1. 仅限付费视频课程适用
  2. 购买后15分钟内可以找到客服进行沟通退款
  3. 退款将返还至51CTO学院账户,不支持提现
  4. 下载资料后不再享有退款特权
  5. 客服(Tel:400-101-1651)
  6. 最终解释权归51CTO学院所有

APP缓存听课

PC倍速播放

专属资料下载

课程介绍

课程大纲

学习资料

学员评价

课程目标
轻松、系统、全面、深入地学习Swift语言的技术体系,彻底征服Swift!
适用人群
想要轻松、系统、全面、深入地学习Swift编程语言的朋友
课程简介
  • 课程优势和特色(4.x)

    1、使用专业的铁三角电容麦克风对视频进行录制,保证视频有清晰的音质。 2、视频内容基于Swift最新版,而且视频内容会随Swift版本的更新而及时更新。3、对Swift技术体系进行了完整介绍。4、任何一个理论技术要点都有相关的案例程序进行演示和验证。5、案例程序尽可能通俗、易...

  • Swift的创始人、历史和特点(4.x)

    Swift语言的创始人是Chris Lattner(克里斯·拉特纳)。Chris于2005年加入苹果公司。Swift语言的底层架构大多由其一人开发完成。除了Swift语言的创始人之外,Chris还是鼎鼎大名的LLVM编译器框架的创始人,以及Clang项目的发起者。Clang是LLVM的一个编译器前端,其目标是取代鼎鼎大名...

  • 搭建Swift开发环境(4.x)

    如果没有苹果电脑,可以在PC上安装虚拟机,比如:VirturalBox、VMWare Workstation等,然后在虚拟机里安装macOS操作系统。 两种下载和安装方式: (1)直接打开Mac App Store,搜索Xcode (2)通过Xcode的官方网站:https://developer.apple.com/download/

  • 在终端窗口中编译和运行HelloWorld(4.x)

    命令swiftc可用于编译Swift程序,其语法格式为: swiftc -o .out .swift 启动终端,切换到HelloWorld.swift所在的目录,输入如下命令对HelloWorld.swift进行编译: swiftc -o hw.out HelloWorld.swift 编译后,HelloWorld.swift所在的目录生成了新文件hw.out。 在终...

  • 在Xcode项目中编译和运行HelloWorld(4.x)

    点击屏幕左上角的三角形按钮,大家看,我把鼠标放在这个按钮上先不点击,它显示的是:build and the run the current scheme,也就是说或,编译并运行当前的项目。我们点击一下这个按钮,然后在屏幕的右下方显示出了程序的运行结果,打印出了字符串Hello World!"。其实,Xcode...

  • 在Playground中编译和运行HelloWorld(4)

    当我们写完这行代码的时候,Playground文件会自动编译并运行,然后将结果显示在这行代码的右边。我们将字符串“Hello World!”改为“Hello Swift!”,大家看,这行代码的运行结果立刻就在代码的右边显示出来了。所以,Playground文件是不是非常得好啊,当我们改了一行代码的时候,...

  • Playground简介(4.x)

    Playground的字面意思是“操场, 运动场, 游乐场 ”,其特点是”实时预览,所见即所得“,也就是说,写完一行代码之后,立刻就会显示出该行代码的运行结果。 Playground可以用来快速方便地验证想法(Explore new ideas quickly and easily),正如Xcode的启动界面所示。

  • 变量和常量的概述(4.x)

    计算机在运行时用到的所有数据都被存储在内存中。数据是各种各样的,因此,系统将数据存储到内存时会根据数据的类型为它分配一块合适的内存空间,被分配的这块内存空间被称为变量。当把数据存储到内存后,为了能够找到已经被存储的数据,需要为存储数据的那部分内存空间起一个名字,...

  • 变量和常量的声明及初始化(上)(4.x)

    变量或常量在使用前必须先声明并初始化,包括:(1)给变量或常量起一个名字(2)指定变量或常量的数据类型(3)给变量或常量赋予一个初始值。使用var声明变量,使用let声明常量。声明变量或常量都有两种语法格式,声明变量的第一种语法格式为:var 变量名 = 初始值,声明常量的第...

  • 变量和常量的声明及初始化(下)(4.x)

    声明变量的第二种语法格式为:var 变量名: 数据类型 [= 初始值],声明常量的第二种语法格式为:let 常量名: 数据类型 [= 初始值]。这种声明变量或常量的方式为显式方式,也就是说,显式指定了变量或常量的数据类型。可以在同一行同时声明并初始化多个变量或多个常量,之间用...

  • 变量和常量的命名规则(关键字和标识符)(4.x)

    所谓关键字,就是Swift语言定义的、具有特殊用途的单词。例如:声明及初始化变量或常量时使用的var和let都是关键字。所谓标识符,就是给程序中的变量、常量、方法、函数、枚举、结构体、类、协议等命名的名字。在命名这些名字时,必须遵守以下命名规则:(1)区分大小写(2)不能是关...

  • 数据类型的概述(4.x)

    任何变量、常量和直接数都有明确的数据类型,例如:整数类型、字符串类型等。当把值类型的值赋给变量或常量时,或把值类型的值作为实参传给函数的形参时,赋予或传递的都是值的拷贝。当把引用类型的值赋给变量或常量时,或把引用类型的值作为实参传给函数的形参时,赋予或传递的都是...

  • 整数类型(上)(4.x)

    整数类型用于表示整数。整数类型分为两种:(1)有符号整数类型:可以表示正整数、0和负整数。(2)无符号整数类型:只能表示正整数和0,不能表示负整数。有符号整数类型有五种表示方式:(1)Int8:在内存中占8位,第1位是符号位,能表示的整数范围是:-128(-2的7次方) ~ 127(2...

  • 整数类型(下)(4.x)

    如果被存储的值超出了变量或常量的数据类型所能表示的数值范围,程序是可以编译通过的,但是运行时会出错。可以访问不同整数类型的属性min和max来得到其最小值和最大值。如果声明并初始化整数类型的变量或常量时不指定具体的整数类型,系统默认将该变量或常量推断为Int类型。整数类型...

  • 不同整数类型运算时的相互转换(4.x)

    如果把两个不同整数类型的变量或常量进行运算(包括赋值运算、算术运算和比较运算),必须显式地将其转换为相同的整数类型,否则会编译出错。在进行显式类型转换时,如果被转换的变量或常量的值超出了转换后的数据类型所能表示的数值范围,程序是可以编译通过的,但是运行时会出错。

  • 浮点类型(4.x)

    浮点类型用于表示浮点数,也就是小数。浮点类型有两种表示方式:(1)Float:表示32位的浮点类型,可以精确到小数点后6位。(2)Double:表示64位的浮点类型,可以精确到小数点后15位。具体选用哪种浮点类型,取决于所存储的浮点数的范围。通常情况下,推荐使用Double。如果声明浮点...

  • 不同浮点类型运算时的相互转换(4.x)

    如果把两个不同浮点类型的变量或常量进行运算(包括赋值运算、算术运算和比较运算),必须显式地将其转换为相同的浮点类型,否则会编译出错。

  • 整数类型和浮点类型运算时的相互转换(4.x)

    如果把整数类型和浮点类型的变量或常量进行运算(包括赋值运算、算术运算和比较运算),必须显式地将其转换为相同的类型,否则会编译出错。当把浮点类型转换成整数类型时,在该浮点类型的值不超出该整数类型所表示数值范围的前提下,浮点类型的值的小数部分会被截掉。在进行显式类型...

  • 布尔类型(4.x)

    布尔类型用于表示一个逻辑值,该逻辑值要么是真,要么是假,分别用true和false表示。例如:这次数学考试及格了吗?地铁三号线的早班车时间是6:00吗?布尔类型用Bool表示。布尔类型主要用于条件判断语句中。Swift的类型安全机制可以防止在应该使用布尔类型的时候使用了其它类型。

  • 元组类型(上)(4.x)

    元组相当于关系数据库中的一条记录,它将多个任意数据类型的值合并为一个值。元组类型的值的语法格式为:(元素1, 元素2, ..., 元素n)。如果想要访问元组中的元素,有以下几种方式:(1)使用索引值访问(索引值从0开始)。(2)为元组中的元素指定名字,然后使用指定的名字访问...

  • 元组类型(下)(4.x)

    如果只需要访问元组中的部分元素,可以使用下划线_代替那些不需要被访问的元素的名字或其对应的变量或常量。元组主要用于多个相关值的临时组合,比如用作函数的返回值。如果需要持久化地存储复杂的数据,不适合使用元组,可以考虑使用类或结构体。可以使用元组方便地交换两个变量的值。

  • 可选类型(4.x)

    有时可能会存在“值缺失”的情况,比如数据类型相互转换时转换失败。"值缺失"用nil表示。 为了处理可能存在“值缺失”的情况,Swift引入了可选类型。在声明任何数据类型的变量或常量时,都可以在数据类型的后面添加一个问号?,这样,声明的变量或常量就是可选类型的。可选类型的变量...

  • 可选类型的解包之强制解包(4.x)

    对于可选类型的变量或常量,如果想要访问其包装的实际值,可以在变量或常量的后面添加叹号!进行强制解包。对nil进行强制解包会导致运行时错误。因此,在对可选类型的变量或常量进行强制解包时要进行判断。

  • 可选类型的解包之可选绑定(上)(4.x)

    对于可选类型的变量或常量,如果想要访问其包装的实际值,除了强制解包外,还可以使用可选绑定。对于可选类型的变量或常量,如果想要访问其包装的实际值,推荐使用可选绑定而不是强制解包,因为强制解包可能会因为被强制解包的变量或常量的值是nil而导致运行时错误。在可选绑定的if语...

  • 可选类型的解包之可选绑定(下)(4.x)

    在可选绑定的if语句中,可以同时使用多个可选的绑定和判断条件,并用逗号进行分隔。只要其中一个可选的绑定值为nil,或其中一个判断条件的值为false,那么整个if语句的判断结果就为false。

  • 隐式解包的可选类型(4.x)

    如果确定一个可选类型的变量或常量始终是有值的,也就是说,不可能存在“值缺失”的情况,那么可以在声明变量或常量时用叹号!代替问号?。这样,被声明的变量或常量就成为隐式解包的可选类型,以后凡是用到该变量或常量的时候,系统都会在其后面自动添加叹号!以进行强制解包,而无须每...

  • 类型别名(4.x)

    可以使用关键字typealias为任意一个已经存在的数据类型起一个别名,其语法格式为:typealias 类型别名 = 已经存在的数据类型。这样,以后任何用到“已经存在的数据类型”的地方都可以使用“类型别名”。

  • 运算符的概述(4.x)

    运算符是一种特殊的符号。通过运算符对相应数据类型的运算数(变量、常量、直接数或表达式)进行运算。例如:加法运算符+可用于将两个整数类型的运算数进行相加的运算,比如3 + 5;逻辑与运算符&&可用于将两个布尔类型的运算数进行逻辑与的运算,比如true && false。根据运算符...

  • 简单赋值运算符(4.x)

    赋值运算符用于将一个变量、常量、直接数或表达式的值赋值给另一个变量或常量。赋值运算符分为简单赋值运算符和复合赋值运算符。简单赋值运算符用=表示,其语法格式为:a = b,其运算规则为:把b的值赋给a。在C语言和Objective-C语言中,赋值语句返回=左边的值,并且0表示false,非...

  • 复合赋值运算符(4.x)

    复合赋值运算符是由基本运算符和简单赋值运算符复合而成的运算符。 常见的复合赋值运算符有: (1)+= (2)-= (3)*= (4)/= (5)%= (6)= (8)&= (9)|= (10)^= 这些复合赋值运算符的语法格式和运算规则都是类似的。以+=为例,其语法格式为:a += ...

  • 比较运算符(上)(4.x)

    用于基本数据类型间的比较运算符有六个: (1)== (2)!= (3)> (4)>= (5)< (6)

  • 比较运算符(下)(4.x)

    如果两个元组的元素数量相同,并且所有位置的相应两个元素都可以使用上面的比较运算符进行比较,那么这两个元组就是可以比较的,其比较规则为:从左到右,依次比较每个位置的相应两个元素,直到某个位置的相应两个元素的值不相等,其比较结果就是元组的比较结果,并且不再比较后面位...

  • 正号和负号运算符(4.x)

    正号运算符用+表示,负号运算符用-表示。正号运算符对运算数没有任何改变。当在代码中对负数使用负号运算符的时候,可以对正数使用正号运算符,以增加代码的对称性和可读性。正号运算符和负号运算符的后面都不能有空格。

  • 标准算术运算符(4.x)

    标准算术运算符包括加减乘除四个运算符,分别为: (1)+ (2)- (3)* (4)/如果两个整数使用除法运算符/进行除法运算,运算结果只保留整数部分。如果一个整数类型的直接数和一个浮点类型的直接数使用除法运算符/进行除法运算,或者两个浮点类型的直接数使用除法运算符...

  • 取余运算符(4.x)

    取余运算符用%表示,其语法格式为:a % b,对应的运算规则为:a % b = a - b × 倍数 = 余数,也就是说,a对b取余就是计算a最多可以容纳多少个b,多出来的那部分就是余数。使用取余运算符%进行取余运算时,运算结果的正负与被除数的正负保持一致。

  • 逻辑运算符(上)(4.x)

    逻辑运算符有三种: (1)逻辑与运算符&& 其语法格式为:逻辑表达式1 && 逻辑表达式2,对应的运算规则为:逻辑表达式1和逻辑表达式2都为true,运算结果才为true。 逻辑与运算符&&是短路运算符,也就是说,如果逻辑表达式1为false,将不再计算逻辑表达式2,并且运...

  • 逻辑运算符(下)(4.x)

    逻辑或运算符||也是短路运算符,也就是说,如果逻辑表达式1为true,将不再计算逻辑表达式2,并且运算结果为true。(3)逻辑非运算符! 其语法格式为:!逻辑表达式(!的后面不能有空格),对应的运算规则为:如果逻辑表达式为true,运算结果为false;如果逻辑表达式为false,运算结果为true。

  • 三目条件运算符(4.x)

    三目条件运算符用?:表示,其语法格式为:判断条件 ? 条件执行体1 : 条件执行体2,对应的运算规则为:先对判断条件求值,如果判断条件的值为true,执行条件执行体1并返回其值;如果判断条件的值为false,执行条件执行体2并返回其值。三目条件运算符支持嵌套,但是嵌套之后降低了代码的可读性。

  • 区间运算符(4.x)

    区间运算符有两种: (1)... 闭区间运算符,a...b表示[a, b]。 (2)..< 半闭半开区间运算符,a..

  • NilCoalescing运算符(4.x)

    NilCoalescing运算符用??表示,其语法格式为:a ?? b,对应的运算规则为:如果a为nil,返回b的值;如果a不为nil,返回a包装的实际值。因此,a ?? b等同于:a == nil ? b : a!。其中,a总是可选类型,b的类型必须与a包装的实际值的类型保持一致。NilCoalescing运算符是短...

  • 运算符的优先级和结合性(上)(4.x)

    每个运算符都有固定的优先级。 当表达式中包含优先级不同的运算符时,高优先级的运算符先参与运算。 每个运算符都有固定的结合性。 当表达式中包含优先级相同的运算符时,结合性定义了哪个运算符先参与运算。 结合性分为三种: (1)Left Left表示表达式中左边的运...

  • 运算符的优先级和结合性(下)(4.x)

    对于包含多个运算符的复杂表达式,其可读性是较低的,为了提高可读性,建议的做法有两种: (1)在复杂表达式中使用小括号()指定运算顺序。 (2)将复杂表达式拆分成几步来完成。

  • 字符和字符串的概述(4.x)

    在程序中,文本内容用字符串来表示。 字符串由一系列有序的字符组成,例如:“HelloWorld”、“SwiftLanguage”。 在每个新创建的Playground文件中都包含一个字符串:"Hello, playground"。

  • 字符的表示方式(4.x)

    字符的表示方式通常有两种: (1)直接使用双引号引起来 其中,双引号中可以为:字符本身、字符的转义字符、字符的Unicode编码。 (2)调用Character的构造器init(_ s: String) 其中,参数是只包含一个字符的字符串。 在表示字符时,还可以将字符的转义字符...

  • 字符变量和常量的声明及初始化(4.x)

    字符变量和常量在使用前必须先声明并初始化,包括: (1)给变量或常量起一个名字 (2)指定变量或常量的数据类型为Character (3)给变量或常量赋予一个初始值 如果使用隐式方式指定变量或常量的数据类型,并且给变量或常量赋予的初始值是直接使用双引号引起来的字符,那...

  • 字符的可变性(4.x)

    如果希望字符是可变的(可被修改的),使用关键字var声明一个字符变量;如果希望字符是不可变的(不可被修改的),使用关键字let声明一个字符常量。

  • 字符是值类型(4.x)

    当把字符赋给变量或常量时,赋予的是值的拷贝;当把字符作为实参传给函数或方法的形参时,传递的也是值的拷贝。因此,字符是值类型。

  • 字符的UnicodeScalar(4.x)

    系统在底层是以Unicode Scalar的形式存储每个字符的。每个字符都是一个或多个Unicode Scalar的有序组合。Unicode Scalar是21位的Unicode编码,用UInt32类型的值来表示。对于有些由多个Unicode Scalar组成的字符,Swift提供了与其等价的单个Unicode Scalar。

  • 字符的相等性比较(4.x)

    如果两个字符变量或常量存储的Unicode Scalar序列表示的是同一个字符,这两个字符变量或常量就是相等的。

  • 字符串的表示方式(4.x)

    字符串的表示方式通常有两种: (1)直接使用双引号引起来 其中,""表示一个空字符串。 (2)调用String的构造器init?(_ description: String) String()表示一个空字符串。

  • 字符串变量和常量的声明及初始化(4.x)

    字符串变量和常量在使用前必须先声明并初始化,包括: (1)给变量或常量起一个名字 (2)指定变量或常量的数据类型为String (3)给变量或常量赋予一个初始值

  • 多行字符串字面量(4.x)

    如果想让一个字符串是跨越多行的,可以使用多行字符串字面量,它的语法格式是用三个双引号将跨越多行的字符串引起来。 如果想让一个多行字符串字面量开始和结束于换行符,可以将换行符写在第一行和最后一行。 对于多行字符串字面量,如果仅仅想通过换行增加代码的可读性,而不是...

  • 字符串的可变性(4.x)

    如果希望字符串是可变的(可被修改的),使用关键字var声明一个字符串变量;如果希望字符串是不可变的(不可被修改的),使用关键字let声明一个字符串常量。

  • 字符串是值类型(4.x)

    当把字符串赋给变量或常量时,赋予的是值的拷贝;当把字符串作为实参传给函数或方法的形参时,传递的也是值的拷贝。因此,字符串是值类型。

  • 字符串的字符个数(4.x)

    如果想要统计字符串中的字符个数,可以访问字符串的属性count。访问属性count时,系统会遍历字符串的所有Unicode Scalar。

  • 字符串的比较(4.x)

    当比较两个字符串时,系统会分别遍历这两个字符串的Unicode Scalar。 用于字符串比较的运算符有六个: (1)== 用于比较两个字符串是否包含相同的字符序列。通俗地说,用于比较两个字符串是否包含相同的文本。 (2)!= 用于比较两个字符串是否包含不同的字...

  • 字符串的遍历(4.x)

    如果想要遍历字符串,可以通过两种方式: (1)把字符串中的字符作为循环变量 (2)把字符串中字符的索引作为循环变量

  • 字符串的Unicode表示方式(上)(4.x)

    当一个Unicode字符串被写入文本文件或存储设备时,该字符串的Unicode Scalar会被编码为Unicode兼容的格式,主要有三种: (1)UTF-8 字符串的属性utf8返回其UTF-8编码。 返回值的类型是String.UTF8View。 返回值是一个UInt8类型的值的集合,也就是说,集...

  • 字符串的Unicode表示方式(下)(4.x)

    (2)UTF-16 字符串的属性utf16返回其UTF-16编码。 返回值的类型是String.UTF16View。 返回值是一个UInt16类型的值的集合,也就是说,集合中的每个元素都是一个0~65535之间的整数,占2个字节。 (3)UTF-32(Unicode Scalar) 字符串的属性unicod...

  • 字符串中字符的索引(上)(4.x)

    字符串中字符的索引类型不能是整数类型,因为:不同的字符占用的内存存储空间是不同的,对于给定的整数类型索引,Swift并不能确定其对应的字符,必须遍历字符串中的所有Unicode Scalar才能确定每个字符的位置。 字符串中字符的索引类型是String.Index,String.Index是String.Chara...

  • 字符串中字符的索引(下)(4.x)

    如果想要取得字符串中相关字符的索引,还可以调用以下方法: (1)index(before i: String.Index) -> String.Index 该方法返回参数i指定的索引的前面位置的索引。 (2)index(after i: String.Index) -> String.Index 该方法返回参数i指定的索引的后面位...

  • 字符串的查操作(4.x)

    如果想要取得字符串中的相关字符,可以使用下标语法和字符索引。当字符索引越界时,会导致运行时错误。

  • 字符串的改操作(4.x)

    不能使用下标语法修改字符串中指定索引的字符值,否则会导致编译错误。

  • 字符串的增操作(4.x)

    如果想要增加字符串中的字符,可以调用以下方法: (1)append(_ c: Character) 该方法用于在字符串的末尾追加参数c指定的字符。 (2)append(_ other: String) 该方法用于在字符串的末尾追加参数other指定的字符串。 (3)insert(_ newElement: Charact...

  • 字符串的删操作(4.x)

    如果想要删除字符串中指定索引的字符,可以调用以下方法: (1)remove(at i: String.Index) -> Character 该方法用于删除字符串中参数i指定索引的字符。 该方法的返回值是被删除的字符。 (2)removeSubrange(_ bounds: Range) 该方法用于删除字符串中参数bounds指定索引的字符。

  • 字符串的大小写转换(4.x)

    如果想要将字符串中的所有字母在大写和小写之间转换,可以调用如下两个方法: (1)uppercased() -> String 该方法用于将字符串中的所有小写字母全部转换为大写字母。 该方法的返回值为转换后的字符串。 (2)lowercased() -> String 该方法用于将字...

  • 字符串与整数或浮点数的相互转换(4.x)

    字符串与整数或浮点数之间可以相互转换: (1)把整数或浮点数作为String的构造器的参数,可以将整数或浮点数转换为字符串。 (2)把内容为整数的字符串作为Int的构造器的参数,可以将该字符串转换为整数;把内容为浮点数的字符串作为Float或Double的构造器的参数,可以将该字符...

  • 字符串的插值(4.x)

    推荐使用字符串插值的方式,因为更容易理解和维护。 字符串中可以通过占位符的形式进行插值,可以插入的占位符包括: (1)变量 (2)常量 (3)表达式 (4)字面量(直接数) 其语法格式为:\(插入的占位符)。 当访问字符串的时候,所有插入的占位符都被替换成实际值。

  • Collection类型的概述(上)(4.x)

    为了使程序能方便地存储和操作数目不固定的一组数据,Swift提供了三种Collection类型: (1)Array(数组) (2)Set(集合) (3)Dictionary(字典)

  • Collection类型的概述(下)(4.x)

    以上三种Collection类型中的元素类型都是明确的,也就是说,创建某种Collection类型时,其中的元素类型已经被确定了。程序只能向Collection类型中存储对应类型的数据,并且只能从Collection类型中取出对应类型的数据。如果希望某种Collection类型是可变的(可被修改的),使用关键字...

  • 数组变量和常量的声明及初始化(上)(4.x)

    数组变量和常量在使用前必须先声明并初始化,包括: (1)给变量或常量起一个名字 (2)指定变量或常量的数据类型为数组类型 (3)给变量或常量赋予一个初始值

  • 数组变量和常量的声明及初始化(中)(4.x)

    (2)构造器语法: a. init(arrayLiteral elements: Array.Element...) 参数elements用于指定可变的数组元素列表。 b. init(repeating repeatedValue: Element, count: Int) 参数repeatedValue用于指定数组元素的重复值,参...

  • 数组变量和常量的声明及初始化(下)(4.x)

    []、[数组元素的类型]()、Array()和Array()都表示一个不包含任何元素的空数组。 当使用[]和Array()时,上下文中必须提供数组元素的类型,以便系统可以自动类型推断。

  • 数组中元素的索引(4.x)

    数组中第一个元素的索引是0。数组中最后一个元素的索引是数组元素的个数-1。如果想要取得数组中相关元素的索引,可以访问某些属性或调用某些方法。

  • 数组的“查”操作(上)(4.x)

    如果想要取得数组中的相关元素,可以使用下标语法和索引。 当索引越界时,会导致运行时错误。 如果想要取得数组的相关元素,还可以访问某些属性。

  • 数组的“查”操作(下)(4.x)

    如果想要取得数组的相关元素,还可以调用某些方法。

  • 数组的“改”操作(4.x)

    如果想要修改数组中指定索引的元素值,可以使用下标语法。 如果指定的索引是一个区间,索引个数与修改后的元素值组成的数组的元素个数可以不相同。

  • 数组的“增”操作(上)(4.x)

    因为数组中的所有元素是按顺序有序排列的,所以,当在数组中的某个位置添加一个元素时,该位置后面的所有元素都依次后移一个位置。 不能使用下标语法增加数组的元素。 如果想要增加数组的元素,可以调用某些方法。 如果想要增加数组的元素,还可以使用运算符+=,该运算符可用于...

  • 数组的“增”操作(下)(4.x)

    如果想要增加数组的元素,还可以使用运算符+=,该运算符可用于在数组的末尾追加另一个类型相同的数组。 此外,运算符+可用于连接两个类型相同的数组,并且连接后两个数组都保持不变。

  • 数组的“删”操作(上)(4.x)

    因为数组中的所有元素是按顺序有序排列的,所以,当在数组中的某个位置删除一个元素时,该位置后面的所有元素都依次前移一个位置。如果想要删除数组中指定索引的元素,可以调用某些方法。

  • 数组的“删”操作(中)(4.x)

    如果想要删除数组中的相关元素,还可以调用某些方法。

  • 数组的“删”操作(下)(4.x)

    如果想要删除数组中的相关元素,还可以调用某些方法。

  • 数组的遍历(4.x)

    如果想要遍历数组,可以通过以下两种方式: (1)把数组元素作为循环变量 (2)把数组元素的索引作为循环变量 如果需要获得每个元素的索引,可以先调用方法enumerated()返回一个元组序列。其中,元组中的元素为数组中元素的索引和对应的元素值。

  • 数组是值类型(4.x)

    当把数组赋给变量或常量时,赋予的是值的拷贝;当把数组作为实参传给函数或方法的形参时,传递的也是值的拷贝。因此,数组是值类型。

  • 数组的相等性比较(4.x)

    如果两个数组以相同的顺序包含相同的元素,这两个数组就是相等的。如果数组中的元素类型遵守了Equatable协议(所有的基本数据类型都默认遵守了协议Hashable,从而遵守了协议Equatable),可以使用运算符==或调用方法elementsEqual(_:)来比较两个数组是否相等。

  • 数组的容量(4.x)

    系统为每个数组都分配了一块内存空间用来存储数组的所有元素。当增加数组的元素时,如果数组的内存空间已经满了,系统会为数组重新分配一块更大的内存空间,并将数组的所有元素(包括新增加的元素)拷贝到新的内存空间。这个过程是比较耗费性能的。因此,如果大约知道数组中元素个数...

  • 多维数组(上)(4.x)

    当数组中的元素也是数组时,就构成了多维数组。例如:二维数组中的元素是一维数组,三维数组中的元素是二维数组。也就是说,多维数组是特殊的一维数组,因此,多维数组与一维数组的操作都是类似的。二维数组的“增删改查”操作与一维数组的“增删改查”操作类似。

  • 多维数组(下)(4.x)

    遍历二维数组与遍历一维数组相似。 通常最多会用到三维数组,很少用到四维及四维以上的数组。

  • 数组的方法index()(4.x)

    如果想要查找数组中指定条件的元素的索引,可以调用方法index()。

  • 数组的方法contains()(4.x)

    如果想要判断数组中是否存在指定条件的元素,可以调用方法contains()。

  • 数组的方法starts()(4.x)

    如果想要判断数组是否以指定条件的序列作为前缀,可以调用方法starts()。

  • 数组的方法filter()(4.x)

    如果想要过滤出数组中指定条件的元素,可以调用方法filter(): filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] 该方法根据参数isIncluded指定的过滤条件对数组中的元素进行过滤。 该方法的返回值为过滤出的元素组成的新数组,且原数组保持不变。

  • 数组的方法map()(4.x)

    如果想要对数组中的所有元素进行映射,可以调用方法map(): map(_ transform: (Element) throws -> T) rethrows -> [T] 该方法根据参数transform指定的映射规则对数组中的所有元素进行映射。 该方法的返回值为映射后的元素组成的新数组,且原数组保持不变。

  • 数组的方法joined()(4.x)

    如果想将数组中的所有元素进行连接,可以调用方法joined():joined(separator: String = default) -> String该方法使用参数separator指定的连接符将数组中的所有元素进行连接。默认的连接符是空字符串。该方法的返回值是连接后的字符串,且原数组保持不变。

  • 数组的方法flatMap()(4.x)

    如果想将多个数组中的元素进行映射并连接为一个数组,可以调用方法flatMap(): flatMap(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] 该方法的返回值是映射并连接后的新数组,且原数组保持不变。 s.flatMap(transform)与Array(s.map(transform).joined())是等价的。

  • 数组的方法sorted()和sort()(4.x)

    如果想对数组中的元素进行排序,可以调用方法sorted()或sort()。

  • 数组的方法min()和max()(4.x)

    如果想求出数组中的最小元素和最大元素,可以调用方法min()和max()。

  • 数组的方法reduce()(4.x)

    方法reduce()重复调用参数nextPartialResult指定的组合规则,对累积值和数组中的元素进行组合,组合后得到一个新的累积值。其中,参数initialResult指定了累积值的初始值。

  • 数组的方法split()(上)(4.x)

    如果想对数组中的元素进行劈分,可以调用方法split()。

  • 数组的方法split()(下)(4.x)

    如果想对数组中的元素进行劈分,可以调用方法split()。

  • 数组的方法reversed()(4.x)

    如果想对数组中的所有元素执行逆序操作,可以调用方法reversed()。

  • 集合变量和常量的声明及初始化(上)(4.x)

    与数组不同,表示集合类型的语法没有简化语法,只有泛型语法:Set,例如:集合类型Set表示集合元素的类型为String的字符串集合;集合类型Set表示集合元素的类型为Int的整型集合。 之所以可以使用泛型语法表示集合类型,是因为集合的本质就是带泛型的结构体:struct Set。

  • 集合变量和常量的声明及初始化(下)(4.x)

    虽然创建集合的语法没有简化语法,但是对于使用简化语法创建的数组,可以将其设置为集合变量或常量的初始值,此时必须显式指定变量或常量的数据类型为集合类型,否则系统会推断为数组类型。 []、Set()和Set()都表示一个不包含任何元素的空集合。 当使用[]和Set()时,上下文中必须...

  • 集合中元素的索引(上)(4.x)

    集合中的元素也是有索引的。与数组不同的是,集合中元素索引的类型不是Int,而是Set.Index。 如果想要取得集合中相关元素的索引,可以访问某些属性和调用某些方法。

  • 集合中元素的索引(下)(4.x)

    如果想要取得集合中相关元素的索引,可以访问某些属性和调用某些方法。

  • 集合的“查”操作(上)(4.x)

    如果想要取得集合的相关元素,可以使用下标语法和索引。 当索引越界时,会导致运行时错误。 如果想要取得集合的相关元素,还可以访问属性first。该属性用于取得集合的第一个元素。

  • 集合的“查”操作(下)(4.x)

    如果想要取得集合的相关元素,还可以调用某些方法。

  • 集合的“改”操作(4.x)

    与数组不同,不能使用下标语法修改集合中指定索引的元素值。

  • 集合的“增”操作(4.x)

    如果想要增加集合的元素,可以调用方法insert()。 该方法用于在集合中添加参数newMember指定的元素。 如果集合中不存在参数newMember指定的元素,该方法返回(true, newMember);如果集合中已经存在参数newMember指定的元素,该方法返回(false, newMember),并且参数newMember指...

  • 集合的“删”操作(上)(4.x)

    如果想要删除集合中指定元素值或指定索引的元素,可以调用方法remove()。

  • 集合的“删”操作(下)(4.x)

    如果想要删除集合中的相关元素,还可以调用某些方法。

  • 集合的遍历(4.x)

    如果想要遍历集合,可以通过以下两种方式: (1)把集合元素作为循环变量 (2)把集合元素的索引作为循环变量 如果需要获得每个元素的序号,可以先调用方法enumerated()返回一个元组序列。其中,元组中的元素为遍历过程中元素的序号和集合中对应的元素值。 集合中的元素是没...

  • 集合的相等性比较(4.x)

    如果两个集合包含相同的元素,这两个集合就是相等的。 如果集合中的元素类型遵守了Equatable协议(所有的基本数据类型都默认遵守了协议Hashable,从而遵守了协议Equatable),可以使用运算符==或调用方法elementsEqual(_:)来比较两个集合是否相等。

  • 集合是值类型(4.x)

    当把集合赋给变量或常量时,赋予的是值的拷贝;当把集合作为实参传递给函数或方法的形参时,传递的也是值的拷贝。因此,集合是值类型。

  • 集合和数组的相互转化(4.x)

    集合和数组可以相互转化。 借助于集合元素的唯一性,可以去除数组中的重复元素,从而使得数组中的元素也具有唯一性。实现方式为:将具有重复元素的数组转换为集合,再将得到的集合转换为数组。

  • 集合间的关系(4.x)

    集合间存在着如下关系: (1)子集 (2)真子集 (3)超集 (4)真超集 (5)是否没有交集

  • 集合间的操作(上)(4.x)

    a.intersection(b)表示:集合a和集合b的交集。a.union(b)表示:集合a和集合b的并集。a.symmetricDifference(b)表示:集合a和集合b的并集 — 集合a和集合b的交集。a.subtracting(b)表示:集合a — 集合a和集合b的交集。

  • 集合间的操作(下)(4.x)

    a.formIntersection(b)表示:用a.intersection(b)的结果替换a。a.formUnion(b)表示:用a.union(b)的结果替换a。a.formSymmetricDifference(b)表示:用a.symmetricDifference(b)的结果替换a。a.subtract(b)表示:用a.subtracting(b)的结果替换a。

  • 集合的常见方法(上)(4.x)

    可以参考数组的常见方法加以类比。

  • 集合的常见方法(下)(4.x)

    可以参考数组的常见方法加以类比。

  • 哈希表(4.x)

    在数组中查找指定的元素时,需要把被查找的元素和数组中一系列的元素进行比较。这种查找方法建立在“比较”的基础上,查找的效率依赖于查找过程中所进行的比较次数。 如果元素的值value和它的位置index有一个确定的对应关系hash():index = hash(value),只要调用该对应关系,就...

  • 集合元素的类型必须遵守协议Hashable(4.x)

    集合的本质是带泛型的结构体:struct Set。由集合类型的声明可知,集合元素的类型必须遵守协议Hashable,同时集合使用了哈希表来提高查找元素的效率。所有的基本数据类型都默认遵守了协议Hashable,因此,所有的基本数据类型都可以作为集合元素的类型。

  • 字典变量和常量的声明及初始化(上)(4.x)

    字典变量和常量在使用前必须先声明并初始化,包括: (1)给变量或常量起一个名字 (2)指定变量或常量的数据类型为字典类型 (3)给变量或常量赋予一个初始值

  • 字典变量和常量的声明及初始化(中)(4.x)

    创建字典的语法有两种: (1)简化语法:[key1: value1, key2: value2, key3: value3, ..., keyN: valueN](2)构造器语法

  • 字典变量和常量的声明及初始化(下)(4.x)

    [:]、[Key的类型: Value的类型]()、Dictionary()和Dictionary()都表示一个不包含任何元素的空字典。当使用[:]和Dictionary()时,上下文中必须提供字典元素的类型,否则系统将无法自动类型推断。

  • 字典中元素的索引(4.x)

    字典中的元素也是有索引的。与数组不同的是,字典中元素索引的类型不是Int,而是Dictionary.Index。

  • 字典的“查”操作(上)(4.x)

    如果想要取得字典的相关元素,可以使用下标语法和索引。 当索引越界时,会导致运行时错误。 如果想要取得字典的相关元素,还可以访问属性first。该属性用于取得字典的第一个元素。

  • 字典的“查”操作(中)(4.x)

    如果想要取得字典的相关元素,还可以调用某些方法。

  • 字典的“查”操作(下)(4.x)

    如果想要取得字典的相关元素,还可以调用某些方法。

  • 字典的“改”操作(4.x)

    与数组不同,不能使用下标语法修改字典中的指定索引的元素值。如果想要修改字典中指定key的元素的value值,有两种方式:(1)为字典中指定key的元素赋予一个新的value值。(2)调用方法updateValue(value: Value, forKey key: Key) -> Value?。当字典中存在参数forKey指定的ke...

  • 字典的“增”操作(4.x)

    如果想要向字典中添加一个新的指定key的元素,有两种方式:(1)为新的指定的key赋予一个value值。(2)调用方法updateValue(_ value: Value, forKey key: Key) -> Value?。

  • 字典的“删”操作(上)(4.x)

    如果想要删除字典中指定key的元素,有两种方式:(1)将指定key对应的value值设置为nil。(2)调用方法removeValue(forKey key: Key) -> Value?。

  • 字典的“删”操作(中)(4.x)

    如果想要删除字典中指定索引的元素,可以调用方法remove(at index: DictionaryIndex) -> (key: Key, value: Value)。 该方法用于删除字典中参数at指定索引的元素。 该方法的返回值为被删除的元素的key和value组成的元组。

  • 字典的“删”操作(下)(4.x)

    如果想要删除字典中的相关元素,还可以调用其它一些方法。

  • 字典的遍历(上)(4.x)

    如果想要遍历字典,可以通过以下两种方式: (1)把字典元素作为循环变量 (2)把字典元素的索引作为循环变量

  • 字典的遍历(下)(4.x)

    如果需要获得每个元素的序号,可以先调用方法enumerated()返回一个元组序列。其中,元组中的元素为遍历过程中元素的序号和字典中对应的元素值。 如果在遍历字典的过程中不需要完整地访问字典的key-value对,而是只访问字典的所有key或所有value,那么可以通过访问字典的属性keys得到...

  • 字典是值类型(4.x)

    当把字典赋给变量或常量时,赋予的是值的拷贝;当把字典作为实参传递给函数或方法的形参时,传递的也是值的拷贝。因此,字典是值类型。

  • 字典的常见方法(4.x)

    字典的常见方法与数组的常见方法和集合的常见方法是类似的。

  • 字典元素的key的类型必须遵守协议Hashable(4.x)

    字典的本质是带泛型的结构体:struct Dictionary。由字典类型的声明可知,与集合元素的类型相似,字典元素中key的类型也必须遵守Hashable协议,同时字典也使用了哈希表来提高查找元素的效率。所有的基本数据类型都默认遵守了协议Hashable,因此,所有的基本数据类型都可以作为字典元素中key的类型。

  • 流程结构的概述(4.x)

    1996年,计算机科学家证明了这样的事实:任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。 程序流程有三种最基本的控制结构: 1. 顺序结构 2. 选择结构 1)if语句 2)guard语句 3)switch语句 3. 循环结构 1)for-in语句 2)while语句 3)repeat-while语句

  • 顺序结构(4.x)

    顺序结构指的是:程序从上到下顺序地执行代码,中间没有任何判断和跳转,直到程序结束。

  • 选择结构的概述(4.x)

    选择结构指的是:程序根据判断条件的结果选择性地执行部分代码。Swift语言提供了三种实现选择结构的语句: (1)if语句 (2)guard语句 (3)switch语句

  • if语句(上)(4.x)

    如果判断条件对应的布尔表达式为true,则执行条件执行体1对应的代码;如果判断条件对应的布尔表达式为false,则执行条件执行体2对应的代码。执行完条件执行体1或条件执行体2之后,都会继续执行if语句之后的代码。

  • if语句(下)(4.x)

    关于if语句的语法格式的几点说明:(1)判断条件无须用小括号括起来,当然括起来也是可以的。(2)条件执行体必须放在花括号中,即使条件执行体只有一行语句。(3)可以把多个if...else语句链接在一起。(4)else语句并不是必须的。(5)程序从上到下依次执行各个判断条件,因此...

  • guard语句(4.x)

    guard的原意是守护,守卫。在上面的语法格式中,guard就像个守卫一样,如果判断条件对应的布尔表达式为true,则通过guard语句,继续执行guard语句的}之后的语句;如果判断条件对应的布尔表达式为false,则不通过guard语句,转而执行else子句中的控制转移语句。

  • switch语句(上)(4.x)

    先对switch表达式求值,然后依次匹配case值1、case值2、... case值n,如果某个case值被匹配到,就执行对应的case子句;如果所有的case值都没有被匹配到,就执行default子句。switch语句与if语句的使用场景:if语句通常用于简单的选择条件,这些选择条件只有几个可能的结果;switch...

  • switch语句(中)(4.x)

    关于switch语句的语法格式的几点说明: (1)如果多个case值对应相同的case子句,可以将这些case值放在同一个case标签后,各个case值之间用逗号进行分隔。只要有其中一个case值被匹配到,就执行对应的case子句。 (2)不能出现“只有case值而没有对应的case子句”的情况,也不能...

  • switch语句(下)(4.x)

    (3)switch语句必须是完备的,也就是说,case子句必须覆盖所有的情况,否则,在switch语句的最后必须添加default:和default子句,从而处理任何case值都没有被匹配到的情况。(4)执行完case子句或default子句后,会自动终止switch语句,所以不需要在case子句的最后添加break。在其...

  • switch语句的模式匹配(4.x)

    switch语句中的case值支持模式匹配,可以匹配的模式包括: (1)任意值_ (2)枚举 (3)区间 (4)元组 (5)值绑定

  • switch语句的区间匹配(4.x)

    switch语句中的case值可以匹配区间。程序从上到下依次匹配各个case值,因此,要注意各个case值的先后顺序。switch语句中的case值在匹配区间时,可以使用where子句作为附加的判断条件。

  • switch语句的元组匹配(上)(4.x)

    switch语句中的case值可以匹配元组。switch语句中的case值在匹配元组时,元组中的元素可以是任意值_,也可以是一个区间。

  • switch语句的元组匹配(下)(4.x)

    switch语句中的case值在匹配元组时,可以使用where子句作为附加的判断条件。

  • switch语句的值绑定(上)(4.x)

    switch语句中的case值可以匹配值绑定。如果被绑定到的变量或常量可以匹配所有剩下的值,在switch语句的最后无须再添加default:和default子句,因为switch语句已经是完备的了。

  • switch语句的值绑定(下)(4.x)

    switch语句中的case值在匹配值绑定时,可以使用where子句作为附加的判断条件。

  • 循环结构的概述(4.x)

    循环结构指的是:程序根据循环条件反复执行某段代码,直到不满足循环条件为止。Swift语言提供了3种实现循环结构的循环语句: (1)for-in语句 (2)while语句 (3)repeat-while语句

  • for-in语句(上)(4.x)

    for-in语句专门用于遍历范围、字符串、数组、集合和字典等序列类型。for-in语句的语法格式为: for 自定义的常量 in 要遍历的序列 { 循环体 }

  • for-in语句(下)(4.x)

    关于for-in语句的语法格式的几点说明:(1)自定义的常量默认是常量,不能使用关键字let再次对其显式声明。(2)自定义的常量的作用域仅仅存在于循环体内。(3)在循环体内不能对自定义的常量重新赋值。(4)如果循环体内不需要访问自定义的常量,可以将其替代为下划线_。当遍历...

  • while语句(上)(4.x)

    (1)初始化部分:用于设置循环的初始条件,比如循环控制变量的初始值。 (2)循环条件:这是一个布尔表达式。每次循环都要判断该布尔表达式的结果,以决定继续循环还是终止循环。这个布尔表达式中通常包含循环控制变量。 (3)循环体:这是循环操作的主体内容,可以是一条语句,...

  • while语句(下)(4.x)

    关于while语句的语法格式的几点说明:(1)while和左花括号{中间的部分,无须用小括号()括起来,当然括起来也是可以的。(2)应该确保提供终止循环的条件,避免while语句陷入死循环(无限循环),即永远不会终止的循环。(3)循环体必须放在花括号中,即使循环体只有一行语句。与...

  • repeat-while语句(4.x)

    repeat-while语句与while语句的不同之处在于:执行完一次初始化部分之后,先执行循环体,然后再判断循环条件的结果。这样,循环体至少被执行一次。而在while语句中,循环体有可能一次都不被执行。 repeat-while语句与while语句的相同之处在于:都用于第一次迭代开始之前迭代次数未知的循环。

  • 嵌套循环(4.x)

    嵌套循环指的是:各种循环语句相互嵌套组成的循环结构。 嵌套循环不仅可以是两层嵌套,还可以是三层嵌套、四层嵌套......。 不论嵌套层数是多少,都可以把内层循环当成外层循环的循环体来对待。

  • break和continue(4.x)

    在循环语句中,break表示断路,用于结束整个循环;continue表示短路,用于结束整个循环中的当前迭代,继续下一个迭代。在嵌套的循环语句中,break和continue默认作用于当前循环。如果想让break和continue作用于外层循环,可以在外层循环的前面定义一个标签,并在使用break和continue时指定该标签。

  • 函数的概述(4.x)

    函数就是执行特定任务以完成特定功能的一段代码。可以在程序中将某段代码定义成函数,并为函数指定一个函数名,这样,就可以在程序的其它地方通过函数名多次调用该段代码,从而执行特定的任务以完成特定功能了。函数就是个黑匣子,接收输入(参数),然后执行特定任务以完成特定功...

  • 函数的定义和调用(上)(4.x)

    关于函数名的几点说明: (1)每个函数都有一个函数名,用于描述该函数执行的任务。 (2)函数名的命名规则:必须要符合标识符的命名规则,因为函数名属于标识符。 (3)函数名的命名规范: a. “见名知意”,由一个或多个有意义的单词组合而成。计算科学中最难的两件...

  • 函数的定义和调用(中)(4.x)

    关于形参列表的几点说明: (1)形参列表是函数的输入,用于接收零个或多个实际参数。 (2)形参列表中形式参数的语法格式为:形式参数名: 形式参数的数据类型,多个形式参数之间用逗号进行分隔。 (3)形参列表是可有可无的,也就是说,可以指定也可以不指定。 关于返回值...

  • 函数的定义和调用(下)(4.x)

    关于调用函数的几点说明: (1)如果在定义函数时指定了形参列表,在调用函数时必须传入对应的实参(实际参数),把形参列表中各个形参的数据类型替换成对应的实参即可。实参与形参的个数、顺序和类型必须匹配。 (2)如果在定义函数时没有指定返回值的数据类型,在调用函数后不...

  • 函数的多个返回值(上)(4.x)

    如果函数需要有多个返回值,在定义函数时可以将返回值的数据类型声明为元组类型。 如果元组类型的返回值可能是“值缺失的”(nil),可以将返回值的数据类型声明为可选的元组类型。

  • 函数的多个返回值(下)(4.x)

    如果函数需要有多个返回值,在定义函数时可以将返回值的数据类型声明为元组类型。 如果元组类型的返回值可能是“值缺失的”(nil),可以将返回值的数据类型声明为可选的元组类型。

  • 函数的常量形参(4.x)

    函数形参列表中的所有形参都默认是常量,也就是说,都默认使用关键字let进行了声明。因此,在函数体内不能修改形参的值。可以在函数体内将形参的值赋给另一个变量,然后对该变量进行操作。如果两者同名,在函数体内被赋值的变量将覆盖同名的形参。

  • 函数的形参标签(上)(4.x)

    为了清晰地表示形参的作用,可以在定义函数时给形参指定形参标签。 给形参指定形参标签的语法格式为:形参标签 形参: 形参的数据类型。 对于指定了形参标签的形参,在调用函数时在对应实参的前面必须添加“形参标签: ”。

  • 函数的形参标签(下)(4.x)

    如果在定义函数时没有给某些形参指定形参标签,其形参标签的默认值就是其对应的形参。对于没有指定形参标签的形参,在调用函数时在对应实参的前面也必须添加“形参标签: ”(“形参: ”)。如果在调用函数时不想在某些实参前面添加相应的形参标签,可以在定义函数时将相应的形参...

  • 函数形参的默认值(4.x)

    可以在定义函数时为形参列表中的任意形参指定默认值,这样,如果在调用函数时不指定相应的实参,就会使用其相应形参的默认值。 为形参指定默认值的语法格式为:[形参标签] 形参: 形参的数据类型 = 形参的默认值。 建议将所有带默认值的形参放在形参列表的最后面,这样,对于...

  • 函数的个数可变的形参(上)(4.x)

    在定义函数时可以将形参列表中的某个形参定义为个数可变的,这样,在调用函数时就可以将0个或多个实参传给该形参。 个数可变的形参的本质是一个数组。 定义个数可变的形参的语法格式为:[形参标签] 形参: 形参的数据类型...。 print函数就包含个数可变的形参:print(_ items...

  • 函数的个数可变的形参(下)(4.x)

    通常将个数可变的形参声明为形参列表中的最后一个形参。 如果没有将个数可变的形参声明为形参列表中的最后一个形参,并且其后面形参的形参标签是_,可能会产生歧义从而导致编译错误。

  • 函数的In-Out形参(上)(4.x)

    当把函数的实参传递给形参时,有两种传递方式: (1)值传递,也就是传递实参的值的拷贝。在函数体内部,对形参的任何改变都不会影响实参。如果形参的数据类型属于值类型,采用该传递方式。 (2)引用传递,也就是传递实参的引用。在函数体内部,对形参所引用实例的任何改变都会...

  • 函数的In-Out形参(中)(4.x)

    当形参的数据类型属于值类型时,如果想让函数体内部对形参的任何改变都影响实参,可以在该形参的数据类型前面添加关键字inout从而将该形参定义为In-Out形参,同时,在实参前面添加&从而让形参和实参指向内存中的同一个地址,这样,默认为常量的形参变为变量,并且函数体内部对形参的...

  • 函数的In-Out形参(下)(4.x)

    在使用In-Out形参时要注意以下几点: (1)In-Out形参对应的实参只能是&和变量的组合,不能是&和常量或字面量的组合,否则执行完函数体之后无法接收传出的In-Out形参值。 (2)In-Out形参不能有默认值,因为In-Out形参对应的实参是不能被省略的,需要把实参的值传入给In-Out形参...

  • 函数类型(4.x)

    每个函数都有对应的函数类型。 函数类型的语法格式为:形参列表的类型 -> 返回值的类型。 函数类型是数据类型的其中一种,因此,函数类型可以作为:(1)声明变量或常量时的类型(2)函数形参的类型(3)函数返回值的类型

  • 重载函数(4.x)

    对于两个或两个以上函数名相同的函数,如果它们满足以下条件之一,就称之为重载函数。 (1)函数类型不同 (2)形参标签列表不同 如果两个重载函数仅仅是返回值的类型不同,那么在调用时必须明确指定返回值的类型,否则会产生编译错误,因为系统无法确定到底调用哪一个重载函数。

  • 嵌套函数(4.x)

    定义在整个Swift源程序最外层的函数,称为全局函数。 全局函数的作用域是:从函数定义处开始,到整个Swift源程序结束。 定义在另一个函数的函数体内部的函数,称为嵌套函数。 嵌套函数的作用域是:从嵌套函数定义处开始,到被嵌套函数的函数体结束。

  • 闭包的概述(4.x)

    闭包就是封闭的、自包含的代码块。 闭包有三种形式: (1)全局函数 (2)嵌套函数 (3)闭包表达式 闭包表达式就是函数的匿名简化版。所有使用函数的地方几乎都可以替换为对应的闭包表达式。

  • 闭包表达式(上)(4.x)

    闭包表达式就是函数的匿名简化版。 闭包表达式的语法格式为: { (形参列表) -> 返回值的类型 in 执行体(相当于函数体) } 与定义函数的语法格式相比,有以下区别: (1)删掉了关键字func (2)删掉了函数名 (3)在返回值的类型后添加了关键字in (4)...

  • 闭包表达式(下)(4.x)

    因为闭包表达式就是函数的匿名简化版,所以闭包表达式的类型就是对应函数的类型,并且所有使用函数的地方几乎都可以替换为对应的闭包表达式。 闭包表达式可以作为: (1)变量或常量的值 (2)函数的实参 (3)函数的返回值 因为闭包表达式就是函数的匿名简化版,所以可以...

  • 闭包表达式的简化_省略关键字return(4.x)

    如果闭包表达式的执行体只有一行return语句,可以省略关键字return。

  • 闭包表达式的简化_省略形参的类型和返回值的类型(4.x)

    Swift可以根据闭包表达式的上下文推断出闭包表达式中形参的类型和返回值的类型,因此,闭包表达式可以省略: (1)形参的类型和形参列表的()和: (2)->和返回值的类型

  • 闭包表达式的简化_省略形参名(4.x)

    在闭包表达式省略形参的类型和返回值的类型的情况下,闭包表达式还可以省略形参名和关键字in。这样,闭包表达式可以在执行体中通过$0、$1、$2......来引用第1个形参、第2个形参、第3个形参......。Swift对基本数据类型间的比较运算符定义了一种特定于String类型的实现,可以将基本数...

  • 尾随闭包(4.x)

    在调用函数时,如果最后一个实参是闭包表达式,可以将其写在()的外面和后面。这种写法的闭包表达式称为尾随闭包。 尾随闭包主要用于闭包表达式的执行体比较长的情形。 使用尾随闭包时必须去掉形参标签。 如果尾随闭包是参数列表中的唯一实参,可以省略()。

  • 自动闭包(4.x)

    如果把一个表达式放在{ }里,Swift会自动创建一个闭包表达式。该闭包表达式没有任何参数,并且返回值就是该表达式的值。这样的闭包表达式称为自动闭包。Swift会对自动闭包延时求值,也就是说,直到该自动闭包被调用时,其封装的表达式才会被计算。可以使用属性@autoclosure对闭包...

  • 枚举的概述(4.x)

    枚举就是将有限的可能取值一一列举出来,从而只限于从列举出来的范围内取值。例如:一年只有12个月,一年只有4个季节,一周只有7天。 如果一个变量只有几种有限的可能取值,就可以将该变量定义为枚举类型。

  • 定义枚举(4.x)

    每定义一个枚举,就定义了一个全新的类型。 创建枚举实例的语法格式为:枚举名.枚举值。 对于一个已知枚举类型的变量,如果对该变量进行赋值,可以使用简化的语法“.枚举值”创建枚举实例,因为系统会进行类型推断。

  • 枚举值在switch语句中的匹配(4.x)

    switch语句必须是完备的。因此,如果所有的case子句没有覆盖所有的枚举值,必须在switch语句的最后添加default:和default子句。

  • 枚举值的原始值(上)(4.x)

    定义枚举时,可以为枚举值指定原始值。 关于该语法格式的几点说明: (1)所有原始值的数据类型必须是相同的。 (2)原始值必须是唯一的。可以通过枚举值的属性rawValue访问原始值。

  • 枚举值的原始值(下)(4.x)

    当原始值的数据类型是整数类型或字符串类型时,无须对每个枚举值都赋予原始值,Swift会根据以下规则自动对枚举值进行赋值: (1)当原始值的数据类型是整数类型时,如果第一个枚举值没有被赋予原始值,其默认的原始值是0;如果第二个枚举值及其之后的枚举值没有被赋予原始值,Swift...

  • 枚举值的相关值(4.x)

    定义枚举时,可以为每个枚举值都指定多个不同数据类型的相关值。相关值被表示为元组。原始值与相关值的区别:定义枚举后,所有枚举值的原始值就确定了;定义枚举后,仅仅确定了所有枚举值的相关值的数据类型,只有当创建枚举的实例时,该实例的所有相关值才确定下来。在switch语句...

  • 类和结构体的概述(上)(4.x)

    对象是对问题领域中事物的抽象。 对象具有以下特征: (1)世间万物皆对象。问题领域中的概念和实体都可以被抽象为对象。 (2)每个对象都是唯一的。对象的唯一性来自于真实世界中事物的唯一性。 (3)对象具有属性和行为。‘ (4)对象具有状态。状态是指某个瞬间对象的各...

  • 类和结构体的概述(下)(4.x)

    类和结构体的主要区别: (1)类是引用类型,结构体是值类型; (2)结构体不支持继承; (3)结构体不支持析构器; (4)结构体不支持类型转换。绝大部分时候,应该优先考虑使用类而不是结构体。当符合一条或多条以下条件时,可以考虑使用结构体: (1)所要定义的数据结...

  • 结构体的基本用法(4.x)

    每定义一个结构体,就定义了一个全新的类型。 关于该语法格式的几点说明: (1)结构体中的变量或常量被称为属性,结构体中的函数被称为方法。 (2)类、结构体和枚举的命名规则及命名规范是相同的。 通过默认构造器创建结构体的实例的语法格式为:结构体名()。 通过.访问...

  • 类的基本用法(4.x)

    每定义一个类,就定义了一个全新的类型。 关于类的语法格式的几点说明: (1)类中的变量或常量被称为属性,类中的函数被称为方法。 (2)类、结构体和枚举的命名规则及命名规范是相同的。 通过默认构造器创建类的实例的语法格式为:类名()。 通过.访问类的实例的属性,其...

  • 类是引用类型(4.x)

    当把类的实例赋给变量或常量时,赋予的是类的实例的引用;当把类的实例作为实参传给函数或方法的形参时,传递的也是类的实例的引用。因此,类是引用类型。

  • 结构体是值类型(4.x)

    当把结构体的实例赋给变量或常量时,赋予的是结构体的实例的拷贝;当把结构体的实例作为实参传给函数或方法的形参时,传递的也是结构体的实例的拷贝。因此,结构体是值类型。

  • 运算符===和!==(4.x)

    运算符===用于比较两个引用类型的变量或常量是否指向同一个对象,如果指向同一个对象,比较结果为true;如果指向不同的对象,比较结果为false。运算符!==用于比较两个引用类型的变量或常量是否指向不同的对象,如果指向不同的对象,比较结果为true;如果指向同一个对象,比较结果为false。

  • 属性的概述(4.x)

    属性就是类、结构体或枚举中定义的变量或常量。属性分为以下四大类:(1)存储属性(2)计算属性(3)实例属性(4)类型属性对以上四大类属性进行组合,可以进一步将属性划分为以下四种: (1)实例存储属性(实例属性 + 存储属性) (2)实例计算属性(实例属性 + 计...

  • 结构体的实例存储属性(4.x)

    因为结构体是值类型,所以,如果将结构体的实例赋值给常量,该实例的所有实例存储属性都无法被修改,即使有的实例存储属性被声明为变量。

  • 类的实例存储属性(4.x)

    因为类是引用类型,所以,即使将类的实例赋值给常量,该实例的所有被声明为变量的实例存储属性仍然可以被修改,因为该常量始终没有引用其它实例。

  • 结构体和类的懒实例存储属性(上)(4.x)

    对于结构体和类,当实例存储属性是变量时,可以在关键字var前面添加关键字lazy,这样,该实例存储属性就成为懒实例存储属性,也就是说,当第一次用到该实例存储属性时才会计算其初始值并且只计算一次。当实例存储属性是常量时,不能将其声明为懒实例存储属性,因为在实例的初始化完...

  • 结构体和类的懒实例存储属性(中)(4.x)

    懒实例存储属性主要应用于两种场景: (1)在实例构造完成之前,不能访问其它实例属性(即便这些实例属性有默认值),也不能访问self属性或调用其它实例方法。但是,当使用关键字lazy对实例存储属性进行标记之后,就可以访问其它实例属性和self属性并调用其它实例方法了,因为当第...

  • 结构体和类的懒实例存储属性(下)(4.x)

    懒实例存储属性的初始值只被计算一次。

  • 结构体的实例计算属性(上)(4.x)

    关于实例计算属性的语法格式的几点说明: (1)获取实例计算属性的值时,调用getter的执行体;修改实例计算属性的值时,调用setter的执行体。 (2)如果setter没有定义新属性值的名称,系统会提供一个名为newValue的默认名称。

  • 结构体的实例计算属性(下)(4.x)

    (3)如果实例计算属性只有getter而没有setter,该实例计算属性就是只读的,这样,就可以省略关键字get和花括号。 即便实例计算属性是只读的,也必须将其声明为变量,而不能声明为常量。 (4)每次获取实例计算属性的值时,都会调用getter的执行体进行重新计算;每次修改实...

  • 类的实例计算属性(4.x)

    关于实例计算属性的语法格式的几点说明: (1)获取实例计算属性的值时,调用getter的执行体;修改实例计算属性的值时,调用setter的执行体。 (2)如果setter没有定义新属性值的名称,系统会提供一个名为newValue的默认名称。 (3)如果实例计算属性只有getter而没有setter,...

  • 枚举的实例计算属性(4.x)

    关于实例计算属性的语法格式的几点说明: (1)获取实例计算属性的值时,调用getter的执行体;修改实例计算属性的值时,调用setter的执行体。 (2)如果setter没有定义新属性值的名称,系统会提供一个名为newValue的默认名称。 (3)如果实例计算属性只有getter而没有setter,...

  • 结构体的类型存储属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。

  • 类的类型存储属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。

  • 枚举的类型存储属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。

  • 结构体的类型计算属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。类型计算属性的语法格式与实例计算属性的语法格式类似。

  • 类的类型计算属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。 类型计算属性的语法格式与实例计算属性的语法格式类似。 当把类的计算属性声明为类型属性时,如果希望该类的子类重写该类型属性,那么必须使用关键字class代替关键字static。

  • 枚举的类型计算属性(4.x)

    可以在关键字var或let前面添加关键字static,将某个存储属性或计算属性声明为类型属性。 类型计算属性的语法格式与实例计算属性的语法格式类似。

  • 结构体的属性观察器(4.x)

    属性观察器用来观察和响应属性值的变化。当属性初始化之后,每当属性值被修改时(包括新值和当前值完全相同的情况),属性观察器就会被调用。属性观察器可用于:存储属性(不包括懒存储属性)。可以在属性中定义以下两个(或两个之一)属性观察器: (1)willSet:在属性值即将被...

  • 类的属性观察器(4.x)

    属性观察器可用于: (1)存储属性(不包括懒存储属性)。 (2)子类中重写的计算属性。 如果不是子类中重写的计算属性,可以直接在setter中观察和响应值的变化。

  • 枚举的属性观察器(4.x)

    属性观察器用来观察和响应属性值的变化。当属性初始化之后,每当属性值被修改时(包括新值和当前值完全相同的情况),属性观察器就会被调用。属性观察器可用于存储属性(不包括懒存储属性)。可以在属性中定义以下两个(或两个之一)属性观察器: (1)willSet:在属性值即将被修...

  • 方法的概述(4.x)

    方法就是结构体、类或枚举内部的函数。方法分为两种: (1)实例方法 实例方法属于结构体、类和枚举三种类型中某一类型的实例。 (2)类型方法 类型方法属于结构体、类和枚举三种类型中的某一类型本身,而不属于该类型的任何实例。

  • 结构体的实例方法的基本用法(4.x)

    实例方法属于结构体、类和枚举三种类型中某一类型的实例。所以,实例方法只可以被其所属类型的实例所调用,而不可以被所属类型本身所调用。

  • 类的实例方法的基本用法(4.x)

    实例方法属于结构体、类和枚举三种类型中某一类型的实例。所以,实例方法只可以被其所属类型的实例所调用,而不可以被所属类型本身所调用。

  • 枚举的实例方法的基本用法(4.x)

    实例方法属于结构体、类和枚举三种类型中某一类型的实例。所以,实例方法只可以被其所属类型的实例所调用,而不可以被所属类型本身所调用。

  • 结构体实例的self属性(4.x)

    结构体、类或枚举的每个实例都有一个隐式的self属性,用于表示该实例。实例方法之所以可以直接访问其所属类型的所有其它实例属性和实例方法,是因为Swift默认访问的是当前实例的实例属性和实例方法,因此在访问时无须在实例属性和实例方法前添加self.。因为实例方法只能被其所属类...

  • 类实例的self属性(4.x)

    结构体、类或枚举的每个实例都有一个隐式的self属性,用于表示该实例。实例方法之所以可以直接访问其所属类型的所有其它实例属性和实例方法,是因为Swift默认访问的是当前实例的实例属性和实例方法,因此在访问时无须在实例属性和实例方法前添加self.。因为实例方法只能被其所属类...

  • 枚举实例的self属性(4.x)

    结构体、类或枚举的每个实例都有一个隐式的self属性,用于表示该实例。实例方法之所以可以直接访问其所属类型的所有其它实例属性和实例方法,是因为Swift默认访问的是当前实例的实例属性和实例方法,因此在访问时无须在实例属性和实例方法前添加self.。因为实例方法只能被其所属类...

  • 在结构体的实例方法中修改实例属性(4.x)

    结构体和枚举都是值类型。默认情况下,在值类型的实例方法中不能修改实例属性。如果想在值类型的实例方法中修改实例属性,可以在实例方法的关键字func前面添加关键字mutating,这样,当实例方法结束后对实例属性的任何改变都会被写回相应的实例。如果将值类型的实例赋值给一个常量...

  • 在枚举的实例方法中修改实例属性(4.x)

    结构体和枚举都是值类型。默认情况下,在值类型的实例方法中不能修改实例属性。如果想在值类型的实例方法中修改实例属性,可以在实例方法的关键字func前面添加关键字mutating,这样,当实例方法结束后对实例属性的任何改变都会被写回相应的实例。如果将值类型的实例赋值给一个常量...

  • 结构体mutating实例方法中给self赋新实例(4.x)

    可以在结构体或枚举的mutating实例方法中给self属性赋值一个新实例。这样,当该mutating实例方法执行结束后,新实例会替换掉原来的实例。

  • 枚举mutating实例方法中给self赋值新实例(4.x)

    可以在结构体或枚举的mutating实例方法中给self属性赋值一个新实例。这样,当该mutating实例方法执行结束后,新实例会替换掉原来的实例。

  • 结构体的类型方法的基本用法(4.x)

    类型方法属于结构体、类和枚举三种类型中的某一类型本身,而不属于该类型的任何实例。所以,类型方法只可以被其所属的类型通过点语法所调用,而不可以被其所属类型的实例所调用。可以在关键字func前面添加关键字static,将某个方法声明为类型方法。

  • 类的类型方法的基本用法(4.x)

    类型方法属于结构体、类和枚举三种类型中的某一类型本身,而不属于该类型的任何实例。所以,类型方法只可以被其所属的类型通过点语法所调用,而不可以被其所属类型的实例所调用。可以在关键字func前面添加关键字static,将某个方法声明为类型方法。

  • 枚举的类型方法的基本用法(4.x)

    类型方法属于结构体、类和枚举三种类型中的某一类型本身,而不属于该类型的任何实例。所以,类型方法只可以被其所属的类型通过点语法所调用,而不可以被其所属类型的实例所调用。可以在关键字func前面添加关键字static,将某个方法声明为类型方法。

  • 结构体类型的self属性(4.x)

    结构体、类或枚举的类型方法都有一个隐式的self属性,用于表示该类型。类型方法之所以可以直接访问其所属类型的所有其它类型属性和类型方法,是因为Swift默认访问的是该类型的类型属性和类型方法,因此在访问时无须在类型属性和类型方法前添加self.。因为类型方法只能被其所属的类...

  • 类类型的self属性(4.x)

    结构体、类或枚举的类型方法都有一个隐式的self属性,用于表示该类型。类型方法之所以可以直接访问其所属类型的所有其它类型属性和类型方法,是因为Swift默认访问的是该类型的类型属性和类型方法,因此在访问时无须在类型属性和类型方法前添加self.。因为类型方法只能被其所属的类...

  • 枚举类型的self属性(4.x)

    结构体、类或枚举的类型方法都有一个隐式的self属性,用于表示该类型。类型方法之所以可以直接访问其所属类型的所有其它类型属性和类型方法,是因为Swift默认访问的是该类型的类型属性和类型方法,因此在访问时无须在类型属性和类型方法前添加self.。因为类型方法只能被其所属的类...

  • 下标的概述(4.x)

    访问数组的元素的方式为:数组名[索引];访问字典的value的方式为:字典名[key]。这两种访问方式都是下标的用法。下标可以作为访问集合、列表或序列中元素的简化方式,通过下标及索引来获取和修改元素的值,而无须单独调用方法。结构体、类和枚举都支持下标。

  • 结构体的下标的基本用法(4.x)

    关于下标的语法格式的几点说明:(1)获取下标值时,调用getter的执行体;修改下标值时,调用setter的执行体。(2)如果下标的setter没有定义新下标值的名称,系统会提供一个名为newValue的默认名称。(3)如果下标只有getter而没有setter,该下标就是只读的。只读下标可以省略关键字get和花括号。

  • 类的下标的基本用法(4.x)

    关于下标的语法格式的几点说明:(1)获取下标值时,调用getter的执行体;修改下标值时,调用setter的执行体。(2)如果下标的setter没有定义新下标值的名称,系统会提供一个名为newValue的默认名称。(3)如果下标只有getter而没有setter,该下标就是只读的。只读下标可以省略关键字get和花括号。

  • 枚举的下标的基本用法(4.x)

    关于下标的语法格式的几点说明:(1)获取下标值时,调用getter的执行体;修改下标值时,调用setter的执行体。(2)如果下标的setter没有定义新下标值的名称,系统会提供一个名为newValue的默认名称。(3)如果下标只有getter而没有setter,该下标就是只读的。只读下标可以省略关键字get和花括号。

  • 继承的概述(4.x)

    继承是面向对象的三大特征之一,也是实现软件复用的重要手段。只有类支持继承。当类A继承类B时,类A被称为子类,类B被称为父类。子类会继承父类的属性、方法和下标,同时,子类还可以添加父类中没有的属性、方法和下标;子类也可以重写继承自父类的属性、方法和下标,通过提供自定...

  • 子类继承父类的属性、方法和下标(4.x)

    子类会继承父类的属性、方法和下标,因此,可以通过子类的实例访问父类的实例属性、实例方法和下标,也可以通过子类类型访问父类的类型属性和类型方法。子类还可以添加父类中没有的属性、方法和下标。

  • 子类重写父类的属性(4.x)

    子类可以重写继承自父类的属性,通过提供自定义的实现来优化和改变它们的行为。子类重写父类的属性时,必须在子类中被重写的属性前添加关键字override。通过添加关键字override,可以让编译器检查父类中是否存在要被重写的属性。子类重写父类的属性后,通过子类的实例只能访问子类...

  • 子类重写父类的下标(4.x)

    子类可以重写继承自父类的下标,通过提供自定义的实现来优化和改变它们的行为。子类重写父类的下标时,必须在子类中被重写的下标前添加关键字override。通过添加关键字override,可以让编译器检查父类中是否存在要被重写的下标。子类重写父类的下标后,通过子类的实例只能调用子类...

  • 子类重写父类的方法(4.x)

    子类可以重写继承自父类的方法,通过提供自定义的实现来优化和改变它们的行为。子类重写父类的方法时,必须在子类中被重写的方法前添加关键字override。通过添加关键字override,可以让编译器检查父类中是否存在要被重写的方法。子类重写父类的实例方法后,通过子类的实例只能调用...

  • 禁止继承和禁止重写(4.x)

    可以使用关键字final修饰类,以禁止该类被其它类继承。可以使用关键字final修饰类中的属性、方法或下标,以禁止相应的属性、方法或下标被子类重写。

  • 构造器的概述(4.x)

    构造就是将结构体、类或枚举的实例准备好以便使用的过程。这个过程包括: (1)为实例中的每个存储属性设置初始值。 (2)执行必要的准备和初始化工作。 实例的构造过程是通过构造器来完成的。可以在结构体、类或枚举中提供自定义的构造器,从而自定义实例的构造过程。

  • 结构体的自定义构造器的基本用法(4.x)

    构造器就是名为init的特殊方法,其语法格式为:init([形参列表]) { 构造体}与普通的方法相比,构造器没有关键字func和返回类型。当通过“类型名([构造器的实参列表])”创建某个类型的实例时,系统会自动调用相应的自定义构造器,以完成实例的构造过程。

  • 类的自定义构造器的基本用法(4.x)

    构造器就是名为init的特殊方法,其语法格式为: init([形参列表]) { 构造体 } 与普通的方法相比,构造器没有关键字func和返回类型。 当通过“类型名([构造器的实参列表])”创建某个类型的实例时,系统会自动调用相应的自定义构造器,以完成实例的构造过程。

  • 枚举的自定义构造器的基本用法(4.x)

    构造器就是名为init的特殊方法,其语法格式为: init([形参列表]) { 构造体 } 与普通的方法相比,构造器没有关键字func和返回类型。 当通过“类型名([构造器的实参列表])”创建某个类型的实例时,系统会自动调用相应的自定义构造器,以完成实例的构造过程。

  • 结构体的自定义构造器的重载(4.x)

    可以在结构体、类或枚举中定义多个重载的自定义构造器,它们必须满足以下条件之一: (1)形参列表的类型不同 (2)形参标签列表不同

  • 类的自定义构造器的重载(4.x)

    可以在结构体、类或枚举中定义多个重载的自定义构造器,它们必须满足以下条件之一: (1)形参列表的类型不同 (2)形参标签列表不同

  • 枚举的自定义构造器的重载(4.x)

    可以在结构体、类或枚举中定义多个重载的自定义构造器,它们必须满足以下条件之一: (1)形参列表的类型不同 (2)形参标签列表不同

  • 结构体的自定义构造器的委托(4.x)

    对于值类型(结构体和枚举)的多个重载的自定义构造器,可以在其中一个自定义构造器中通过self.init调用其它重载的构造器,从而把一部分功能委托给其它重载的构造器,这被称之为构造器委托。构造器委托可以避免多个自定义构造器中存在重复代码。

  • 枚举的自定义构造器的委托(4.x)

    对于值类型(结构体和枚举)的多个重载的自定义构造器,可以在其中一个自定义构造器中通过self.init调用其它重载的构造器,从而把一部分功能委托给其它重载的构造器,这被称之为构造器委托。构造器委托可以避免多个自定义构造器中存在重复代码。

  • 结构体的默认构造器(上)(4.x)

    默认构造器有两种: (1)默认的无参构造器,适用于结构体和类。 (2)默认的逐一成员构造器,只适用于结构体。如果不存在任何自定义构造器,并且所有的实例存储属性都有默认值,系统会为结构体或类提供默认的无参构造器。如果系统为结构体或类提供了默认的无参构造器,并且创...

  • 结构体的默认构造器(中)(4.x)

    只要不存在任何自定义构造器,系统就会为结构体提供默认的逐一成员构造器。如果系统为结构体提供了默认的逐一成员构造器,并且创建结构体的实例时为所有的存储属性都指定了实参值,系统就会自动调用默认的逐一成员构造器。

  • 结构体的默认构造器(下)(4.x)

    如果希望既能通过默认的无参构造器和默认的逐一成员构造器来构造结构体的实例,又能通过自定义构造器来构造结构体的实例,可以把自定义构造器放在扩展中。

  • 类的默认构造器(4.x)

    默认构造器有两种: (1)默认的无参构造器,适用于结构体和类。 (2)默认的逐一成员构造器,只适用于结构体。如果不存在任何自定义构造器,并且所有的实例存储属性都有默认值,系统会为结构体或类提供默认的无参构造器。如果系统为结构体或类提供了默认的无参构造器,并且创...

  • 设置结构体的存储属性的初始值(上)(4.x)

    在构造完成结构体或类的实例之前,所有的实例存储属性都必须有初始值。 为实例存储属性设置初始值的方式有两种: (1)在声明实例存储属性时为其设置默认值。 (2)在构造器(包括自定义构造器和默认构造器)中为实例存储属性设置初始值。 注意:这两种方式都不会调用实例存...

  • 设置结构体的存储属性的初始值(中)(4.x)

    对于某个实例存储属性,如果既在声明时为其设置了默认值,又在构造器中为其设置了初始值,后者会覆盖前者。因此,如果某个实例存储属性是常量,要么在声明时为其设置默认值,要么在构造器中为其设置初始值,不能同时在声明时和在构造器中为其设置初始值。否则,当后者覆盖前者时,相...

  • 设置结构体的存储属性的初始值(下)(4.x)

    对于类型存储属性,必须在声明时为其设置默认值,而不能在构造器中为其设置初始值,因为构造器只适用于实例而不适用于类型。如果某个可选类型的存储属性是变量,系统自动将其默认值设置为nil。

  • 设置类的存储属性的初始值(4.x)

    为实例存储属性设置初始值的方式有两种: (1)在声明实例存储属性时为其设置默认值。 (2)在构造器(包括自定义构造器和默认构造器)中为实例存储属性设置初始值。 注意:这两种方式都不会调用实例存储属性的属性观察器。对于某个实例存储属性,如果既在声明时为其设置了默...

  • 设置枚举的存储属性的初始值(4.x)

    枚举中不能定义实例存储属性。对于类型存储属性,必须在声明时为其设置默认值,而不能在构造器中为其设置初始值,因为构造器只适用于实例而不适用于类型。如果某个可选类型的存储属性是变量,系统自动将其默认值设置为nil。

  • 全局函数或闭包为结构体的存储属性设置默认值(上)(4.x)

    如果存储属性的默认值需要一些客户化操作,可以使用全局函数或闭包表达式为存储属性设置默认值。使用闭包表达式为存储属性设置默认值时, (1)如果闭包表达式的右花括号}后面紧跟一对圆括号(),表示将闭包表达式的返回值赋值给该存储属性。 (2)如果闭包表达式的右花括号}后面...

  • 全局函数或闭包为结构体的存储属性设置默认值(4.x)

    使用闭包表达式为实例存储属性设置默认值时,在闭包表达式执行期间,实例的剩余部分还没有被构造完成,因此,在闭包表达式内不能访问其它实例属性(即便这些实例属性有默认值),也不能访问self属性或调用其它实例方法。

  • 析构的概述(4.x)

    系统通过自动引用计数(ARC)来处理类实例的内存管理。系统会自动销毁不再需要的类实例以释放内存。因此,当类实例被销毁时通常不需要手动地执行清理工作。当使用自己创建的资源时,可能需要执行一些额外的清理工作,例如,如果创建了一个自定义的类来打开一个文件并写入一些数据,...

  • 析构器(4.x)

    在类实例被销毁之前系统自动调用析构器,不能在程序中手动调用析构器。析构器的语法格式为:deinit { }。析构器没有参数,没有返回值,所以析构器不能重载。每个类中最多只能有一个析构器。在系统调用析构器时,类实例还没有被销毁,因此可以在析构器中访问实例存储属性或调用实...

  • 可选链的概述(4.x)

    所谓可选链,就是多次连续访问和调用属性、方法或下标的过程,并且所有的访问者和调用者都是可选类型,这样,所有的访问和调用就可以被链接在一起形成一个可选链。如果可选链上所有的访问者和调用者都不为nil,可选链访问和调用成功;如果可选链上存在某个访问者或调用者为nil,可选...

  • 通过可选链访问属性(4.x)

    可以通过可选链访问属性(获取和修改属性的值)。如果运算符=左边的可选链访问失败,Swift不会对运算符=右边进行计算。当可选链访问和调用成功时,如果最后一次访问或调用的返回值不是可选类型,Swift会将该返回值包装成可选类型以作为可选链的最终返回值类型。

  • 使用可选链调用方法(4.x)

    可以通过可选链调用方法。当可选链访问和调用成功时,如果最后一次访问或调用的返回值不是可选类型,Swift会将该返回值包装成可选类型以作为可选链的最终返回值类型。

  • 类型转换的概述(4.x)

    对象对应的变量或常量有两种类型:(1)编译时类型 (2)运行时类型。变量或常量的编译时类型就是声明该变量或常量时的类型。在编译期间编译器只认变量或常量的编译时类型。变量或常量的运行时类型就是运行时赋值给该变量或常量的对象的实际类型。

  • 使用运算符is进行类型检查(4.x)

    运算符is可以用于检查变量或常量的运行时类型是否是指定的子类类型,其语法格式为:变量或常量 is 指定的子类类型。

  • 使用运算符as进行类型转换(4.x)

    可以使用运算符as将变量或常量的编译时类型向下转型为指定的子类类型,其语法格式为:变量或常量 as? 指定的子类类型,或者:变量或常量 as! 指定的子类类型。当不确定向下转型是否会成功时,使用运算符as?。如果向下转型成功,返回指定类型的可选值;如果向下转型失败,返回nil...

  • 扩展的概述(4.x)

    扩展就是为某个已有的结构体、类、枚举或协议类型添加新功能。即使无法获取某个已有类型的源代码,也可以使用扩展为该类型添加新功能。扩展只可以为某个已有类型添加新功能,而不可以重写已有的功能。如果使用扩展为某个已有类型添加新功能,新功能对该类型的所有已有实例都是可用的...

  • 使用扩展添加属性(4.x)

    可以使用扩展为某个已有的结构体、类或枚举类型添加类型存储属性和计算属性,但是不可以添加实例存储属性。

  • 使用扩展添加方法(4.x)

    可以使用扩展为某个已有的结构体、类或枚举类型添加实例方法和类型方法。

  • 使用扩展添加下标(4.x)

    可以使用扩展为某个已有的结构体、类或枚举类型添加下标。

  • 使用扩展添加嵌套类型(4.x)

    可以使用扩展为某个已有的结构体、类或枚举类型添加嵌套类型。

  • 使用扩展添加构造器(4.x)

    可以使用扩展为某个已有的结构体、类或枚举类型添加构造器。只可以使用扩展为某个已有的类类型添加便利构造器,不可以添加指定构造器或析构器。

  • 协议的概述

    Swift中的协议相当于其它编程语言中的接口。协议定义了属性、方法、下标和构造器等必须满足特定要求的规范。协议并不提供这些要求的具体实现,而是仅仅描述这些实现需要遵守的规范。结构体、类和枚举类型都可以为某个协议定义的属性要求、方法要求、下标要求和构造器要求等提供具体实...

  • 协议的属性要求

    在协议的定义中可以规定其遵守者必须提供指定要求的属性。协议的属性要求包括:a. 实例属性还是类型属性;b. 只读的还是可读写的。协议的属性要求不包括:存储属性还是计算属性。

  • 协议的方法要求

    在协议的定义中可以规定其遵守者必须提供指定要求的方法。与具体的方法实现相比,去掉了其花括号和方法体,并且不能为参数设置默认值。

  • 协议的下标要求

    在协议的定义中可以规定其遵守者必须提供指定要求的下标。如果要求某个下标是可读写的,在下标值的数据类型后添加{ get set };如果要求某个下标是只读的,在下标值的数据类型后添加{ get }。

  • 协议的构造器要求

    在协议的定义中可以规定其遵守者必须提供指定要求的构造器。与具体的构造器实现相比,去掉了其花括号和方法体,并且不能为参数设置默认值。

  • 百钱买百鸡

    用100文钱买100只鸡,其中公鸡5文钱1只,母鸡3文钱1只,小鸡1文钱3只。问:公鸡、母鸡和小鸡各买了几只?

  • 猴子吃桃

    猴子第一天摘下若干个桃子,当即吃了一半,还不过瘾,又多吃了一个。第二天早上又将第一天剩下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半后又多吃一个。到第10天早上想再吃时,发现只剩下一个桃子了。求猴子第一天共摘了多少个桃子。

  • 水仙花数

    如果一个三位数等于它的三个数字的立方和,那么该三位数称为水仙花数。求出所有的水仙花数。

  • 最大公约数和最小公倍数

    两个整数a和b的公约数里最大的那一个叫做它们的最大公约数,记为[a, b];两个整数a和b的公倍数里最小的那一个叫做它们的最小公倍数,记为(a, b)。例如:[12, 15] = 3,(12, 15) = 60。[20, 35] = 5,(20, 35) = 140。求两个整数的最大公约数和最小公倍数。

  • 杨辉三角

    打印杨辉三角的图形

  • 汉诺塔

    有一个梵塔叫汉诺塔,汉诺塔上有三根柱子A、B和C,柱子A上有若干个圆盘,所有圆盘大小不等,且小的在上大的在下。将柱子A上的所有圆盘借助柱子B移动到柱子C上,移动的过程中每次只能移动一个圆盘,移动后仍然是小的在上大的在下。求所有圆盘的移动过程。

  • 角谷猜想

    日本的角谷提出了一个猜想,猜想的内容是:对于任意的自然数,反复进行如下运算:(1)若为奇数,则乘以3后加1;(2)若为偶数,则除以2。总可以得到运算结果1。到目前为止,既不能证明角谷猜想是正确的,也不能举出反例说明角谷猜想是错误的。对于给定的自然数,验证以上角谷猜想。

  • 自守数

    如果某个自然数是其平方的尾部,那么该自然数称为自守数。例如:25 x 25 = 625,25是625的尾部,所以25是自守数。76 x 76 = 5776,76是5776的尾部,所以76是自守数。求出指定自然数区间的所有自守数。

  • 舍罕王赏麦

    据说印度的舍罕王打算重赏一个宰相,问他有何要求,这位宰相说:“陛下,请您在这张棋盘的第一个格内赏给我一粒麦子,在第二个格内赏给我两粒麦子,在第三个格内赏给我四粒麦子,照这样每一格内都比前一格多一倍,把这棋盘的64个格都放满就行啦!”。舍罕王听后,认为这区区赏金微不...

  • 约瑟夫环

    约瑟夫环问题是约瑟夫提出的这样一个问题:编号分别为1, 2, ......, n的n个人围成环状,从编号为k的人开始报数,报到数m时对应的人退出环,下一个人重新报数,一直循环直到所有人都退出环。求最后一个退出环者和第p个退出环者的编号。

  • 兔子繁殖

    有一对刚出生的雌雄兔子,从第3个月起每个月都会生一对雌雄兔子,所有新出生的一对雌雄兔子也都会从第3个月起生一对雌雄兔子。如果所有兔子都不死,求第n个月共有多少对兔子。

  • 寻找假币

    有n枚外观完全相同的硬币,其中有一枚重量较轻的假币,如何通过一架天平找出假币。

  • 回文数

    对于某个自然数,如果从左到右读与从右到左读都是一样的,那么该自然数就被称为回文数。例如:1221, 从左到右读与从右到左读都是1221,所以1221是回文数;12321,从左到右读与从右到左读都是12321,所以12321是回文数;1234,从左到右读是1234,从右到左读是4321,所以1234不是回文...

  • 质数(素数)

    对于某个大于1的自然数,如果该自然数不能被1和它本身之外的所有自然数整除,那么该自然数就被称为质数或素数。例如:自然数5不能被1和5之外的所有自然数整除,所以5是质数。自然数8除了可以被1和8整除之外,还可以被2和4整除,所以8不是质数。判断一个给定的自然数是否是质数。

  • 哥德巴赫猜想

    数学家哥德巴赫提出了著名的猜想:任意大于2的偶数都可以分解为两个质数的和。至今,既不能证明哥德巴赫猜想是正确的,也不能找到反例说明它是错误的。判断一个给定的大于2的偶数是否符合哥德巴赫猜想。

  • 阶乘及阶乘和数

    1. 求自然数n的阶乘。2. 如果一个自然数等于它各位数字的阶乘之和,那么该自然数被称为阶乘和数。求所有三位阶乘和数。

  • 尾数前移

    求性质如下的最小自然数n,它的尾数(最后一位数字)是6,把尾数移到其余数字前面,所得数是原数n的4倍。例如:自然数153846的尾数是6,把6移到其它数字前面,所得数615384是原数153846的4倍。

  • 数制转换

    1. 把一个十进制的正整数转换为d(2 ≤d ≤ 16)进制数。2. 把一个d(2 ≤d ≤ 16)进制的正整数转换为十进制数。

  • 数字魔术

    魔术师请一位观众随意想一个三位数abc(a是百位数,b是十位数,c是个位数),然后让这位观众记下另外五个三位数:acb、bac、bca、cab、cba,并计算出这5个三位数的和。如果这位观众的计算结果是正确的,只要把计算结果告诉魔术师,魔术师就能破解这位观众随意想的三位数abc。

  • 鸡兔同笼

    有若干只鸡和兔在同一个笼子里,从上面数共有h个头,从下面数共有f只脚,求笼子里鸡和兔的只数。

  • 谁家孩子跑得最慢

    张家、王家和李家各有三个孩子。一天,三家的九个孩子在一起比赛跑步,规定:跑第一名得9分,跑第二名得8分,跑第三名得7分,...,跑第九名得1分。比赛结果如下:1. 所有孩子的名次没有并列的。2. 各家三个孩子的总分相同。3. 第一名是李家的孩子,第二名是王家的孩子。4. 各家三...

  • 梅森尼数

    形如2n - 1的质数称为梅森尼数。求出指数n小于20的所有梅森尼数。

  • 个人所得税

    个人所得税的起征点是3500元,并按照七级超额累进税率进行计算。月收入扣除3500元后:1. 不超过1500元的部分,税率为3%;2. 超过1500元不超过4500元的部分,税率为10%;3. 超过4500元不超过9000元的部分,税率为20%;4. 超过9000元不超过35000元的部分,税率为25%;5. 超过35000...

  • 勾股数

    满足x2 + y2 = z2的正整数解x、y和z称为一组勾股数。求指定区间内的所有勾股数。

  • 分数化小数

    将一个给定的分数转化为对应的小数。如果转换后的小数存在循环节,要将循环节用小括号括起来,并计算输出循环节的位数。例如:1 / 64 = 0.015625;45 / 56 = 0.803(571428),循环节共有6位;17 / 3 = 5.(6),循环节共有1位。

  • 求解分数不等式

    对于指定的n,求解下列关于正整数m的分数不等式:n < 1 + 1 / 2 + 1 / 3 + ...... + 1 / m < n + 1

  • 不重复的三位数

    统计0~9这10个数字可以组成多少个不重复的三位数。

  • 谁在说谎

    张三说李四在说谎,李四说王五在说谎,王五说张三和李四都在说谎。这三人中到底谁说的是真话,谁说的是假话?

  • 谁是小偷

    公安人员审问甲乙丙丁四名小偷嫌疑犯。甲说:“乙没有偷,是丁偷的”;乙说:“我没有偷,是丙偷的”;丙说:“甲没有偷,是乙偷的”;丁说:“我没有偷”。已知这四人中仅有一名是小偷,并且这四个人中每人要么说的是实话,要么说的总是假话。根据这四个人的回答判断谁是小偷。

加载中
所属章节 资料名称 文件大小 下载
相关资料推荐

暂时还没有学习资料~

综合评分

0人评价

好于0%的课程

暂无

课程与描述相符 5 非常满意

老师的讲解表达 5 非常满意

老师的答疑服务 5 非常满意

全部

好评 0

中评 0

差评 0

加载中
没有了哦~
你可能还感兴趣的课程

讲师介绍

张荣超

张荣超

好评率:100%

曾就职于联想、HTC、阿里巴巴,担任高级软件开发工程师、Team Leader、技术主管、高级技术培训讲师。丰富的Python、Swift、Kotlin开发及培训经验。

357151人学习过

订阅专栏更多

推荐图书

7日学霸榜 有357151人与你一起学习

课程介绍

课程大纲

学习资料

学员评价

¥398

课程评价

发表客观评价,最高可得35学分(会员可得70学分)

Swift全面深入详解视频教程

该课程已有 人评价

课程与描述相符

老师的讲解表达

老师的答疑服务

匿名

在线
客服
APP
下载

下载Android客户端

下载iphone 客户端

返回
顶部