文章目录

  • swift入门必看(1)
  • 常量变量
  • 数据类型
  • 元组
  • 选项集合
  • OptionSet 是什么
  • 如何使用
  • nil
  • 值溢出符
  • 合并空值运算符
  • 区间运算符


swift入门必看(1)

持续更新中…

常量变量

let 定义常量，var 定义变量。类似javascript

let max:Int=100
var min:Int=1
max=200

会报错

MyPlaygroundDemo.playground:5:1: note: change 'let' to 'var' to make it mutable
let max:Int=100
^~~
var

数据类型

swift定义了Int与UInt的8，16，32，64的有符号或无符号类型
Double与Float的浮点数

swift 列表查找_配置项


Bool做布尔类型,true或false 类型别名


typealias ID=UInt32
let Tom:ID=2034298621
print(ID.max,"  ",ID.min)

元组

Tuple可以把多个不同类型的值合并为一个复合型的值，可以作为函数返回值

let error=(code:404 as UInt16,errorMessage:"404 Not Found" as String)
print(error.code," ",error.errorMessage)
let (code,message)=error
print(code," ",message)

注意元组在创立后可以修改，但不能改变类型

var error2:(code:UInt16,errorMessage:String)=(code:404,errorMessage:"404 Not Found")
error2.code=405
error2.errorMessage="Method Not Allowed"
print(error2.code," ",error2.errorMessage)

选项集合

Swift 中的 OptionSet 允许你定义一组关于配置的选项，每个选项只会占用一个比特位。从作用上来看，它等同于 Objective-C 中的 NS_OPTIONS。
从形式上来看，OptionSet 跟枚举很相似。但它们使用场景是不同的。
对于枚举，通常我们只会使用其单一的某个值。比如下面的关于等级的枚举：

enum Level {
    case high
    case medium
    case low
}

当我们使用的时候，通常只会用到某一个 case，不会存在某个条件既 high 又 low 的情况。

而对于 OptionSet ，通常都是使用多个值来进行配置的。比如 WritingOptions 的使用：

data = try JSONSerialization.data(withJSONObject: messageWrapper, options: [.prettyPrinted, .sortedKeys])

OptionSet 是什么

OptionSet 是 Swift 标准库的一个协议。它代表的是比特集的类型，每一位比特代表了一个选项。
如果自定义类型遵守了该协议，则该类型可以执行与集合相关的操作，比如网络配置项、本地缓存配置项等等。更重要的是，当使用特定标准实现时，遵守该协议并不需要你写额外的代码。

如何使用

当创建选项集的时候，首先，自定义类型必须包含一个名字为 rawValue 的属性，且该类型必须遵守了 FixedWidthInteger 协议，比如 Int 或者 UInt8 。
然后，再去创建静态属性的每个配置项，且每个配置项需唯一。每个配置项的原始值依次为 1/2/4/16等等。
原始值解释：


1 << 0 代表不移动，2 的零次方为 1
1 << 1 代表挪动一位，2 的 1 次方为 2
以此类推

下面是一个缓存库的配置项示例代码：

struct CacheOptions: OptionSet {
    let rawValue: Int
    
    static let memory = CacheOptions(rawValue: 1 << 0)
    static let disk = CacheOptions(rawValue: 1 << 1)
    static let autoClear = CacheOptions(rawValue: 1 << 2)
}

下面是使用的三种方式：

赋值空选项：

let noOptions: CacheOptions = []

赋值单个选项：

let singleOption: CacheOptions = .memory

赋值多个选项：

let multipleOptions: CacheOptions = [.memory, .autoClear]

nil

demo1

var str: String? = "Hello, world"

if let unwrappedStr = str {
    // 这里可以安全地操作非nil的字符串
    print(unwrappedStr)
} else {
    // str 是nil，执行这里的代码
    print("str is nil")
}

可选链demo2

class Person {
    var name: String
    var address: Address?
    
    init(name: String) {
        self.name = name
    }
}

class Address {
    var street: String
    
    init(street: String) {
        self.street = street
    }
}

// 创建一个可选的 Person 对象
let person: Person? = Person(name: "John")

// 使用可选链安全地访问属性
let street = person?.address?.street

// 打印结果，如果 person、address 或 street 任何一个为 nil，则结果为 nil
if let street = street {
    print("Street: \(street)")
} else {
    print("Street is nil")
}

用以下typescript表示为
demo1

let str: string | null = "Hello, world";

if (str !== null) {
    // 这里可以安全地操作非null的字符串
    console.log(str);
} else {
    // str 是null，执行这里的代码
    console.log("str is null");
}

可选链demo2

class Person {
    name: string;
    address?: Address;
    
    constructor(name: string) {
        this.name = name;
    }
}

class Address {
    street: string;
    
    constructor(street: string) {
        this.street = street;
    }
}

// 创建一个可选的 Person 对象
const person: Person | undefined = new Person("John");

// 使用可选链安全地访问属性
const street = person?.address?.street;

// 打印结果，如果 person、address 或 street 任何一个为 undefined，则结果为 undefined
if (street !== undefined) {
    console.log(`Street: ${street}`);
} else {
    console.log("Street is undefined");
}


1.swift和typescript在处理空值方面有相似之处
2.所有在Swift nil 与OC 里面的 nil 是有区别的， Swift 里面的nil 对象 不能对其作操作 只能判断是否为 nil（例如str ==nil or str != nil）只有确定对象不为nil 的情况下 才能对对象进行操作，否则则会crash。

值溢出符

swift赋值超过容量时会报错，提供安全性

Swift 提供了一些溢出运算符，用于执行整数类型之间的溢出运算。这些运算符可以用于处理在运算过程中可能导致溢出的情况。Swift 中的溢出运算符包括以下几种：

  1. 溢出加法运算符 &+：用于执行整数相加操作，如果结果溢出了整数类型的范围，将会产生溢出值。
let maxInt = Int.max
let overflowResult = maxInt &+ 1 // 溢出，结果为最小的负数
  1. 溢出减法运算符 &-：用于执行整数相减操作，如果结果溢出了整数类型的范围，将会产生溢出值。
let minInt = Int.min
let overflowResult = minInt &- 1 // 溢出，结果为最大的正数
  1. 溢出乘法运算符 &*：用于执行整数相乘操作，如果结果溢出了整数类型的范围，将会产生溢出值。
let maxInt = Int.max
let overflowResult = maxInt &* 2 // 溢出，结果为负数

合并空值运算符

Swift 中的合并空值运算符是 ??，它允许你在处理可选值时提供一个默认值，以防可选值为 nil。合并空值运算符的语法如下：

let result = optionalValue ?? defaultValue

其中：

optionalValue 是一个可选值，可能为 nil 或具有某个值。
defaultValue 是一个在 optionalValue 为 nil 时将被使用的默认值。
如果 optionalValue 不为 nil，那么 result 将等于 optionalValue 的值。如果 optionalValue 为 nil，那么 result 将等于 defaultValue。

以下是一个示例：

let userInput: String? = nil
let greeting = "Hello, " + (userInput ?? "Guest")
// 如果 userInput 不为 nil，greeting 将等于 "Hello, " + userInput 的值；否则，它将等于 "Hello, Guest"

在上面的示例中，如果 userInput 是 nil，则默认使用 “Guest”。

合并空值运算符是处理可选值的一种便捷方式，它允许你提供一个备用值，以确保在处理可选值时不会导致空值错误。这对于在代码中提供默认值或处理用户输入等情况非常有用。

区间运算符

Swift 中有几种不同类型的区间运算符，用于表示和操作范围或序列。以下是其中一些常见的区间运算符：

  1. 闭区间运算符 a…b：表示从 a 到 b（包括 a 和 b）的所有值的范围。
let closedRange = 1...5 // 表示 1, 2, 3, 4, 5
  1. 半开区间运算符 a…<b：表示从 a 到 b 的所有值，但不包括 b。
let halfOpenRange = 1..<5 // 表示 1, 2, 3, 4
  1. 单侧区间运算符 a… 和 …b：表示从 a 开始（包括 a）到无穷大或从负无穷小到 b 结束（包括 b）的范围。
let fromOne = 1...
let upToFive = ...5

这些区间运算符可用于循环、集合筛选和其他需要操作范围的地方。例如：

for number in 1...5 {
    print(number) // 会打印 1, 2, 3, 4, 5
}

let numbers = [1, 2, 3, 4, 5]
let filteredNumbers = numbers.filter { $0 > 2 && $0 < 5 }
// filteredNumbers 将包含 [3, 4]
numbers.reversed()//倒序