Xcode学习笔记

前言

Xcode 是 Apple 提供的集成开发环境（IDE），用于开发 macOS、iOS、watchOS 和 tvOS 应用程序，而 Swift 是 Apple 推出的现代编程语言。

一、在Mac上安装Xcode并做点简单设置

安装其实没啥好说的直接在商店下载即可

做点简单设置

1.查看一下Xcode的版本

二、使用Xcode新建一个Playground

写点东西运行一下

三、swift基础-变量

1.swift是什么

Swift是由苹果公司开发的一种编程语言，用于iOS、macOS、watchOS和tvOS应用程序的开发。它是一种现代化、安全性高、性能优秀的编程语言，被广泛用于开发各种类型的应用程序，包括移动应用、桌面应用和服务器端应用。

2.变量是什么

"变量"是在编程中用来存储和表示数据的符号名称。变量可以在程序执行过程中被赋予不同的值，并且可以被程序中的其他部分引用和操作。在许多编程语言中，包括Swift，变量具有特定的数据类型，例如整数、浮点数、字符串等。

3.建立变量

在Swift编程中，你可以使用以下语法来创建变量：

var variableName: DataType = value

例子

let number:Int = 3

其中：

• var和let是关键字，用于声明变量。
• variableName是你给变量起的名称。
• DataType是变量的数据类型，例如整数（Int）、浮点数（Double）、字符串（String）等。
• value是可选的，表示你可以为变量赋一个初始值。

4.改变变量

在Swift编程语言中，改变变量的值是一个基本操作。首先，你需要定义一个变量，通常使用var关键字来声明可以修改的变量。一旦定义了变量，你可以简单地通过赋值来改变它的值。

这里有一个基本的例子来展示如何在Swift中改变变量的值：

// 定义一个变量
var number = 10

// 输出当前的值
print(number)  // 输出将会是 10

// 改变变量的值
number = 20

// 再次输出改变后的值
print(number)  // 输出将会是 20

在这个例子中，number是一个可以改变的变量，最初被赋值为10。然后，我们通过将number赋值为20来改变它的值，接着通过print函数输出来验证值已经改变。

如果你需要一个在赋值后不能更改的“变量”，你可以使用let关键字来声明一个常量。一旦给常量赋值之后，你将无法更改它的值。这里是一个常量的例子：

// 定义一个常量
let constantNumber = 10

// 尝试改变常量的值将导致编译错误
// constantNumber = 20  // 这将会导致一个错误

在实际开发中，选择使用var还是let取决于你是否需要在将来改变变量的值。使用let可以让你的代码更安全、更清晰。

5.小帖士

四、swift基础-变量命名规范

在Swift编程中，遵循变量命名规范不仅有助于代码的可读性，还能提高代码的可维护性和一致性。以下是一些常见的Swift变量命名规范和最佳实践：

1.使用小驼峰命名法

变量名通常使用小驼峰命名法，第一个单词以小写字母开头，后续的每个单词首字母大写。

var myVariable = 10
var userName = "John"
var totalAmount = 100.0

2.使用有意义且描述性的名称

变量名应尽量简洁且能准确描述变量的用途和意义。

var numberOfItems = 5
var userAge = 25
var userFirstName = "Alice"

3.避免使用缩写或单个字母

除非缩写非常常见且易于理解，否则应避免使用缩写或单个字母作为变量名。

// 不推荐
var n = 10
var usr = "John"

// 推荐
var numberOfItems = 10
var userName = "John"

4.遵循Swift API设计准则

Swift的API设计准则推荐变量名要清晰、简洁，并且避免冗余的描述。比如，若变量已经在一个类的上下文中，就不需要包含类名。

// 不推荐
class Car {
    var carSpeed = 60
    var carColor = "Red"
}

// 推荐
class Car {
    var speed = 60
    var color = "Red"
}

5.使用正确的拼写和语法

变量名应使用标准的英文拼写和语法，确保所有开发者都能轻松理解。

// 不推荐
var nmbrOfItms = 5
var usrAge = 25

// 推荐
var numberOfItems = 5
var userAge = 25

6.避免使用保留字

Swift中有一些保留字不能用作变量名，例如class、struct、func等。

// 不推荐
var class = "Math"

// 推荐
var className = "Math"

7.使用合适的集合名

对于数组、字典等集合类型的变量名，应使用复数形式以表明这是一个集合。

var names = ["Alice", "Bob", "Charlie"]
var userScores = [101, 200, 150]

五、swift基础-如何写注释

在Swift编程中，注释是用来解释代码的，可以帮助开发者理解代码的意图和逻辑。Swift支持单行注释和多行注释。以下是如何在Swift中写注释的详细说明：

1.单行注释

单行注释以两个斜杠 (//) 开始，注释内容从这两个斜杠到行尾的部分。

// 这是一个单行注释
var myVariable = 10  // 这是一个内联单行注释

2.多行注释

多行注释以斜杠加星号 (/*) 开始，并以星号加斜杠 (*/) 结束，可以跨越多行。

/*
这是一个多行注释
它可以跨越多行
用于更长的注释
*/
var myVariable = 10

3.嵌套多行注释

Swift支持嵌套多行注释，这在调试代码时非常有用，可以暂时注释掉一大块代码而不影响内部的注释。

/*
这是外部的多行注释
/*
这是内部的多行注释
*/
这是外部多行注释的结束部分
*/
var myVariable = 10

4.文档注释

文档注释用于生成代码文档，以斜杠加两个星号 (/**) 开始，并以星号加斜杠 (*/) 结束。通常放在类、方法或属性的前面，提供详细的描述。

/**
 这是一个文档注释
 - Parameter name: 用户的名字
 - Returns: 问候语句
 */
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

5.注释的最佳实践

1. 保持简洁和相关性：注释应简洁明了，直接解释代码的作用和逻辑。

2. 避免冗余：注释不应重复代码本身已经表达的信息。

// 不推荐的冗余注释
var myVariable = 10  // 将myVariable设置为10

// 推荐的注释
var myVariable = 10  // 初始计数值

6.实例

以下是一个包含不同类型注释的Swift代码示例：

// 这是一个简单的Swift程序

/*
 这是一个多行注释
 解释程序的主要部分
*/

/// 表示一个用户的类
class User {
    /// 用户的名字
    var name: String

    /**
     初始化方法
     - Parameter name: 用户的名字
     */
    init(name: String) {
        self.name = name
    }

    /**
     打印用户的问候语
     - Returns: 问候语
     */
    func greet() -> String {
        return "Hello, \(name)!"
    }
}

// 创建一个User实例
let user = User(name: "Alice")
// 打印问候语
print(user.greet())  // 输出: Hello, Alice!

通过这些示例，你可以看到如何在Swift中使用单行注释、多行注释、嵌套注释和文档注释，以及一些编写注释的最佳实践。

六、swift基础-使用快捷键注释

在Xcode中，使用快捷键可以提高开发效率，特别是在添加和管理注释时。以下是一些常用的Xcode快捷键，用于插入单行注释、多行注释，以及管理注释块：

1.单行注释

你可以使用快捷键快速添加或移除单行注释。

• 注释/取消注释选中的行：Command (⌘) + /

2.多行注释

虽然Xcode没有直接的快捷键来插入多行注释，但你可以使用以下步骤和快捷键来实现：

1. 选中多行代码：使用鼠标或键盘快捷键（如 Shift + 上/下箭头）选中多行代码。
2. 注释/取消注释选中的行：Command (⌘) + /

3.文档注释

为了生成文档注释，你可以使用快捷键Option (⌥) + Command (⌘) + /。在函数、类或方法的上方使用这个快捷键，可以自动生成文档注释模板。

/// <#Description#>
/// - Parameter name: <#name description#>
/// - Returns: <#description#>
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

七、swift基础-如何打印出包含文字和变量的内容

在Swift编程中，你可以使用字符串插值和字符串连接来打印包含文字和变量的内容。以下是详细说明和示例：

1.使用字符串插值

字符串插值是将变量或表达式的值插入到字符串中的一种简洁方法。使用\(变量或表达式)的语法即可。

let name = "Alice"
let age = 30

// 使用字符串插值
print("My name is \(name) and I am \(age) years old.")

在这个例子中，\(name)和\(age)会被替换为变量name和age的值，输出结果为：My name is Alice and I am 30 years old.

2.使用字符串连接

你也可以通过字符串连接的方式来组合文字和变量。使用加号 (+) 来连接字符串和变量。

let name = "Alice"
let age = 30

// 使用字符串连接
print("My name is " + name + " and I am " + String(age) + " years old.")

在这个例子中，由于age是一个整数类型，需要使用String(age)将其转换为字符串类型。输出结果同样是：My name is Alice and I am 30 years old.

八、swift基础-运算符（Operator）是什么

运算符（Operator）是编程语言中的一个基本组成部分，用于对操作数（即变量和常量）执行各种运算。运算符是特定的符号或关键字，通过它们可以进行算术运算、逻辑运算、比较运算等。

1.运算符的类型

运算符可以分为以下几种主要类型：

1） 算术运算符（Arithmetic Operators）

用于执行基本的数学运算。

• 加法运算符 (+)：将两个数相加。

  let sum = 5 + 3  // 结果是 8
  

• 减法运算符 (-)：将一个数减去另一个数。

  let difference = 5 - 3  // 结果是 2
  

• 乘法运算符 (*)：将两个数相乘。

  let product = 5 * 3  // 结果是 15
  

• 除法运算符 (/)：将一个数除以另一个数。

  let quotient = 6 / 3  // 结果是 2
  

• 取余运算符 (%)：计算两个数相除的余数。

  let remainder = 7 % 3  // 结果是 1
  

2） 赋值运算符（Assignment Operators）

用于将值赋给变量。

• 赋值运算符 (=)：将右侧的值赋给左侧的变量。

  let x = 5  // x 被赋值为 5
  

3） 复合赋值运算符（Compound Assignment Operators）

结合了算术运算和赋值运算。

• 加赋值运算符 (+=)：将右侧的值加到左侧变量上，并赋值给左侧变量。

  var x = 5
  x += 3  // 结果是 x = 8
  

• 减赋值运算符 (-=)：将右侧的值从左侧变量上减去，并赋值给左侧变量。

  var x = 5
  x -= 3  // 结果是 x = 2
  

• 乘赋值运算子 (*=)：将左侧变量与右侧的值相乘，并赋值给左侧变量。

  var x = 5
  x *= 3  // 结果是 x = 15
  

• 除赋值运算子 (/=)：将左侧变量除以右侧的值，并赋值给左侧变量。

  var x = 6
  x /= 3  // 结果是 x = 2
  

4） 范围运算符（Range Operators）

用于定义范围。

• 闭区间运算符 (...)：定义一个包含从开始到结束的所有值的范围。

  for i in 1...5 {
      print(i)
  }
  // 输出: 1, 2, 3, 4, 5
  

• 半开区间运算符 (..<)：定义一个从开始到结束但不包括结束值的范围。

  for i in 1..<5 {
      print(i)
  }
  // 输出: 1, 2, 3, 4
  

2.运算符优先级和结合性

运算符有优先级和结合性，用于确定在表达式中运算符执行的顺序。

• 优先级：优先级决定了运算符执行的顺序。优先级高的运算符会先执行。

  let result = 5 + 3 * 2  // 结果是 11，因为乘法优先于加法
  

• 结合性：结合性决定了当运算符具有相同优先级时的执行顺序。通常有左结合和右结合。

  let result = 5 - 3 - 1  // 结果是 1，左结合意味着从左到右计算
  

九、swift基础- 数字类型

在 Swift 编程中，数字类型（Number Types）用于表示整数和浮点数。Swift 提供了多种数值类型来满足不同的需求。以下是 Swift 中常见的数字类型及其注意事项：

1.整数类型（Integer Types）

1） 有符号整数类型（Signed Integers）

有符号整数可以表示正数、负数和零。Swift 提供了以下几种有符号整数类型：

• Int：默认整数类型，位数根据平台不同而不同。在 32 位平台上是 32 位，在 64 位平台上是 64 位。

  let a: Int = 42
  

• Int8：8 位有符号整数，范围是 -128 到 127。

  let b: Int8 = 127
  

• Int16：16 位有符号整数，范围是 -32768 到 32767。

  let c: Int16 = 32767
  

• Int32：32 位有符号整数，范围是 -2147483648 到 2147483647。

  let d: Int32 = 2147483647
  

• Int64：64 位有符号整数，范围是 -9223372036854775808 到 9223372036854775807。

  let e: Int64 = 9223372036854775807
  

2） 无符号整数类型（Unsigned Integers）

无符号整数只能表示非负整数。Swift 提供了以下几种无符号整数类型：

• UInt：默认无符号整数类型，位数根据平台不同而不同。在 32 位平台上是 32 位，在 64 位平台上是 64 位。

  let f: UInt = 42
  

• UInt8：8 位无符号整数，范围是 0 到 255。

  let g: UInt8 = 255
  

• UInt16：16 位无符号整数，范围是 0 到 65535。

  let h: UInt16 = 65535
  

• UInt32：32 位无符号整数，范围是 0 到 4294967295。

  let i: UInt32 = 4294967295
  

• UInt64：64 位无符号整数，范围是 0 到 18446744073709551615。

  let j: UInt64 = 18446744073709551615
  

3）浮点数类型（Floating-Point Types）

浮点数用于表示小数和大范围的数值。Swift 提供了以下几种浮点数类型：

• Float：32 位浮点数，精度为 6 位小数。

  let k: Float = 3.14159
  

• Double：64 位浮点数，精度为 15 位小数。Swift 默认的浮点数类型。

  let l: Double = 3.141592653589793
  

2.注意事项

1） 类型安全和类型推断

Swift 是一种类型安全的语言，这意味着它会在编译时检查你的代码，并阻止你传递错误类型的值。此外，Swift 还具有类型推断功能，编译器可以根据你赋的值自动推断变量的类型。

let number = 42  // 编译器推断 number 的类型为 Int
let pi = 3.14159  // 编译器推断 pi 的类型为 Double

2） 类型转换

在不同类型之间进行运算时，需要显式转换类型。Swift 不会进行隐式类型转换。

let m: Int = 10
let n: Double = 3.14
// let result = m + n  // 错误：不能将 Int 和 Double 相加
let result = Double(m) + n  // 正确：将 Int 转换为 Double

3） 溢出检查

Swift 默认会进行溢出检查。如果一个运算导致整数溢出，程序会在运行时抛出错误。

let maxInt = Int.max
// let overflow = maxInt + 1  // 错误：导致溢出

4） 精度问题

使用浮点数类型时需要注意精度问题，尤其是在比较浮点数时。

let x: Double = 0.1 + 0.2
let y: Double = 0.3
print(x == y)  // 输出 false，因为浮点数精度问题

3.和金钱有关的时候用Decimal类型

在 Swift 编程中，Decimal 类型用于高精度的十进制数值计算，特别适用于需要避免浮点数精度问题的财务应用和其他高精度计算场景。Decimal 类型提供了更高的精度和更好的精度控制，但也有一些需要注意的事项。

1） 创建 Decimal并进行算术运算

通过直接赋值、字符串初始化或使用整数和浮点数初始化 Decimal 值，并且支持基本的算术运算，包括加法、减法、乘法和除法

import Foundation

// 直接赋值
let decimalA: Decimal = 10.5

// 通过字符串初始化
let decimalB = Decimal(string: "123.456")

// 通过整数初始化
let decimalC = Decimal(100)

// 通过浮点数初始化
let decimalD = Decimal(3.14159)

let sum = decimalA + decimalC          // 加法
let difference = decimalA - decimalC   // 减法
let product = decimalA * decimalC      // 乘法
let quotient = decimalA / decimalC     // 除法

print(sum)
print(difference)
print(product)
print(quotient)

2） 精度和范围

Decimal 的精度和范围是固定的，精度为 38 位有效数字，小数点后最多 28 位。超出这个范围可能会导致数值被截断或舍入。

import Foundation
let highPrecisionValue = Decimal(string: "144.23456789012345678901234567890123456789")
print(highPrecisionValue)  // 输出 (144.234567890123456789012345678901234567)

3） 性能

由于 Decimal 提供了高精度和精确的十进制计算，因此在性能方面比普通的浮点数计算稍慢。在需要高性能但不要求高精度的场景下，使用 Double 或 Float 可能更合适。

十、swift基础-文字类型

1.Character 和 String 的区别

Character：表示单个字符，由一个或多个 Unicode 标量组成。
String：表示字符序列，可以包含零个或多个字符。

2. .count 的用法

在 Swift 中，.count 是一个常用的属性，用于获取集合类型（例如字符串、数组、字典和集合）中的元素数量。

String 类型的 .count 属性返回字符串中的字符数。

let string = "Hello!"
let characterCount = string.count
print("The string '\(string)' has \(characterCount) characters.")
// 输出: The string 'Hello!' has 6 characters.

• .count 是一个只读属性.
• 对于 String 类型，.count 返回的是字符的数量，而不是字节数。Swift 的 String 是基于 Unicode 标量的。

3.用连续三个双引号来建立多行字串

在 Swift 中，可以使用三个双引号 (""") 来创建多行字符串字面量。这种方式可以方便地创建包含换行符和其他格式的长文本。多行字符串字面量的内容可以包含换行、制表符以及其他字符，并且保留它们的格式。

1）示例代码

以下是如何使用三个双引号创建多行字符串字面量的示例：

let multilineString = """
This is a multiline string.
It can span multiple lines.
Each new line in the code is also a new line in the string.
"""
print(multilineString)

输出结果将保持代码中的格式：

2）使用缩进

多行字符串字面量还支持使用缩进。所有行的缩进会以最小缩进为基准进行调整，以便在代码中保持整齐而在输出中保持一致。

let indentedMultilineString = """
    This is an indented multiline string.
        Each line will have the leading whitespace trimmed.
    This helps maintain readability in your code.
"""
print(indentedMultilineString)

输出结果会自动调整缩进：

3）插入变量和表达式

可以使用字符串插值在多行字符串中插入变量和表达式：

let name = "Swift"
let version = 5.7
let multilineStringWithInterpolation = """
Hello, \(name)!
The current version is \(version).
"""
print(multilineStringWithInterpolation)

输出结果将包含插入的变量值：

4.String相加

var text:String = "嗨"
let emoji:String = "😀"
print(text+emoji)

text+=emoji
print(text)

5. String的属性和方法

let text:String = "Hello"
print(text.count)
print(text.first!)
print(text.last!)
print(text.uppercased())
print(text.lowercased())

6.🇨🇳的unicode组成

let text:String = "🇨🇳"
print("文字长度:\(text.count)")
print("Unicode:\(text.unicodeScalars.count)")
print("第一个字:\(text.unicodeScalars.first!)")
print("最后一个字:\(text.unicodeScalars.last!)")

let c = "🇨"
let n = "🇳"
print("\(c) + \(n) = \(c+n)")

7.咖啡色的👍

let text = "\u{1F44D}"
let color = "\u{1F3FE}"
print(text)
print (color)
print (text+color)

8.用 Unicode 输入文字

谷歌搜索“unicode converter”随便打开一个
unicode converter转换网址
https://r12a.github.io/app-conversion/

let text = "\u{4F60}\u{597D}\u{670B}\u{53CB}"
print(text)

十一、swift基础-转义符

在 Swift 中，转义符用于在字符串字面量中表示特殊字符。常见的转义符包括换行符、制表符、引号以及其他一些特殊字符。以下是 Swift 中常用的转义符及其示例：

1. 换行符 (\n)

let newLineString = "Hello,\nWorld!"
print(newLineString)

2. 制表符 (\t)

let tabString = "Hello,\tWorld!"
print(tabString)

3. 双引号 (\")

let doubleQuoteString = "She said, \"Hello, World!\""
print(doubleQuoteString)

4. 单引号 (\')

let singleQuoteString = "It\'s a sunny day."
print(singleQuoteString)

5. 反斜杠 (\\)

let backslashString = "This is a backslash: \\"
print(backslashString)

十二、Zalgo文字

之前还记得两个unicode字符组成一个表情吗，通过unicode的组合，可以组成一些看上去很酷或者像是符文之类的文字
Zalgo文字转换网址
https://tw.piliapp.com/cool-text/zalgo-text/

let zalgo = "Z̮̱̳̪̓̑̎̓̀̊̈̋̋̀a̙̖̟̥͇͐̽̀̅̄̏̾̔͌l̪̠̟͓̖͚̈̓̃͆̑͌̊g̥͙̝̬̳͓̞̖͛̐̈́͛̍̓͌͗̓̐̉͊ò̲̗̞͕̄͐͂́̒̉̊̈́̚.͖̟̘͓̱͕͚̠̄̎̽̄̚ͅͅ.̳̤̬͖̜̽̔̀̽̔̅̆͂̐̐̓ͅ.̥̪̝̥̥͈̗̰͌̃͊̅̋̒́̿"

print(zalgo)

十三、布尔值及三元条件运算符

1.布尔值

布尔值只有两种 true 或者 false ，只需使用 0 和 1 表示，也就只要1bit的空间。
用来解决只有两种答案的问题，“问题”就是变量的名称，而它的值就是答案。

1）命名布尔变量

布尔变量应使用能清楚表达其真值的名称，通常以is、has、can、should等开头。

var isUserLoggedIn = true
var hasFinishedLoading = false
var canEditProfile = true
var shouldSaveChanges = false

let isAdult = true  //你成年了吗？
let didEat = false  //你吃了吗？
let hasUmbrella = false   //你有带伞吗？
let isEarthSquare = false   //地球是方的吗？
let willHaveCoffee = false   //喝咖啡吗？

2） 比较运算符（Comparison Operators）

用于比较两个值，并返回布尔值（true 或 false）。

• 等于运算符 (==)：判断两个值是否相等。

  let isEqual = (5 == 3)  // 结果是 false
  

• 不等于运算符 (!=)：判断两个值是否不等。

  let isNotEqual = (5 != 3)  // 结果是 true
  

• 大于运算符 (>)：判断左侧值是否大于右侧值。

  let isGreater = (5 > 3)  // 结果是 true
  

• 小于运算符 (<)：判断左侧值是否小于右侧值。

  let isLesser = (5 < 3)  // 结果是 false
  

• 大于等于运算符 (>=)：判断左侧值是否大于或等于右侧值。

  let isGreaterOrEqual = (5 >= 3)  // 结果是 true
  

• 小于等于运算符 (<=)：判断左侧值是否小于或等于右侧值。

  let isLesserOrEqual = (5 <= 3)  // 结果是 false
  

3） 逻辑运算符（Logical Operators）

用于执行逻辑运算，通常用于布尔值的操作。

• 与运算符 (&&)：当且仅当两个布尔值都为true时，结果为true。

  let result = true && false  // 结果是 false
  

• 或运算符 (||)：当任意一个布尔值为true时，结果为true。

  let result = true || false  // 结果是 true
  

• 非运算符 (!)：取反布尔值。

  let result = !true  // 结果是 false
  

4） 返回布尔值的属性和方法

//返回 Bool 的属性和方法
let int1:Int = 4
print(int1.isMultiple(of: 2))  //是否是2的倍数，是返回true，否返回false

let double1:Double = 1.5
print(double1.isEqual(to: 1.5))     //比较数值是否相同，相同返回true，否则返回false

let double2:Double = 1.5
print(double2.isLess(than: 1.8))     //比较数值大小，小于1.8返回true，否则返回false

let double3:Double = 1.5
print(double3.isLessThanOrEqualTo(1.5))  //比较数值大小，小于或者等于1.5返回true，否则返回false
 
let string1 = ""
print(string1.isEmpty)      //如果string1的值为空，返回true，否则返回false

let string2 = "123"
print(string2.hasPrefix("1"))   //如果string2的值是“1”开头，返回true，否则返回false

let string3 = "123"
print(string3.hasSuffix("23"))   //如果string3的值是“23”结尾，返回true，否则返回false

let string4 = "123"
print(string4.contains("2"))    //如果string4的值包含“2”，返回true，否则返回false

2.三元条件运算符

三元条件运算符是一种简化 if-else 语句的工具，用于根据一个条件表达式的结果来选择两个值之一。条件运算子的语法非常简洁，使代码更紧凑。其形式为 condition ? trueExpression : falseExpression。

1.语法

condition ? trueExpression : falseExpression

• condition：一个布尔表达式，决定选择哪个表达式的结果。
• trueExpression：如果 condition 为 true，则返回此表达式的结果。
• falseExpression：如果 condition 为 false，则返回此表达式的结果。

let age = 20
let canVote = (age >= 18) ? "Yes" : "No"
print("Can vote: \(canVote)")  // 输出: Can vote: Yes

let temperature = 30
let weatherDescription = (temperature > 25) ? "Hot" : "Cold"
print("Weather: \(weatherDescription)")  // 输出: Weather: Hot

let payment = 300.0
print(payment.isLess(than: 499) ? "自己付运费" : "免运费")   //购物金额小于499，需要自己付运费，否则就免运费
print(payment.isLess(than: 499) ? "含运费共计\(payment + 60)元" : "免运费\(payment)元")

let payment1 = 300.0
let showldPayShippingFee = payment1.isLess(than: 499)
print(showldPayShippingFee ? "自己付运费" : "免运费")   //购物金额小于499，需要自己付运费，否则就免运费
print(showldPayShippingFee ? "含运费共计\(payment + 60)元" : "免运费\(payment)元")    //运费60元
print("应付金额为 \(showldPayShippingFee ? payment1 + 60 : payment1)元")

let isMale = false  //设定性别
let canSpeakMandarin = false    //设定是否会说中文
let greeting1 = canSpeakMandarin ? (isMale ? "帅哥，你好" : "美女，你好") : "Hello"     //先判断是否会说中文，再判断性别

print(greeting1)

2.体重检测示例

func 体重检测(weight: Double, height: Double){
    print("🌼体重：\(weight)公斤，身高\(height * 100)厘米")
    //👇体重低于50时，印出「不能捐血」，50或者50以上印出「可以捐血」
    print(weight.isLess(than: 50) ? "不能捐血" : "可以捐血")
    //👇计算出BMI:体重 /（身高 * 身高）
    let bmi = weight / (height * height)
    print("你的 BMI 是：\(bmi)")
    //👇BMI小于等于18.5时印出「过瘦体型」；小于30时打印出「正常」；其他印出「过胖」
    let isSkinny = bmi.isLessThanOrEqualTo(18.5)
    let isNormal = bmi.isLess(than: 30)
    print(isSkinny ? "过瘦" : isNormal ? "正常" : "过胖" , "体型" ,separator: "") //这里的separator可以去掉中间空格
    print("-------------------")
}
体重检测(weight: 47.5, height: 1.62)
体重检测(weight: 75, height: 1.75)
体重检测(weight: 130, height: 1.80)

3.店铺优惠活动示例

// 店铺虎年搞活动，名字里面有虎字的可以获得优惠的活动，根据客人名字印出他能获得多少优惠
func 名字优惠活动(name1:String){
    //名字包含虎字
    let shouldGetDiscount = name1.contains("虎")
    //名字开头有虎字
    let shouldGetHalfDiscount = name1.hasPrefix("虎")
    //默认没有优惠
    var message1 = "你这次没有获得优惠"
    //名字包含虎字获得八折优惠
    message1 = shouldGetDiscount ? "你可以获得八折优惠" : message1
    //名字开头有虎字，获得半价优惠
    message1 = shouldGetHalfDiscount ? "你可以获得半价优惠" : message1
    print("📢名字是\(name1)的客人，\(message1)")
}

名字优惠活动(name1: "小老虎")
名字优惠活动(name1: "虎牙妹")
名字优惠活动(name1: "小猫咪")

十四、静态属性和实例属性

在 Swift 中，静态属性（static properties）和实例属性（instance properties）用于存储数据，但它们的作用范围和使用方式不同。理解它们的区别有助于你在编写 Swift 代码时更好地设计和管理数据。

1.实例属性

实例属性是属于某个特定实例的属性，每个实例都有自己独立的一份实例属性的数据。实例属性用于存储与实例相关的数据。

class Person {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

// 创建实例
let person1 = Person(name: "Alice", age: 30)
let person2 = Person(name: "Bob", age: 25)

// 每个实例都有自己独立的属性数据
print(person1.name)  // 输出: Alice
print(person2.name)  // 输出: Bob

2.静态属性

静态属性是属于整个类型的属性，而不是某个特定实例。静态属性在所有实例之间共享，同一个类型的所有实例都访问同一个静态属性。静态属性使用 static 关键字来声明。

class MathUtility {
    static let pi = 3.14159

    static func areaOfCircle(radius: Double) -> Double {
        return pi * radius * radius
    }
}

// 访问静态属性
print(MathUtility.pi)  // 输出: 3.14159

// 调用静态方法
let area = MathUtility.areaOfCircle(radius: 5)
print(area)  // 输出: 78.53975

十五、函数（function）和方法（method）

在 Swift 编程中，函数（function）和方法（method）都是用于定义一段可以重复使用的代码块，它们在功能上非常相似，但在使用场景和定义方式上存在一些区别。

1.函数（Function）

函数是独立的代码块，可以在程序的任何地方定义和调用。它们不属于任何特定类型或实例。

// 定义一个简单的函数
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

// 调用函数
let greeting = greet(name: "Alice")
print(greeting)  // 输出: Hello, Alice!

2.方法（Method）

方法是与特定类型（类、结构体、枚举）相关联的函数。方法分为实例方法和类型方法。

1）实例方法

是属于某个特定实例的函数。它们可以访问和修改该实例的属性。

class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func greet() -> String {
        return "Hello, \(name)!"
    }
}

// 创建实例并调用实例方法
let person = Person(name: "Bob")
print(person.greet())  // 输出: Hello, Bob!

2）类型方法

是属于类型本身的函数。它们使用 static 关键字（或 class 关键字在类中，允许子类重写）来定义。

class MathUtility {
    static func add(a: Int, b: Int) -> Int {
        return a + b
    }
}

// 调用类型方法
let sum = MathUtility.add(a: 3, b: 5)
print(sum)  // 输出: 8

十六、如何使用别人写好的函数

以下内容是别人写好的函数

import Foundation

/// 一隻可戰鬥的動物。
public struct Animal
{
    public let name: String
    public var hp: Int
    public let power: Int
    
    /// 建立一隻動物，血量範圍為 1 ~ 50，力量範圍為 1 ~ 10，超過範圍將取最接近值。
    /// - Parameter name: 名字
    /// - Parameter hp: 血量
    /// - Parameter power: 力量
    public init(_ name: String, hp: Int, power: Int)
    {
        var name = name.trimmingCharacters(in: .whitespacesAndNewlines)
        if (name.count == 0) { name = "無名氏🥲" }
        
        self.name = name
        self.hp = hp < 1 ? 1 : min(50, hp)
        self.power = power < 1 ? 1 : min(10, power)
    }
    
    /// 和另外一隻動物戰鬥。預設是我方先攻。
    /// 這個方法會印出對戰訊息並回傳獲勝的動物。
    /// - Returns: 獲勝的動物
    public func 戰鬥(對上 敵人: Animal, 我方先攻: Bool = true) -> Animal
    {
        var attacker = 我方先攻 ? self : 敵人
        var defender = 我方先攻 ? 敵人 : self
        print("⚔️⚔️⚔️ \(name)（HP \(hp) 力量 \(power)） VS \(敵人.name) （HP \(敵人.hp) 力量 \(敵人.power)）⚔️⚔️⚔️")
        
        while (attacker.hp > 0 && defender.hp > 0)
        {
            defender.hp -= attacker.power
            let hpMessage = defender.hp > 0 ? "\(defender.name)血量剩餘 \(defender.hp)。" : "致命一擊！\(defender.name)被打倒了。"
            print("\t\(attacker.name) 對 \(defender.name) 造成了 \(attacker.power) 點傷害！ \(hpMessage)")
            (attacker, defender) = (defender, attacker)
        }
        
        print("✨「\(defender.name)」獲勝！🏆")
        return defender
    }
    
    public static let 戰鬥規則: String = "兩隻動物輪流攻擊，1 點力量可以消耗對方 1 點血量，先讓敵方血量歸零者獲勝。"
    
    /// 隨機產生一隻動物
    public static func 隨機() -> Animal
    {
        let names = "🐶🐱🐹🐰🐻🐼🐻‍❄️🐨🐯🦁🐮🐷🐸🐵🐔🐧🐤🦊🐴🦄🐝🐛🦋🐌🐞🐢🐙🦑🦀🐠🐟🐡🐬🦭🐳🦉"
        return Animal(String(names.randomElement()!),
                      hp: Int.random(in: 10...50),
                      power: Int.random(in: 1...10))
    }
}

新建一个Playground，然后在“Sources”上右键新建文件，将上述别人写好的函数复制一下

试着读懂这个函数并写一个实例

print("欢迎来到动物大乱斗，这里的规则是： \(Animal.戰鬥規則)")
let 中华大老虎 = Animal("中华大老虎",hp:25,power:7)
let 东瀛小乌龟 = Animal("东瀛小乌龟", hp: 40, power: 4)
print("第一轮战斗开始！")
var winner = 中华大老虎.戰鬥(對上: 东瀛小乌龟)
winner.hp += 25
print("🍼\(winner.name)喝了一瓶固本回血药，现在血量为\(winner.hp)")
print("第二轮战斗开始！")
winner.戰鬥(對上: Animal.隨機(),我方先攻: false)

十七、Tuple及typealias类型别名

1.Tuple是什么

元组（Tuple）是一种将多个值组合成一个单一复合值的数据结构。元组的每个值可以是不同类型的。元组非常适用于临时组合多个值，尤其是当函数需要返回多个值时。

2.示例一

let girlName = "安妮"
let girlHeight = 155
let girlHairColor = "金色"

print("小女孩名字是\(girlName)，身高是\(girlHeight)厘米，头发的颜色是\(girlHairColor)")

let girl = ("安妮",155,"金色")
print("小女孩名字是\(girl.0)，身高是\(girl.1)厘米，头发的颜色是\(girl.2)")

3.示例二

typealias Human = (name:String,height:Int,hairColor:String)
let girl:Human = ("安妮",155,"金色")
print("小女孩名字是\(girl.name)，身高是\(girl.height)厘米，头发的颜色是\(girl.hairColor)")

十八、if流程控制

1.示例1

var food = "🍞"
let 吃全素 = false
let 吃蛋奶素 = false

if (吃全素){
    food += "🍅🍄"
}else if (吃蛋奶素){
    food += "🥚🧀"
}else{
    food += "🥚🥓"
}
print("您的餐品：\(food)")

2.示例2

let birthday = (year: 1994, month: 9, day: 5)
let today = (year: 2024, month: 6, day: 21)

let age = today.year - birthday.year
let 生日在这个月之前 = today.month > birthday.month

if (age > 18){
    print("成年")
}else if (age == 18){
    if (生日在这个月之前){print("成年")}
    else if (today.month == birthday.month && today.day >= birthday.day){
        print("成年")
    }
    else {print("未成年")}
} else {print("未成年")}

以上这种写法，看的人实在是难受，可以优化一下

let birthday = (year: 1994, month: 9, day: 5)
let today = (year: 2024, month: 6, day: 21)

let age = today.year - birthday.year
let 生日在这个月之前 = today.month > birthday.month
let 已过生日 = 生日在这个月之前 || (today.month == birthday.month && today.day >= birthday.day)

if (age > 18){
    print("成年")
}else if (age == 18 && 已过生日){
    print("成年")
} else {print("未成年")}

这样写感觉也挺满意了，但其实还可以再优化一下

let birthday = (year: 1994, month: 9, day: 5)
let today = (year: 2024, month: 6, day: 21)

let age = today.year - birthday.year
let 生日在这个月之前 = today.month > birthday.month
let 已过生日 = 生日在这个月之前 || (today.month == birthday.month && today.day >= birthday.day)

if (age > 18 || (age == 18 && 已过生日)){
    print("成年")
} else {print("未成年")}

3.示例3

let 我喜欢她 = true
let 她喜欢我 = true

if (我喜欢她){
    if (她喜欢我){
        print("两情相悦～～Match!")
    } else{
        print("单相思")
    }
} else if (她喜欢我){
    print("单相思")
} else {
    print("不来电")
}

以上内容看起来还是比较费劲的，可以优化一下

let 我喜欢她 = false
let 她喜欢我 = true

if (我喜欢她 || 她喜欢我){
    if (我喜欢她 == 她喜欢我){
        print("两情相悦～～Match!")
    } else {
        print("单相思")
    }
} else {
    print("不来电")
}

这样看上去舒服多了，但还可以再优化一下

let 我喜欢她 = true
let 她喜欢我 = true

let 感觉不一样 = 我喜欢她 != 她喜欢我
if (感觉不一样){
    print("单相思")
} else if (我喜欢她){
    print("两情相悦～～Match!")
} else {
    print("不来电")
}

十九、Range范围运算符

在 Swift 中，范围运算符（Range Operators）用于表示一系列的值。范围运算符有两种主要类型：闭区间运算符和半开区间运算符。

1.闭区间运算符（Closed Range Operator）

闭区间运算符 ... 用于创建包含两个端点及其之间所有值的范围。它的语法如下：

let closedRange = 1...5

for number in closedRange {
    print(number)
}

输出：

1
2
3
4
5

2.半开区间运算符（Half-Open Range Operator）

半开区间运算符 ..< 用于创建从起始值到但不包括结束值的范围。它的语法如下：

let halfOpenRange = 1..<5

for number in halfOpenRange {
    print(number)
}

输出：

1
2
3
4

3.单侧区间（One-Sided Ranges）

Swift 还支持单侧区间，这些区间在一侧没有明确的边界。可以用于数组、字符串等的切片操作。

let numbers = [1, 2, 3, 4, 5]

// 从索引 2 到数组的末尾
let subArray1 = numbers[2...]
print(subArray1)  // 输出: [3, 4, 5]

// 从数组的开头到索引 2
let subArray2 = numbers[...2]
print(subArray2)  // 输出: [1, 2, 3]

// 从索引 2 开始到索引 4（不包含）
let subArray3 = numbers[2..<4]
print(subArray3)  // 输出: [3, 4]

4.Range的属性

// Range 范围运算符

//属性
let range = 0...3

print("是空的吗？\(range.isEmpty)")
print("范围内的数量：\(range.count)")
print("第一个值：\(range.first)")
print("最后一个值：\(range.last)")
print("下限：\(range.lowerBound)")
print("上限：\(range.upperBound)")

5.Range的方法

1）示例1

// Range 范围运算符

//方法
let range = "a"..."d"
let result = range.contains("c")

print("\(range)是否包含某个值？")
print(result)

2）示例2

let range = 1...9
let result = range.randomElement()!

print("\(range)中随机取一个值")
print(result)
print(range.randomElement()!)
print(range.randomElement()!)
print(range.randomElement()!)
print(range.randomElement()!)

3）示例3

let good = "👍🏾"
print(good)
print(good.unicodeScalars.first!.description)
print(good.unicodeScalars.last!.description)

二十、switch流程控制

switch是一个强大的控制流语句，用于匹配多个可能的值并执行相应的代码块。与其他一些编程语言不同。

1.示例1

将以下内容，改为使用switch实现。

let age = 7

if (age <= 2){
    print("婴儿")
} else if (age <= 5){
    print("幼儿")
} else if (age <= 12){
    print("儿童")
} else if (age <= 18){
    print("青少年")
} else if (age < 60){
    print("成年人")
} else {
    print("老年人")
}

// 条件式流程控制：Switch

let age = 7

switch age {
    case ...2:
        print("婴儿")
    case ...5:
        print("幼儿")
    case ...12:
        print("儿童")
    case ...18:
        print("青少年")
    case ..<60:
        print("成年人")
    default:
        print("老年人")
}

2.示例2

// 条件式流程控制：Switch

let 相亲对象 = ("李诗诗", 165)

switch (相亲对象){
    case (let 名字, 165...):
        print("可以安排和\(名字)见面")
    default:
        print("可以当朋友")
    break
}

增加where子句

// 条件式流程控制：Switch

let 相亲对象 = ("李诗诗", 165)

switch (相亲对象){
    case (let 名字, 165...) where 名字.first != "李":
        print("可以安排和\(名字)见面")
    default:
        print("可以当朋友")
    break
}

二十一、Array数组

Array是一种用于存储相同类型值的有序集合。

1.建立Array

// 建立空Array
let 电话本: Array<String> = []
let 电话本1: [String] = []
let 电话本2 = Array<String>()
let 电话本3 = [String]()

//建立有值的Array
let 妈妈电话 = "13787665456"
let 爸爸电话 = "13887665675"
let 主管电话 = "13987667676"
let 电话本4: [String] = [ 妈妈电话, 爸爸电话, 主管电话 ]
let 电话本5 = Array<String>([妈妈电话,爸爸电话,主管电话])
let 电话本6 = [妈妈电话,爸爸电话,主管电话]

print(电话本4)
print(电话本5)
print(电话本6)

2.示例1

let 妈妈电话 = "13787665456"
let 爸爸电话 = "13887665675"
let 主管电话 = "13987667676"

var 电话本 = [String]()
电话本.append(妈妈电话)
print(电话本)

3.示例2

let 妈妈电话 = "13787665456"
let 爸爸电话 = "13887665675"
let 主管电话 = "13987667676"

var 电话本 = [String]()
电话本.append(妈妈电话)
print(电话本)
电话本.append(爸爸电话)
print(电话本)
//在指定位置插入，从0开始数，也就是在第二个位置插入
电话本.insert(主管电话, at: 1)
print(电话本)

4.示例3

let 妈妈电话 = "13787665456"
let 爸爸电话 = "13887665675"
let 主管电话 = "13987667676"

var 电话本 = [String]()
电话本.append(妈妈电话)
电话本.append(爸爸电话)
//在指定位置插入，从0开始数，也就是在第二个位置插入
电话本.insert(主管电话, at: 1)

//修改Array的值
电话本[0] = "妈妈电话"
print(电话本[0])
电话本[1...2] = ["主管电话","爸爸电话"]
print(电话本)
print(电话本.joined(separator: " & "))

5.示例4

let 妈妈电话 = "13787665456"
let 爸爸电话 = "13887665675"
let 主管电话 = "13987667676"

var 电话本 = [String]()
电话本.append(妈妈电话)
电话本.append(爸爸电话)
//在指定位置插入，从0开始数，也就是在第二个位置插入
电话本.insert(主管电话, at: 1)
print(电话本)

//删除Array的值
电话本.remove(at: 0)
print(电话本)
电话本.removeFirst()
print(电话本)
电话本.removeFirst()
电话本.popLast()
print(电话本)

6.示例5

let numbers = [23, 177, 5, 9, 88]
print(numbers.min()!)
print(numbers.max()!)

var sortedNumber = numbers.sorted()
print(numbers)
print(sortedNumber)
sortedNumber = numbers.sorted(by: >)
print(sortedNumber)

二十二、for循环

for 循环是一种控制结构，用于反复执行代码块，直到特定条件不再满足为止。

1.示例1

for number in 0...5{
    print(number)
}

2.示例2

for number in 1...5{
    if (number % 2 == 0) { break }
    print(number)
}

3.示例3

for number in 1...5{
    if (number % 2 == 0) { continue }
    print(number)
}

4.示例4

let numbers = [23, 177, 5, 9, 88]

var minNumber = numbers.first!
for number in numbers {
    minNumber = number < minNumber ? number : minNumber
}
print(minNumber)

5.示例5

let numbers = [23, 177, 5, 9, 88]

var minNumber = numbers.first!
for number in numbers {
    minNumber = min(number, minNumber)
}
print(minNumber)

6.示例6

var numbers = [23, 177, 5, 9, 88, 11]

let range = 3...4
let replacement = 100
for index in range {
    numbers[index] = replacement
}
print(numbers)

7.示例7

var numbers = [23, 177, 5, 9, 88, 11]

let element = 5

for index in numbers.indices{
    let number = numbers[index]
    if number == element{
        print("这个值的位置在\(index)")
        break
    }
}

8.示例8

var numbers = [23, 177, 5, 9, 88, 11]

let element = 5

for index in 0...(numbers.count - 1){
    let number = numbers[index]
    if number == element{
        print("这个值的位置在\(index)")
        break
    }
}

9.示例9

var numbers = [23, 177, 5, 9, 88, 11]

for number in numbers {
    if (number > 50) {
        print(number)
    }
}

10.示例10

var numbers = [23, 177, 5, 9, 88, 11]

for number in numbers {
    if !(number > 50) { continue }
    print(number)
}

11.示例11

typealias Food = (name: String, price: Int, 饱食度:Int)

let 食物: [Food] = [
("番茄炒蛋饭", 15, 3),
("鸡腿饭", 18, 5),
("香肠鸡蛋饭", 15, 4),
("猪扒饭", 26, 8),
("瘦肉汤河粉", 12, 2),
("鸡蛋灌饼", 7, 1),
("黑椒牛排饭", 35, 10),
("白粥", 3, 1),
]

var 饱食度 = 20
var 钱 = 50

for food in 食物 {
    饱食度 -= 5
    print("经过了一天时间，当前小明的饱食度是：\(饱食度)")
    
    if(饱食度 < 0){
        print("小明身上还有\(钱)元，已经饿死了")
        break
    }
    if 钱 < food.price {
        print("小明身上只有\(钱)元，吃不起\(food.price)元的\(food.name)，饿到下一餐")
      
        continue
    }
    饱食度 += food.饱食度
    钱 -= food.price
    print("小明今天吃了\(food.name)，当前饱食度是\(饱食度)，身上还剩下\(钱)元")
}

二十三、for嵌套循环

嵌套循环是指在一个循环内部再嵌套一个或多个循环。这种结构可以用于处理多维数据、复杂的条件判断等场景。

1.示例1

let 轮班人员 = ["张三", "李四", "王五"]
let 每日流程 = ["打扫", "整理档案", "报告事项"]

for 人 in 轮班人员 {
    for 工作 in 每日流程 {
        print("\(人)开始进行\(工作)")
    }
    print("--------")
}

2.示例2

let 轮班人员 = ["张三", "李四", "王五"]
let 每日流程 = ["打扫", "整理档案", "报告事项"]

let 失火了 = true

轮班: for 人 in 轮班人员 {
    流程:for 工作 in 每日流程 {
        print("\(人)开始进行\(工作)")
        if (失火了) {
            print("失火了🔥，大家快逃命。")
            break 轮班
        }
    }
    print("--------")
}

3.示例3

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票集合 = [true, false, true, false, true, false, false]

var 支持票数 = 0.0

for 支持 in 投票集合 {
    if (支持) { 支持票数 += 1 }
}

let 支持率 = Int(支持票数 / Double(投票集合.count) * 100)
    print("「\(投票内容)」支持率：\(支持率)%")

4.示例4

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票集合 = [true, false, true, false, true, false, false]

let 投票内容2 = "宿舍安装空调"
let 投票集合2 = [true, false, true, true, true, false, false]

var 支持票数 = 0.0

for 支持 in 投票集合 {
    if (支持) { 支持票数 += 1 }
}

var 支持率 = Int(支持票数 / Double(投票集合.count) * 100)
    print("「\(投票内容)」支持率：\(支持率)%")

支持票数 = 0

for 支持 in 投票集合2 {
    if (支持) { 支持票数 += 1 }
}

 支持率 = Int(支持票数 / Double(投票集合2.count) * 100)
    print("「\(投票内容2)」支持率：\(支持率)%")

5.示例5

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票集合 = [true, false, true, false, true, false, false]
let 投票内容2 = "宿舍安装空调"
let 投票集合2 = [true, false, true, true, true, false, false]

let 投票内容集合 = [投票内容, 投票内容2]

for 投票项目 in 投票内容集合 {
    var 支持票数 = 0.0
    
    for 支持 in 投票集合 {
        if (支持) { 支持票数 += 1 }
    }
    
    var 支持率 = Int(支持票数 / Double(投票集合.count) * 100)
    print("「\(投票项目)」支持率：\(支持率)%")
    
}

6.示例6

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票内容2 = "宿舍安装空调"
let 投票集合 = [
    [true, false, true, false, true, false, false],
    [true, false, true, true, true, false, false]
]

let 投票内容集合 = [投票内容, 投票内容2]

for index in 投票内容集合.indices {
    let 投票项目 = 投票内容集合[index]
    var 支持票数 = 0.0
    
    for 支持 in 投票集合[index] {
        if (支持) { 支持票数 += 1 }
    }
    
    let 支持率 = Int(支持票数 / Double(投票集合[index].count) * 100)
    print("「\(投票项目)」支持率：\(支持率)%")   
}

7.示例7

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票内容2 = "宿舍安装空调"
let 投票集合 = [
    [true, false, true, false, true, false, false],
    [true, false, true, true, true, false, false]
]

let 投票内容集合 = [投票内容, 投票内容2]

for index in 投票内容集合.indices {
    let 投票项目 = 投票内容集合[index]
    var 支持票数 = 0.0
    let 所有票 = 投票集合[index]
    
    for 支持 in 所有票 {
        if (支持) { 支持票数 += 1 }
    }
    
    let 支持率 = Int(支持票数 / Double(所有票.count) * 100)
    print("「\(投票项目)」支持率：\(支持率)%")
}

8.示例8

let 投票内容 = "宿舍门禁由22点改为23点"
let 投票内容2 = "宿舍安装空调"
let 投票集合 = [
    [true, false, true, false, true, false, false],
    [true, false, true, true, true, false, false]
]

let 投票内容集合 = [投票内容, 投票内容2]

for index in 投票内容集合.indices {
    let 投票项目 = 投票内容集合[index]
    var 支持票数 = 0.0
    let 所有票 = 投票集合[index]
    print(所有票)
    for voteIndex in 所有票.indices {
        let 支持 = 所有票[voteIndex]
        if (支持) {
            print("第\(voteIndex)票是支持的，所以 + 1")
            支持票数 += 1
        }
    }
    
    let 支持率 = Int(支持票数 / Double(所有票.count) * 100)
    print("「\(投票项目)」支持率：\(支持率)%")
}

二十四、while循环

while 循环是一种控制流语句，用于在某个条件为真时反复执行一段代码。当条件不再满足时，循环终止。while 循环有两种形式：while 循环和 repeat-while 循环。while 循环在每次迭代之前检查条件，而 repeat-while 循环在每次迭代之后检查条件。

1.示例1

let 目标金额 = 1_000_000
var 现在金额 = 0

while (现在金额 < 目标金额 ){
    //募资
    let donation = (1...30000).randomElement()!
    现在金额 += donation
}
print("募资成功！募得\(现在金额)元。")

2.示例2

let age = 20
var guess = Int.random(in: 15...45)

while (age != guess){
    //重复猜
    print("不是\(guess)岁～继续猜～")
    guess = Int.random(in: 15...45)
}
print("答对了～就是\(age)岁")

3.示例3

let age = 20
var 下限 = 15
var 上限 = 45
var guess = Int.random(in: 下限...上限)

while (age != guess){
    //重复猜
    if (guess > age){
        上限 = guess - 1
    } else { 下限 = guess + 1}
    print("不是\(guess)岁～是在\(下限)到\(上限)岁，继续猜～")
    guess = Int.random(in: 下限...上限)
}
print("答对了～就是\(age)岁")

4.示例4

let age = 20
var 下限 = 15
var 上限 = 45
var guess = Int.random(in: 下限...上限)
repeat {
    //先至少执行一遍
    if (guess > age){
        上限 = guess - 1
    } else { 下限 = guess + 1}
    print("不是\(guess)岁～是在\(下限)到\(上限)岁，继续猜～")
    guess = Int.random(in: 下限...上限)
} while (age != guess)
print("答对了～就是\(age)岁")

二十五、Set集合

Set 是一种集合类型，用于存储唯一值的无序集合。与数组不同，集合中的元素是无序的，并且每个元素只能出现一次。Set 是一个泛型集合，因此它可以存储任何遵循 Hashable 协议的类型。

1.建立

//建立Set
var set: Set<String> = []
let set2 = Set<Int>()
let set3 = Set(["苹果"])

2.新增

//新增
var set: Set<String> = []
set.insert("苹果")
print(set)
set.update(with: "香蕉")
print(set)
set.insert("苹果")
print(set)
set.update(with: "香蕉")
print(set)

3.删除

//删除
var set: Set<String> = []
set.insert("苹果")
set.update(with: "香蕉")
print(set)

set.remove("苹果")
set.remove("苹果")
set.remove("苹果")
set.removeAll()
print(set)

4.array转Set

//array转Set
let array = ["香蕉", "苹果", "香蕉"]

let set = Set(array)
print(set)

5.集合运算示例

let 目的地: Set<String> = ["广东", "广西", "湖北", "湖南", "福建",
                        "山东", "台湾", "海南", "河南", "河北",
                        "西藏", "新疆", "内蒙古", "黑龙江", "云南"
]

let 爸爸: Set<String> = ["广东", "广西", "台湾", "海南"]
let 妈妈: Set<String> = ["西藏", "新疆", "台湾", "海南"]
let 女儿: Set<String> = ["内蒙古", "黑龙江", "西藏", "台湾"]
let 儿子: Set<String> = ["湖北", "湖南", "台湾", "西藏"]

//爸爸和妈妈都想去的地方
print(爸爸.intersection(妈妈))

//爸爸想去但妈妈不想去的地方
print(爸爸.subtracting(妈妈))

//妈妈想去但爸爸不想去的地方
print(妈妈.subtracting(爸爸))

//爸爸和妈妈想去的地方的差集
print(爸爸.symmetricDifference(妈妈))

//大家都想要去的地方
print(爸爸.intersection(妈妈).intersection(女儿).intersection(儿子))

//至少有一个人想去的地方
let 至少有一个人想去 = 爸爸.union(妈妈).union(女儿).union(儿子)
print(至少有一个人想去)

//没有人想去的地方
print(目的地.symmetricDifference(至少有一个人想去))

二十六、Dictionary

Dictionary（字典）是一种集合类型，用于存储键值对。每个键（key）都是唯一的，与其关联的值（value）可以是任何类型。

1.示例1

// Dictionary
// 基本操作：建立、新增、修改、删除

var 水果库存 = [String: Int]()
水果库存["苹果"] = 3
print(水果库存)
水果库存.updateValue(4, forKey: "苹果")
水果库存.updateValue(2, forKey: "香蕉")
print(水果库存)
水果库存["苹果", default: 0] += 5
print(水果库存)
水果库存.removeValue(forKey: "香蕉")
print(水果库存)

2.示例2

let 水果库存 = ["苹果": 3, "香蕉": 10, "奇异果": 4]

for pair in 水果库存 {
    print(pair)
}

3.示例3

let 水果库存 = ["苹果": 3, "香蕉": 10, "奇异果": 4]

for (名称, 数量) in 水果库存 {
    print(名称, 数量)
}

原文地址：https://blog.csdn.net/weixin_43465752/article/details/139249050

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！