//一、声明常量和变量
//1.用let关键字声明常量，用关键字声明变量var

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

//可以在一行中声明多个常量或多个变量，用逗号分隔：

var x = 0.0, y = 0.0, z = 0.0

//2.类型注释
//通过在常量或变量名称之后放置一个冒号，然后是一个空格，然后是要使用的类型的名称来编写类型注释。

var welcomeMessage: String
welcomeMessage = "Hello World!"

//可以在一行中定义多个相同类型的相关变量，以逗号分隔，并在最终变量名称后使用单个类型注释：

var red, green, blue: Double
red = 1.0
green = 2.0
blue = 3.0

//3.命名常量和变量
//常量和变量名称几乎可以包含任何字符，包括 Unicode 字符：

let π = 3.14159
let 你好 = "你好世界"
let 🐶🐮 = "dogcow"

//常量和变量名称不能包含空格字符、数学符号、箭头、专用 Unicode 标量值或线条和方框图字符。它们也不能以数字开头，尽管数字可能包含在名称的其他地方。
//与变量不同，常量的值在设置后不能更改

//4.打印常量和变量
//可以使用以下print(_:separator:terminator:)函数打印常量或变量的当前值：
//默认情况下，该函数通过添加换行符来终止它打印的行。要打印一个没有换行符的值，请传递一个空字符串作为终止符
print(red)

//二.注释
//单行注释以两个正斜杠 ( //)开头：

// This is a comment.

//多行注释以正斜杠开头，后跟星号 ( /*)，以星号结尾，后跟正斜杠 ( */)：

/* This is also a comment
but is written over multiple lines. */

//与 C 中的多行注释不同，Swift 中的多行注释可以嵌套在其他多行注释中。

/* This is the start of the first multiline comment.
 /* This is the second, nested multiline comment. */
This is the end of the first multiline comment. */

//分号
//Swift 不要求您在代码中的每个语句之后编写分号
//要在一行中编写多个单独的语句，则需要分号：

let cat = "🐱";print(cat)

//三.整数
//整数是没有小数部分的整数，例如42和-23。整数有符号（正、零或负）或无符号（正或零）。

//1.整数边界
//可以使用其min和max属性访问每个整数类型的最小值和最大值：

let minValue = UInt8.min  // minValue is equal to 0, and is of type UInt8
let maxValue = UInt8.max  // maxValue is equal to 255, and is of type UInt8

//大多数情况下，您不需要选择特定大小的整数来在您的代码中使用。Swift 提供了一个额外的整数类型，Int，它的大小与当前平台的原生字大小相同：

//在 32 位平台上，Int与Int32.
//在 64 位平台上，Int与Int64.

//2.无符号整数类型
//Swift 还提供了一个无符号整数类型，UInt它的大小与当前平台的原生字大小相同：
//

//在 32 位平台上，UInt与UInt32.
//在 64 位平台上，UInt与UInt64.

//四、浮点数字
//浮点数是具有小数部分的数字，例如3.14159，0.1，和-273.15。
//浮点类型可以表示比整数类型更广泛的值，并且可以存储比Int. Swift 提供了两种有符号浮点数类型：

//Double 表示 64 位浮点数。
//Float 表示一个 32 位浮点数。

//五、类型安全和类型推断

//Swift在推断浮点数的类型时总是选择Double（而不是Float）。

//六、进制转换
//整数文字可以写成：

//一个十进制数，没有前缀
//一个二进制数，有0b前缀
//一个八进制数，带0o前缀
//一个十六进制数，有0x前缀
let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation

//浮点文字可以是十进制（没有前缀）或十六进制（有0x前缀）。它们的小数点两侧必须始终有一个数字（或十六进制数）。
//十进制浮点数也可以有一个可选的指数，由大写或小写表示e；十六进制浮点数必须有一个指数，由大写或小写表示p。
//1.对于指数为 的十进制数exp，基数乘以 10 exp：

// 1.25e2表示 1.25 x 10 2，或125.0。
// 1.25e-2表示 1.25 x 10 -2，或0.0125。

let decimal = 1.25e2
let decimalFloat = 1.25e-2

//2.对于指数为 的十六进制数exp，基数乘以 2 exp：

//
//0xFp2表示 15 x 2 2，或60.0。
//0xFp-2表示 15 x 2 -2，或3.75。
let hexadecimal = 0xFp2
let hexadecimalFload = 0xFp-2

//七、数字类型转换
//1.整数转换

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
//let twoThousandAndOne = UInt8(twoThousand) + one

//2.整数和浮点转换

//整数和浮点数值类型之间的转换必须明确：
let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
let integerPi = Int(pi)

//八、类型别名
//可以使用typealias关键字定义类型别名。

typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min

//此处，AudioSample定义为UInt16的别名。因为它是一个别名，调用AudioSample.min实际调用UInt16.min。

//九、布尔值
//Swift 有一个基本的布尔类型，称为Bool. 布尔值被称为逻辑值，因为它们只能为真或假。
//Swift 提供了两个布尔常量值，true以及false：

//十、元组（Tuples）
//元组将多个值分组为一个复合值。元组中的值可以是任何类型，并且不必彼此具有相同的类型。

let http404Error = (404, "Not Found")

//可以将元组的内容分解为单独的常量或变量，然后您可以像往常一样访问它们

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
print("The status message is \(statusMessage)")

//如果您只需要元组的某些值，在分解元组时使用带有下划线_的部分元组忽略该值：

let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")

//使用从零开始的索引号访问元组中的各个元素值：

print("The status code is \(http404Error.0)")
print("The status message is \(http404Error.1)")

//可以在定义元组时命名元组中的各个元素，使用元素名称访问这些元素的值：

let http200Status = (statusCode: 200, description: "OK")

print("The status code is \(http200Status.statusCode)")
print("The status message is \(http200Status.description)")

//十一、可选项
//1.nil
//可以通过为其分配特殊值来将可选变量设置为无值状态nil：

var serverResponseCode: Int? = 404
serverResponseCode = nil

//如果您定义了一个可选变量而不提供默认值，该变量将自动为您设置nil：

var surveyAnswer: String?

//备注：
//在 Objective-C 中，nil是指向不存在对象的指针。
//在 Swift 中，nil不是指针——它是某种类型的值的缺失。任何类型可以设置为nil，不只是对象类型。

//2.强制解包
//如果一个可选项有一个值，它被认为是“不等于” nil：

var convertedNumber: String? = "1"
if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
}

//一旦您确定可选项确实包含一个值，您就可以通过在可选项名称的末尾添加一个感叹号(!) 来访问其基础值。
//感叹号有效地表示，“我知道这个可选项肯定有一个值；请使用它。” 这被称为可选值的强制展开：

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}

//3.可选绑定
//为if语句编写可选绑定，如下所示：

//if let constantName = someOptional {
//    statements
//}

//var possibleNumber: String? = "4"
var possibleNumber = "4b"
if let actualNumber = Int(possibleNumber) {
    print("The string \"\(possibleNumber)\" has an integer value of \(actualNumber)")
} else {
    print("The string \"\(possibleNumber)\" couldn't be converted to an integer")
}

//这段代码可以读作：
//如果Int返回的可选Int(possibleNumber)值包含一个值，则设置一个新常量，调用该actualNumber可选值中包含的值。”

//您可以根据需要在单个if语句中包含任意数量的可选绑定和布尔条件，并用逗号分隔。
//如果可选绑定中的任何值是nil或任何布尔条件的计算结果为false，则整个if语句的条件被视为false。
//以下if语句是等效的：

if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
    print("\(firstNumber) < \(secondNumber) < 100")
}

if let firstNumber = Int("4") {
    if let secondNumber = Int("42") {
        if firstNumber < secondNumber && secondNumber < 100 {
            print("\(firstNumber) < \(secondNumber) < 100")
        }
    }
}

//4.可选项的隐式展开
//有时，从程序的结构中可以清楚地看出，在首次设置该值之后，可选项将始终具有一个值。
//在这些情况下，消除每次访问可选值时检查和解包的需要很有用，因为可以安全地假设它始终具有值。
//通过在要设为可选的类型之后放置一个感叹号 ( String!) 而不是问号 ( String?) 来编写一个可选的隐式展开
//当您使用它时，与其在可选项的名称后面放置一个感叹号，不如在声明它时在可选项的类型后面放置一个感叹号。

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 要求必须解包

//在下面的代码中，optionalString没有明确的类型，所以它是一个普通的可选。不要求解包

let optionalString = possibleString

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // 不要求解包

//十二、错误处理
//当函数遇到错误条件时，它会抛出错误。然后该函数的调用者可以捕获错误并做出适当的响应。

//func canThrowAnError() throws {
//    // this function may or may not throw an error
//}

//十三、断言和前提条件
//断言和前提条件之间的区别在于检查它们的时间：
//断言仅在调试版本中检查，但前提条件在调试版本和生产版本中都进行检查。
//在生产版本中，不评估断言内的条件。这意味着您可以在开发过程中使用任意数量的断言，而不会影响生产中的性能。
//1.使用断言调试
//您可以通过调用assert(::file:line:)Swift 标准库中的函数来编写断言

//let age = -3
let age = 5
assert(age >= 0, "A person's age can't be less than zero.")

//在此示例中，如果计算结果值为非负，则代码继续执行。
//如果计算结果的值为负，则上面的代码评估为断言失败，终止应用程序

//如果代码已经检查了条件，则使用该assertionFailure(_:file:line:)函数来指示断言失败

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 5 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than five.")
}

//2.执行前提条件
//您可以通过调用precondition(::file:line:)函数来编写前提条件。
//您向该函数传递一个计算结果为trueorfase的表达式，条件结果为false时，显示一条错误消息
//您的代码必须绝对为真才能继续执行

let index = 10
precondition(index > 0, "Index must be greater than zero.")

//如果代码已经检查了条件，则使用该preconditionFailure(_:file:line:)函数来指示失败

if index < 5 {
//    preconditionFailure("Index must be greater than five.")
    fatalError("Index must be greater than five.")
}

//备注：
//如果您在未检查模式(-Ounchecked)下编译，则不会检查前提条件。编译器假定前提条件始终为真，并相应地优化您的代码。
//但是，fatalError(_:file:line:)无论是否设置未检查模式(-Ounchecked)，该函数始终会停止执行。

print("every thing is good!")