Swift - 快速指南

---

斯威夫特 - 概述

Swift 4 是苹果公司为 iOS 和 OS X 开发而开发的一种新的编程语言。Swift 4 采用了 C 和 Objective-C 的优点，不受 C 兼容性的限制。

• Swift 4 使用安全的编程模式。

• Swift 4 提供现代编程功能。

• Swift 4 提供类似 Objective-C 的语法。

• Swift 4 是编写 iOS 和 OS X 应用程序的绝佳方式。

• Swift 4 提供对现有 Cocoa 框架的无缝访问。

• Swift 4 统一了该语言的过程部分和面向对象部分。

• Swift 4 不需要单独的库导入来支持输入/输出或字符串处理等功能。

Swift 4 使用与 Mac OS 和 iOS 上现有 Obj-C 系统相同的运行时，这使得 Swift 4 程序可以在许多现有的 iOS 6 和 OS X 10.8 平台上运行。

Swift 4 附带了 Playground 功能，Swift 4 程序员可以编写代码并执行它以立即查看结果。

Swift 的第一个公开版本于 2010 年发布。Chris Lattner花了近 14 年的时间才提出第一个正式版本，后来得到了许多其他贡献者的支持。Swift 4 已包含在 Xcode 6 beta 中。

Swift 设计者从各种其他流行语言（例如 Objective-C、Rust、Haskell、Ruby、Python、C# 和 CLU）中汲取了灵感。

Swift - 环境

本地环境设置

Swift 4 提供了一个用于学习目的的 Playground 平台，我们将设置相同的平台。您需要 xCode 软件才能在 Playground 中开始 Swift 4 编码。一旦您熟悉了 Swift 4 的概念，您就可以使用 xCode IDE 进行 iOS/OS x 应用程序开发。

首先，我们认为您已经在 Apple Developer 网站上拥有一个帐户。登录后，请访问以下链接 - Apple 开发人员下载

这将列出一些可用的软件，如下所示 -

现在选择 xCode 并通过单击光盘映像附近的给定链接来下载它。下载 dmg 文件后，只需双击它并按照给定的说明进行安装即可。最后，按照给定的说明操作，并将 xCode 图标放入应用程序文件夹中。

现在你的机器上已经安装了 xCode。接下来，从应用程序文件夹中打开 Xcode，并在接受条款和条件后继续。如果一切正常，您将看到以下屏幕 -

选择开始使用 Playground选项，输入 Playground 的名称，然后选择 iOS 作为平台。最后，您将获得 Playground 窗口，如下所示 -

以下是取自默认 Swift 4 Playground 窗口的代码。

import UIKit
var str = "Hello, playground"

如果您为 OS X 程序创建相同的程序，那么它将包含 import Cocoa，并且该程序将如下所示 -

import Cocoa
var str = "Hello, playground"

当上面的程序被加载时，它应该在 Playground 结果区域（右侧）显示以下结果。

Hello, playground

恭喜，您已准备好 Swift 4 编程环境，并且可以继续学习“Tutorials Point”。

Swift - 基本语法

我们在搭建环境时已经看到了一段 Swift 4 程序。让我们再次从下面的Hello, World! 开始吧！为 OS X Playground 创建的程序，其中包括导入 Cocoa，如下所示 -

/* My first program in Swift 4 */
var myString = "Hello, World!"

print(myString)

如果您为 iOS Playground 创建相同的程序，那么它将包含import UIKit并且该程序将如下所示 -

import UIKit
var myString = "Hello, World!"
print(myString)

当我们使用适当的 Playground 运行上述程序时，我们将得到以下结果 -

Hello, World!

现在让我们看看 Swift 4 程序的基本结构，以便您轻松理解 Swift 4 编程语言的基本构建块。

在 Swift 4 中导入

您可以使用import语句将任何 Objective-C 框架（或 C 库）直接导入到您的 Swift 4 程序中。例如，上面的import cocoa语句使得构成所有 OS X 开发层的所有 Cocoa 库、API 和运行时都可以在 Swift 4 中使用。

Cocoa 是用 Objective-C 实现的，Objective-C 是 C 的超集，因此很容易将 C 甚至 C++ 混合到 Swift 4 应用程序中。

Swift 4 中的令牌

Swift 4 程序由各种标记组成，标记可以是关键字、标识符、常量、字符串文字或符号。例如，以下 Swift 4 语句包含三个标记 -

print("test!")
The individual tokens are:
print("test!")

评论

注释就像 Swift 4 程序中的帮助文本。它们被编译器忽略。多行注释以 /* 开头并以字符 */ 结尾，如下所示 -

/* My first program in Swift 4 */

多行注释可以嵌套在 Swift 4 中。以下是 Swift 4 中的有效注释 -

/* My first program in Swift 4 is Hello, World!
/* Where as second program is Hello, Swift 4! */ */

单行注释在注释开头使用 // 编写。

// My first program in Swift 4

分号

Swift 4 不要求您在代码中的每个语句后键入分号 (;)，尽管它是可选的；如果您使用分号，那么编译器不会抱怨它。

但是，如果在同一行中使用多个语句，则需要使用分号作为分隔符，否则编译器将引发语法错误。你可以写上面的Hello, World! 程序如下 -

/* My first program in Swift 4 */
var myString = "Hello, World!"; print(myString)

身份标识

Swift 4 标识符是用于标识变量、函数或任何其他用户定义项的名称。标识符以字母 A 到 Z 或 a 到 z 或下划线 _ 开头，后跟零个或多个字母、下划线和数字（0 到 9）。

Swift 4 不允许在标识符中使用特殊字符，例如 @、$ 和 %。Swift 4 是一种区分大小写的编程语言。因此，Manpower 和 manpower 在 Swift 4 中是两个不同的标识符。以下是可接受的标识符的一些示例 -

Azad        zara   abc   move_name   a_123
myname50    _temp  j     a23b9       retVal

要使用保留字作为标识符，您需要在其前后添加反引号 (`)。例如，class不是有效的标识符，但 ` class`是有效的。

关键词

以下关键字在 Swift 4 中被保留。这些保留字不能用作常量或变量或任何其他标识符名称，除非它们用反引号转义 -

声明中使用的关键字

语句中使用的关键字

表达式和类型中使用的关键字

在特定上下文中使用的关键字

空格

仅包含空格（可能带有注释）的行称为空行，Swift 4 编译器完全忽略它。

空白是 Swift 4 中用来描述空白、制表符、换行符和注释的术语。空格将语句的一部分与另一部分分隔开，并使编译器能够识别语句中的一个元素（例如 int）结束以及下一个元素开始的位置。因此，在以下声明中 -

var age

var和age之间必须至少有一个空白字符（通常是空格），以便编译器能够区分它们。另一方面，在以下声明中 -

int fruit = apples + oranges   //get the total fruits

水果和 = 之间或 = 和苹果之间不需要空格字符，尽管您可以自由地添加一些空格字符以获得更好的可读性。

运算符两侧的空间应该相等，例如。

int fruit = apples +oranges    //is a wrong statement
int fruit = apples + oranges   //is a Correct statement

文字

文字是整数、浮点数或字符串类型值的源代码表示形式。以下是文字示例 -

92               // Integer literal
4.24159          // Floating-point literal
"Hello, World!"  // String literal

在 Swift 中打印

要在 swift 中打印任何内容，我们有“print”关键字。

打印具有三种不同的属性。

项目– 要打印的项目

分隔符– 项目之间的分隔符

终止符– 行结束的值，让我们看一个示例和语法。

print("Items to print", separator: "Value " , terminator: "Value")
// E.g. of print statement.

print("Value one")
// prints "Value one \n" Adds, \n as terminator and " " as separator by
default.

print("Value one","Value two", separator: " Next Value" , terminator: " End")
//prints "Value one Next Value Value two End"

在上面的代码中，第一个打印语句默认添加 \n ，换行符 Feed 作为终止符，而在第二个打印语句中，我们给出了“ End ”作为终止符，因此它将打印“ End ”而不是 \n 。

我们可以根据我们的要求提供定制分隔符和终止符。

Swift - 数据类型

使用任何编程语言进行编程时，都需要使用不同类型的变量来存储信息。变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间。

您可能喜欢存储各种数据类型的信息，如字符串、字符、宽字符、整数、浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定保留的内容可以存储记忆。

内置数据类型

Swift 4 为程序员提供了丰富的内置数据类型以及用户定义的数据类型。声明变量时最常见的是以下类型的基本数据类型 -

• Int 或 UInt - 用于整数。更具体地说，您可以使用 Int32、Int64 定义 32 或 64 位有符号整数，而使用 UInt32 或 UInt64 定义 32 或 64 位无符号整数变量。例如，42 和-23。

• Float - 用于表示 32 位浮点数和小数点较小的数字。例如，3.14159、0.1 和 -273.158。

• Double - 用于表示 64 位浮点数，并在浮点值必须非常大时使用。例如，3.14159、0.1 和 -273.158。

• Bool - 这表示一个布尔值，可以是 true 也可以是 false。

• 字符串- 这是字符的有序集合。例如，“你好，世界！”

• 字符- 这是一个单字符字符串文字。例如，“C”

• 可选- 这表示可以保存值或不保存值的变量。

• 元组- 用于将多个值分组到单个复合值中。

我们在这里列出了与整数类型相关的一些要点 -

• 在 32 位平台上，Int 的大小与 Int32 相同。

• 在 64 位平台上，Int 的大小与 Int64 相同。

• 在 32 位平台上，UInt 的大小与 UInt32 相同。

• 在 64 位平台上，UInt 的大小与 UInt64 相同。

• Int8、Int16、Int32、Int64 可用于表示 8 位、16 位、32 位和 64 位形式的有符号整数。

• UInt8、UInt16、UInt32 和 UInt64 可用于表示 8 位、16 位、32 位和 64 位形式的无符号整数。

约束值

下表显示了变量类型、在内存中存储该值需要多少内存以及该类型变量可以存储的最大值和最小值是多少。

类型别名

您可以使用typealias为现有类型创建新名称。以下是使用 typealias 定义新类型的简单语法 -

typealias newname = type

例如，以下行指示编译器Feet是Int的另一个名称-

typealias Feet = Int

现在，以下声明是完全合法的，并创建一个名为距离的整数变量 -

typealias Feet = Int
var distance: Feet = 100
print(distance)

当我们使用 Playground 运行上述程序时，我们得到以下结果。

100

类型安全

Swift 4 是一种类型安全语言，这意味着如果代码的一部分需要 String，则不能错误地向其传递 Int。

由于 Swift 4 是类型安全的，因此它会在编译代码时执行类型检查，并将任何不匹配的类型标记为错误。

var varA = 42
varA = "This is hello"
print(varA)

当我们编译上面的程序时，它会产生以下编译时错误。

main.swift:2:8: error: cannot assign value of type 'String' to type 'Int'
varA = "This is hello"

类型推断

类型推断使编译器能够在编译代码时自动推断出特定表达式的类型，只需检查您提供的值即可。Swift 4 使用类型推断来计算出适当的类型，如下所示。

// varA is inferred to be of type Int
var varA = 42
print(varA)

// varB is inferred to be of type Double
var varB = 3.14159
print(varB)

// varC is also inferred to be of type Double
var varC = 3 + 0.14159
print(varC)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

42
3.14159
3.14159

Swift - 变量

变量为我们提供了程序可以操作的命名存储。Swift 4 中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局；该内存中可以存储的值的范围；以及可以应用于变量的操作集。

Swift 4 支持以下基本类型的变量 -

• Int 或 UInt - 用于整数。更具体地说，您可以使用 Int32、Int64 定义 32 或 64 位有符号整数，而使用 UInt32 或 UInt64 定义 32 或 64 位无符号整数变量。例如，42 和-23。

• Float - 用于表示 32 位浮点数。它用于保存小数点较小的数字。例如，3.14159、0.1 和 -273.158。

• Double - 用于表示 64 位浮点数，并在浮点值必须非常大时使用。例如 3.14159、0.1 和 -273.158。

• Bool - 这表示一个布尔值，可以是 true 也可以是 false。

• 字符串- 这是字符的有序集合。例如，“你好，世界！”

• 字符- 这是一个单字符字符串文字。例如，“C”

Swift 4 还允许定义各种其他类型的变量，我们将在后续章节中介绍这些变量，例如可选、数组、字典、结构和类。

以下部分将介绍如何在 Swift 4 编程中声明和使用各种类型的变量。

变量声明

变量声明告诉编译器在何处以及为变量创建存储空间的量。在使用变量之前，必须使用var关键字声明它们，如下所示 -

var variableName = <initial value>

以下示例展示了如何在 Swift 4 中声明变量 -

var varA = 42
print(varA)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

42

类型注释

您可以在声明变量时提供类型注释，以明确变量可以存储的值的类型。这是语法 -

var variableName:<data type> = <optional initial value>

以下示例展示了如何使用 Annotation 在 Swift 4 中声明变量。这里需要注意的是，如果我们不使用类型注释，则必须为变量提供初始值，否则我们可以使用类型注释来声明变量。

var varA = 42
print(varA)

var varB:Float

varB = 3.14159
print(varB)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

42
3.1415901184082

命名变量

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大小写字母是不同的，因为 Swift 4 是区分大小写的编程语言。

您可以使用简单字符或 Unicode 字符来命名变量。以下示例显示了如何命名变量 -

var _var = "Hello, Swift 4!"
print(_var)

var 你好 = "你好世界"
print(你好)

当我们使用 Playground 运行上述程序时，我们得到以下结果。

Hello, Swift 4!
你好世界

打印变量

您可以使用 print 函数打印常量或变量的当前值。您可以通过将名称括在括号中来插入变量值，并在左括号之前使用反斜杠对其进行转义：以下是有效示例 -

var varA = "Godzilla"
var varB = 1000.00

print("Value of \(varA) is more than \(varB) millions")

当我们使用 Playground 运行上述程序时，我们得到以下结果。

Value of Godzilla is more than 1000.0 millions

Swift - 可选

Swift 4 还引入了Optionals类型，它可以处理值的缺失。可选表示“有一个值，并且它等于 x”或“根本没有值”。

Optional 本身就是一种类型，实际上是 Swift 4 的新的超级枚举之一。它有两个可能的值：None和Some(T)，其中T是 Swift 4 中可用的正确数据类型的关联值。

这是一个可选的整数声明 -

var perhapsInt: Int?

这是一个可选的字符串声明 -

var perhapsStr: String?

上面的声明相当于显式地将其初始化为nil，这意味着没有值 -

var perhapsStr: String? = nil

让我们通过以下示例来了解可选值在 Swift 4 中的工作原理：

var myString:String? = nil

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

myString has nil value

可选值类似于 Objective-C 中使用nil和指针，但它们适用于任何类型，而不仅仅是类。

强制展开

如果您将变量定义为可选，那么要从该变量中获取值，您必须将其解包。这只是意味着在变量末尾添加一个感叹号。

让我们举一个简单的例子 -

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Optional("Hello, Swift 4!")

现在让我们应用展开来获取变量的正确值 -

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print( myString! )
} else {
   print("myString has nil value")
}

当我们使用 Playground 运行上述程序时，我们得到以下结果。

Hello, Swift 4!

自动拆包

您可以使用感叹号而不是问号来声明可选变量。此类可选变量将自动解包，您无需在变量末尾使用任何进一步的感叹号即可获取分配的值。让我们举一个简单的例子 -

var myString:String!
myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Hello, Swift 4!

可选装订

使用可选绑定来查明可选值是否包含值，如果包含，则使该值可用作临时常量或变量。

if语句的可选绑定如下 -

if let constantName = someOptional {
   statements
}

让我们举一个简单的例子来了解可选绑定的用法 -

var myString:String?
myString = "Hello, Swift 4!"

if let yourString = myString {
   print("Your string has - \(yourString)")
} else {
   print("Your string does not have a value")
}

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Your string has - Hello, Swift 4!

Swift - 元组

Swift 4 还引入了元组类型，用于将多个值分组到单个复合值中。

元组中的值可以是任何类型，并且不需要是同一类型。

例如，("Tutorials Point", 123) 是一个有两个值的元组，一个是字符串类型，另一个是整数类型。这是一个合法的命令。

let ImplementError = (501, "Not Implemented") 是当服务器上的某些内容未实现时出现的错误，它返回两个值。错误代码和描述。

您可以根据需要从任意数量的值以及任意数量的不同数据类型创建元组。

这是元组声明的语法 -

var TupleName = (Value1, value2,… any number of values)

这是一个元组声明 -

var error501 = (501, “Not implemented”)

您可以使用从 0 开始的索引号来访问元组的值。

这是访问元组值的示例 -

print(“The code is\(error501.0)”)
print(“The definition of error is\(error501.1)”)

您可以在声明时命名元组的变量，并且可以使用它们的名称来调用它们

var error501 = (errorCode: 501, description: “Not Implemented”)
print(error501.errorCode)   // prints 501.

元组有助于从函数返回多个值。例如，Web 应用程序可能会返回类型（“String”、Int）的元组来显示加载是成功还是失败。

通过在元组中返回不同的值，我们可以根据不同的元组类型做出决定。

注意- 元组对于临时值很有用，不适合复杂数据。

Swift - 常量

常量是指程序在执行过程中不得更改的固定值。常量可以是任何基本数据类型，例如整型常量、浮点常量、字符常量或字符串常量。还有枚举常量。

常量的处理方式与常规变量一样，只是它们的值在定义后不能修改。

常量声明

在使用常量之前，必须使用let关键字声明它们，如下所示 -

let constantName = <initial value>

以下是一个简单的示例，展示如何在 Swift 4 中声明常量 -

let constA = 42
print(constA)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

42

类型注释

您可以在声明常量时提供类型注释，以明确常量可以存储的值的类型。以下是语法 -

var constantName:<data type> = <optional initial value>

以下示例展示了如何使用 Annotation 在 Swift 4 中声明常量。这里需要注意的是，在创建常量时必须提供初始值 -

let constA = 42
print(constA)

let constB:Float = 3.14159
print(constB)

当我们使用 Playground 运行上述程序时，我们得到以下结果。

42
3.1415901184082

命名常量

常量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大小写字母是不同的，因为 Swift 4 是区分大小写的编程语言。

您可以使用简单字符或 Unicode 字符来命名变量。以下是有效的例子 -

let _const = "Hello, Swift 4!"
print(_const)

let 你好 = "你好世界"
print(你好)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Hello, Swift 4!
你好世界

打印常数

您可以使用print函数打印常量或变量的当前值。您可以通过将名称括在括号中来插入变量值，并在左括号之前使用反斜杠对其进行转义：以下是有效示例 -

let constA = "Godzilla"
let constB = 1000.00

print("Value of \(constA) is more than \(constB) millions")

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Value of Godzilla is more than 1000.0 millions

Swift - 文字

文字是整数、浮点数或字符串类型值的源代码表示形式。以下是文字示例 -

42                // Integer literal
3.14159           // Floating-point literal
"Hello, world!"   // String literal

整数文字

整数文字可以是十进制、二进制、八进制或十六进制常量。二进制文字以 0b 开头，八进制文字以 0o 开头，十六进制文字以 0x 开头，十进制没有任何内容。

以下是整数文字的一些示例 -

let decimalInteger = 17         // 17 in decimal notation
let binaryInteger = 0b10001     // 17 in binary notation
let octalInteger = 0o21         // 17 in octal notation
let hexadecimalInteger = 0x11   // 17 in hexadecimal notation

浮点文字

浮点文字具有整数部分、小数点、小数部分和指数部分。您可以用十进制形式或十六进制形式表示浮点文字。

十进制浮点文字由一系列十进制数字组成，后跟十进制分数、十进制指数或两者。

十六进制浮点文字由 0x 前缀、后跟可选的十六进制小数和十六进制指数组成。

以下是浮点文字的一些示例 -

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

字符串文字

字符串文字是用双引号括起来的字符序列，其形式如下 -

"characters"

字符串文字不能包含未转义的双引号 (")、未转义的反斜杠 (\)、回车符或换行符。可以使用以下转义序列在字符串文字中包含特殊字符 -

以下示例展示了如何使用一些字符串文字 -

let stringL = "Hello\tWorld\n\nHello\'Swift 4\'"
print(stringL)

当我们使用 Playground 运行上述程序时，我们得到以下结果 -

Hello World

Hello'Swift 4'

布尔文字

一共有三个布尔文字，它们是标准 Swift 4 关键字的一部分 -

• true值代表 true。

• false值代表 false。

• nil值代表没有值。

Swift - 运算符

运算符是告诉编译器执行特定数学或逻辑操作的符号。Objective-C 拥有丰富的内置运算符，并提供以下类型的运算符 -

• 算术运算符
• 比较运算符
• 逻辑运算符
• 按位运算符
• 赋值运算符
• 范围运算符
• 杂项运算符

本教程将一一讲解算术、关系、逻辑、位、赋值等运算符。

算术运算符

下表列出了 Swift 4 语言支持的所有算术运算符。假设变量A为 10，变量B为 20，则 -

比较运算符

下表显示了 Swift 4 语言支持的所有关系运算符。假设变量A为 10，变量B为 20，则 -

逻辑运算符

下表列出了 Swift 4 语言支持的所有逻辑运算符。假设变量A为 1，变量B为 0，则 -

按位运算符

位运算符作用于位并执行逐位运算。&、| 和 ^ 的真值表如下 -

Assume A = 60; and B = 13;

In binary format, they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

下表列出了 Swift 4 语言支持的按位运算符。假设变量A为 60，变量B为 13，则 7−

赋值运算符

SSwift 4 支持以下赋值运算符 -

范围运算符

Swift 4 包含两个范围运算符，它们是表达值范围的快捷方式。下表解释了这两个运算符。

杂项运算符

Swift 4 支持其他一些重要的运算符，包括range和 ? : 如下表所示。

运算符优先级

运算符优先级决定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级高于其他运算符；例如，乘法运算符的优先级高于加法运算符。

例如，x = 7 + 3 * 2；此处，x 被分配为 13，而不是 20，因为运算符 * 的优先级高于 +，因此它首先乘以 3*2，然后添加到 7。

在这里，优先级最高的运算符出现在表的顶部，优先级最低的运算符出现在底部。在表达式中，将首先计算优先级较高的运算符。

Swift - 决策

决策结构要求程序员指定一个或多个要由程序评估或测试的条件，以及在条件确定为 true 时要执行的一条或多条语句，以及可选的在条件确定时要执行的其他语句确定是假的。

以下是大多数编程语言中典型决策结构的一般形式 -

Swift 4 提供了以下类型的决策语句。单击以下链接查看其详细信息。

这 ？： 操作员

我们已经介绍了条件运算符 ? ：在上一章中可以用来替换if...else语句。它具有以下一般形式 -

Exp1 ? Exp2 : Exp3;

其中 Exp1、Exp2 和 Exp3 是表达式。注意冒号的使用和位置。

的值？表达式的确定如下：Exp1 被求值。如果为真，则计算 Exp2 并成为整个 ? 的值。表达。如果 Exp1 为 false，则计算 Exp3 并且其值成为表达式的值。

Swift - 循环

可能存在这样的情况：您需要多次执行一段代码。一般来说，语句是按顺序执行的：首先执行函数中的第一个语句，然后执行第二个语句，依此类推。

编程语言提供了各种控制结构，允许更复杂的执行路径。

循环语句允许我们多次执行一条语句或一组语句。以下是大多数编程语言中循环语句的一般形式 -

Swift 4 编程语言提供了以下几种循环来处理循环需求。单击以下链接查看其详细信息。

循环控制语句

循环控制语句改变其正常顺序的执行。当执行离开作用域时，在该作用域中创建的所有自动对象都将被销毁。

Swift 4 支持以下控制语句。单击以下链接查看其详细信息。

Swift - 字符串

Swift 4 中的字符串是字符的有序集合，例如“Hello, World!” 它们由 Swift 4 数据类型String表示，而 String 又表示字符类型值的集合。

创建一个字符串

您可以通过使用字符串文字或创建 String 类的实例来创建 String，如下所示 -

// String creation using String literal
var stringA = "Hello, Swift 4!"
print( stringA )

// String creation using String instance
var stringB = String("Hello, Swift 4!")
print( stringB )

//Multiple line string

let stringC = """
Hey this is a
example of multiple Line
string by tutorialsPoint 

"""
print(stringC)

当上面的代码被编译并执行时，会产生以下结果

Hello, Swift 4!
Hello, Swift 4!
Hey this is a
example of multiple Line
string by tutorialsPoint

空字符串

您可以通过使用空字符串文字或创建 String 类的实例来创建空字符串，如下所示。您还可以使用布尔属性isEmpty检查字符串是否为空。

// Empty string creation using String literal
var stringA = ""

if stringA.isEmpty {
   print( "stringA is empty" )
} else {
   print( "stringA is not empty" )
}

// Empty string creation using String instance
let stringB = String()

if stringB.isEmpty {
   print( "stringB is empty" )
} else {
   print( "stringB is not empty" )
}

当上面的代码被编译并执行时，它会产生以下结果 -

stringA is empty
stringB is empty

字符串常量

您可以指定您的字符串是否可以通过将其分配给变量来修改（或变异），或者通过使用let关键字将其分配给常量来指定它是常量，如下所示-

// stringA can be modified
var stringA = "Hello, Swift 4!"
stringA + = "--Readers--"
print( stringA )

// stringB can not be modified
let stringB = String("Hello, Swift 4!")
stringB + = "--Readers--"
print( stringB )

当上面的代码被编译并执行时，它会产生以下结果 -

Playground execution failed: error: <EXPR>:10:1: error: 'String' is not
convertible to '@lvalue UInt8'
stringB + = "--Readers--"

字符串插值

字符串插值是一种通过将常量、变量、文字和表达式的值包含在字符串文字中来构造新字符串值的方法。

插入到字符串文字中的每个项目（变量或常量）都用一对括号括起来，并以反斜杠为前缀。这是一个简单的例子 -

var varA = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) times \(constA) is equal to \(varC * 100)"
print( stringA )

当上面的代码被编译并执行时，它会产生以下结果 -

20 times 100 is equal to 2000.0

字符串连接

您可以使用 + 运算符连接两个字符串或一个字符串和一个字符或两个字符。这是一个简单的例子 -

let constA = "Hello,"
let constB = "World!"

var stringA = constA + constB
print( stringA )

当上面的代码被编译并执行时，它会产生以下结果 -

Hello,World!

字符串长度

Swift 4 字符串没有length属性，但您可以使用全局 count() 函数来计算字符串中的字符数。这是一个简单的例子 -

var varA = "Hello, Swift 4!"

print( "\(varA), length is \((varA.count))" )

当上面的代码被编译并执行时，它会产生以下结果 -

Hello, Swift 4!, length is 15

字符串比较

您可以使用 == 运算符来比较两个字符串变量或常量。这是一个简单的例子 -

var varA = "Hello, Swift 4!"
var varB = "Hello, World!"

if varA == varB {
   print( "\(varA) and \(varB) are equal" )
} else {
   print( "\(varA) and \(varB) are not equal" )
}

当上面的代码被编译并执行时，它会产生以下结果 -

Hello, Swift 4! and Hello, World! are not equal

字符串迭代

在 swift 4 中，字符串又是值的集合，因此我们可以使用循环来迭代字符串。-

for chars in "ThisString" {
   print(chars, terminator: " ")
}

当上面的代码被编译并执行时，它会产生以下结果 -

T h i s S t r i n g

统一码字符串

您可以通过迭代字符串的 utf8 和 utf16 属性来访问字符串的 UTF-8 和 UTF-16 表示形式，如以下示例所示 -

var unicodeString = "Dog???"

print("UTF-8 Codes: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 Codes: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}

当上面的代码被编译并执行时，它会产生以下结果 -

UTF-8 Codes: 
68 
111 
103 
63 
63 
63 


UTF-16 Codes: 
68 
111 
103 
63 
63 
63 

字符串函数和运算符

Swift 4 支持与字符串相关的多种方法和运算符 -