let nickName: String? = nil
// 更简洁的语法来解析一个值
if let nickName {
print("hello (nickName)")
}
// switch 语句支持任意类型的数据和多种比较操作 ---- 不仅限于整数和等值比较
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasPrefix("pepper"): ////////////////
print("Is it a spicy (x)?")
default:
print("Everything tastes good in soup.")
}
///!!!运行 switch中匹配到的 case语句之后，程序会退出 switch语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。
//使用元组来创建复合值——例如，用于从函数中返回多个值。元组的元素可以通过名称或编号来引用。
func calculateStatistics(scores: [Int]) ->(min: Int, max: Int, sum: Int) {
var min = scores[0]
var max = scores[1]
var sum = min + max
return (min, max, sum)
}
let s = calculateStatistics(scores: [0,0,0])
print(s.sum)
let numbers = [2,1,24,4]
let mappNumbers = numbers.map({ number in 3*number})
print(mappNumbers)
class EquilateralTriangle {
var sideLength: Double = 0.0
var square: Double {
get {
return 3.0 * sideLength
}
set {//在 perimeter的 setter中，新值有一个默认的名字 newValue。你可以在 set后的括号中显式地指定一个名字。
sideLength = newValue / 3.0
}
}
}
//使用 enum来创建枚举。与类和其他所有命名类型一样，枚举也可以包含方法。
//使用 async标记异步运行的函数。
func fetchUserId(form server: String) async ->Int {
if server == "primary" {
return 97
}
return 100
}
func fetchUserName(form server: String) async ->String {
// let userId = await fetchUserId(form: server)//... await
async let userId = fetchUserId(form: server)
if await userId == 501 {
return "1"
}
return "2"
}
//使用 Task从同步代码中调用异步函数且不等待它们的返回结果。
Task {
await fetchUserId(form: "")
}
let userIds = await withTaskGroup(of: Int.self) { group in
for server in ["ss"] {
group.addTask {
return await fetchUserId(form: server)
}
}
var results: [Int] = []
for await result in group {
results.append(result)
}
return results
}
///// actor 和类很相似，它可以确保同一时刻不同的异步函数可以安全地与同一个actor的实例交互
actor ServerConnection {
var server: String = "primary"
private var activeUsers: [Int] = []
func connect() async ->Int {
let userid = await fetchUserId(form: server)
activeUsers.append(userid)
return userid
}
}
let server = ServerConnection()
let userid = await server.connect()
/////////协议和扩展
///
protocol ExapmpleProtocol {
var simpleDescription: String {get}
mutating func adjust()
}
// 类 结构体 枚举都可以遵循协议
// 错误处理 你可以使用任何遵循 Error协议的类型来表示错误。
enum PrintError: Error {
case outOfPaper
case noToner
case onFire
}
// 使用throws 来抛出错误，并使用throws标记可能抛出错误的函数，如果在函数中抛出错误，。函数会立即返回，并由调用该函数的代码来处理这个错误
func send(job: Int, toPrinter printerName: String) throws ->String {
if printerName == "" {
throw PrintError.noToner
}
return "job sent"
}
// 错误处理 1 do catch 2 throw 3 try?
do {
let printerResponse = try send(job: 1020, toPrinter: "ddd")
} catch { //在 catch代码块中，除非你另外命名，否则错误会被默认命名为 er
print(error)
}
// 可以提供多个catch块来处理特定的错误，和Switch中的case的写法一样，在catch后写匹配模式
do {
let printerResponse = try send(job: 1020, toPrinter: "ddd")
print(printerResponse)
} catch PrintError.onFire {
} catch let printerError as PrintError {
print("ccccc(printerError)")
} catch {
print(error)
}
let printer = try? send(job: 1992, toPrinter: "add")
//defer: 使用defer代码块表示在函数返回前，函数中最后执行的代码，无论函数是否会抛出错误，这段代码都会执行，使用defer代码可以把初始代码和扫尾代码写在一起，即使他们在不同的时机执行
//泛型 在尖括号里写一个名字来创建一个泛型函数或者泛型类型
func makeArray(repeating item: Item, numberOfTimes: Int) ->[Item] {
var reslut: [Item] = []
for _ in 0..<numberOfTimes {
reslut.append(item)
}
return reslut
}
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool where T.Element: Equatable, T.Element == U.Element{
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}
}
}
return false
}
print(anyCommonElements([1, 2, 3], [3]))
