当前位置： 首页 > news >正文

swift-17-字面量协议、模式匹配、条件编译

news 2025/7/8 3:40:22

一、字面量（ Literal ）

var age = 10
var isRed = false
var name = "Jack"上面代码中的10、 false、 "Jack"就是字面量常见字面量的默认类型public typealias IntegerLiteralType = Intpublic typealias FloatLiteralType = Doublepublic typealias BooleanLiteralType = Boolpublic typealias StringLiteralType = String// 可以通过typealias修改字面量的默认类型
typealias FloatLiteralType = Float
typealias IntegerLiteralType = UInt8
var age = 10 // UInt8
var height = 1.68 // FloatSwift自带的绝大部分类型，都支持直接通过字面量进行初始化Bool、 Int、 Float、 Double、 String、 Array、 Dictionary、 Set、 Optional等

二、字面量协议

Swift自带类型之所以能够通过字面量初始化，是因为它们遵守了对应的协议

 Bool : ExpressibleByBooleanLiteralInt : ExpressibleByIntegerLiteralFloat、 Double : ExpressibleByIntegerLiteral、 ExpressibleByFloatLiteralDictionary : ExpressibleByDictionaryLiteralString : ExpressibleByStringLiteralArray、 Set : ExpressibleByArrayLiteralOptional : ExpressibleByNilLiteralvar b: Bool = false // ExpressibleByBooleanLiteral
var i: Int = 10 // ExpressibleByIntegerLiteral
var f0: Float = 10 // ExpressibleByIntegerLiteral
var f1: Float = 10.0 // ExpressibleByFloatLiteral
var d0: Double = 10 // ExpressibleByIntegerLiteral
var d1: Double = 10.0 // ExpressibleByFloatLiteral
var s: String = "jack" // ExpressibleByStringLiteral
var arr: Array = [1, 2, 3] // ExpressibleByArrayLiteral
var set: Set = [1, 2, 3] // ExpressibleByArrayLiteral
var dict: Dictionary = ["jack" : 60] // ExpressibleByDictionaryLiteral
var o: Optional<Int> = nil // ExpressibleByNilLiteral

三、字面量协议应用

extension Int : ExpressibleByBooleanLiteral {
public init(booleanLiteral value: Bool) { self = value ? 1 : 0 }
}
var num: Int = true print(num) // 1

class Student : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral, ExpressibleByStringLiteral,
CustomStringConvertible { var name: String = "" var score: Double = 0
required init(floatLiteral value: Double) { self.score = value }
required init(integerLiteral value: Int) { self.score = Double(value) }
required init(stringLiteral value: String) { self.name = value }
required init(unicodeScalarLiteral value: String) { self.name = value }
required init(extendedGraphemeClusterLiteral value: String) { self.name = value }
var description: String { "name=\(name),score=\(score)" }
}
var stu: Student = 90
print(stu) // name=,score=90.0 stu = 98.5
print(stu) // name=,score=98.5 stu = "Jack"
print(stu) // name=Jack,score=0.0
struct Point {
var x = 0.0, y = 0.0
}
extension Point : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral {
init(arrayLiteral elements: Double...) {
guard elements.count > 0 else { return }
self.x = elements[0]
guard elements.count > 1 else { return }
self.y = elements[1]
}
init(dictionaryLiteral elements: (String, Double)...) {
for (k, v) in elements {
if k == "x" { self.x = v }
else if k == "y" { self.y = v }
}
}
}
var p: Point = [10.5, 20.5]
print(p) // Point(x: 10.5, y: 20.5)
p = ["x" : 11, "y" : 22]
print(p) // Point(x: 11.0, y: 22.0)

四、模式（ Pattern ）

 什么是模式？
 模式是用于匹配的规则，比如switch的case、捕捉错误的catch、 if\guard\while\for语句的条件等


 Swift中的模式有
 通配符模式（ Wildcard Pattern ）
 标识符模式（ Identifier Pattern ）
 值绑定模式（Value-Binding Pattern ）
 元组模式（ Tuple Pattern ）
 枚举Case模式（ Enumeration Case Pattern ）
 可选模式（ Optional Pattern ）
 类型转换模式（Type-Casting Pattern ）
 表达式模式（ Expression Pattern ）

4.1 通配符模式（Wildcard Pattern ）

_ 匹配任何值

 _? 匹配非nil值

enum Life {
case human(name: String, age: Int?)
case animal(name: String, age: Int?)
}func check(_ life: Life) {
switch life {
case .human(let name, _):
print("human", name)
case .animal(let name, _?):
print("animal", name)
default:
print("other")
}
}check(.human(name: "Rose", age: 20)) // human Rose
check(.human(name: "Jack", age: nil)) // human Jack
check(.animal(name: "Dog", age: 5)) // animal Dog
check(.animal(name: "Cat", age: nil)) // othervar num: Int? = 10
switch num {
case let v?
print (v)
case nil:
print ("nil")
｝

4.2 标识符模式（ Identifier Pattern ）

var age = 10
let name = "jack"

4.3 值绑定模式（Value-Binding Pattern ）

let point = (3, 2)
switch point {
case let (x, y):
print("The point is at (\(x), \(y)).")
}

4.4 元组模式（ Tuple Pattern ）

let points = [(0, 0), (1, 0), (2, 0)]
for (x, _) in points {
print(x)
}let name: String? = "jack" let age = 18
let info: Any = [1, 2]
switch (name, age, info) {
case (_?, _ , _ as String):
print("case")
default:
print("default")
} // defaultvar scores = ["jack" : 98, "rose" : 100, "kate" : 86]
for (name, score) in scores {
print(name, score)
}

4.5 枚举Case模式（ Enumeration Case Pattern ）

if case语句等价于只有1个case的switch语句

let age = 2
// 原来的写法
if age >= 0 && age <= 9 {
print("[0, 9]")
}
// 枚举Case模式
if case 0...9 = age {
print("[0, 9]")
}
等价于
switch age {
case 0...9: print("[0, 9]")
default: break }guard case 0...9 = age else { return }
print("[0, 9]")let ages: [Int?] = [2, 3, nil, 5]
for case nil in ages { print("有nil值")
break
} // 有nil值let (x, 0)匹配后边的这个值为0的
let points = [(1, 0), (2, 1), (3, 0)]
for case let (x, 0) in points {
print(x)
} // 1 3

4.6 可选模式（ Optional Pattern ）

let age: Int? = 42
if case .some(let x) = age { print(x) }
if case let x? = age { print(x) }

let ages: [Int?] = [nil, 2, 3, nil, 5]
for case let age? in ages {
print(age)
} // 2 3 5等价于
let ages: [Int?] = [nil, 2, 3, nil, 5]
for item in ages {
if let age = item {
print(age)
}
} // 跟上面的for，效果是等价的
func check(_ num: Int?) {
switch num {
case 2?: print("2")
case 4?: print("4")
case 6?: print("6")
case _?: print("other")
case _: print("nil")
}
}
check(4) // 4
check(8) // other
check(nil) // nil

4.7 类型转换模式（Type-Casting Pattern ）

let num: Any = 6 switch num {
case is Int:
// 编译器依然认为num是Any类型
print("is Int", num)
//case let n as Int:
//    print("as Int", n + 1)
default:  break
}class Animal { func eat() { print(type(of: self), "eat") } }
class Dog : Animal { func run() { print(type(of: self), "run") } }
class Cat : Animal { func jump() { print(type(of: self), "jump") } }
func check(_ animal: Animal) {
switch animal {
case let dog as Dog:
dog.eat()
dog.run() case is Cat:
animal.eat() default: break
}
}
// Dog eat
// Dog run
check(Dog())
// Cat eat
check(Cat())

4.8 表达式模式（ Expression Pattern ）

可以通过重载运算符，自定义表达式模式的匹配规则

struct Student {
var score = 0, name = ""
static func ~= (pattern: Int, value: Student) -> Bool { value.score >= pattern }
static func ~= (pattern: ClosedRange<Int>, value: Student) -> Bool { pattern.contains(value.score) }
static func ~= (pattern: Range<Int>, value: Student) -> Bool { pattern.contains(value.score) }
}var stu = Student(score: 75, name: "Jack")
switch stu {
case 100: print(">= 100")
case 90: print(">= 90")
case 80..<90: print("[80, 90)")
case 60...79: print("[60, 79]")
case 0: print(">= 0")
default: break } // [60, 79]if case 60 = stu {
print(">= 60")
} // >= 60var info = (Student(score: 70, name: "Jack"), "及格") switch info {
case let (60, text): print(text)
default: break } // 及格

4.9 自定义表达式模式

extension String {
static func ~= (pattern: (String) -> Bool, value: String) -> Bool {
pattern(value)
}
}func hasPrefix(_ prefix: String) -> ((String) -> Bool) { { $0.hasPrefix(prefix) } }
func hasSuffix(_ suffix: String) -> ((String) -> Bool) { { $0.hasSuffix(suffix) } }var str = "jack"
switch str {
case hasPrefix("j"), hasSuffix("k"):
print("以j开头，以k结尾") default: break
} // 以j开头，以k结尾
func isEven(_ i: Int) -> Bool { i % 2 == 0 }
func isOdd(_ i: Int) -> Bool { i % 2 != 0 }extension Int {
static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
pattern(value)
}
}var age = 9  switch age { case isEven:
print("偶数") case isOdd:
print("奇数") default:
print("其他") }prefix operator ~>
prefix operator ~>=
prefix operator ~<
prefix operator ~<=
prefix func ~> (_ i: Int) -> ((Int) -> Bool) { { $0 > i } }
prefix func ~>= (_ i: Int) -> ((Int) -> Bool) { { $0 >= i } }
prefix func ~< (_ i: Int) -> ((Int) -> Bool) { { $0 < i } }
prefix func ~<= (_ i: Int) -> ((Int) -> Bool) { { $0 <= i } }var age = 9  switch age { case ~>=0:
print("1") case ~>10:
print("2") default: break } // [0, 10]

5.0 where

可以使用where为模式匹配增加匹配条件

var data = (10, "Jack")
switch data {
case let (age, _) where age > 10:
print(data.1, "age>10")
case let (age, _) where age > 0:
print(data.1, "age>0")
default: break }var ages = [10, 20, 44, 23, 55]
for age in ages where age > 30 {
print(age)
} // 44 55protocol Stackable { associatedtype Element }
protocol Container {
associatedtype Stack : Stackable where Stack.Element : Equatable
}func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool
where S1.Element == S2.Element, S1.Element : Hashable {
return false
}extension Container where Self.Stack.Element : Hashable { }

http://www.lqws.cn/news/474877.html

相关文章：

  • Java 21 的虚拟线程与桥接模式：构建高性能并发系统
  • Kafka Streams入门与实战：从概念解析到程序开发
  • 架构总结记录
  • VSCode性能调优：从卡顿到丝滑的终极方案
  • C++法则11：没有“顶层 const 引用“
  • 16_设备树中的remote-endpoint演示基于视频字符设备Linux内核模块
  • 深度实战｜星环OS三大创新场景解密：如何用确定性技术重构智能汽车安全与体验？
  • Unity高性能无GC图表
  • RSA加密原理及推导
  • 跨个体预训练与轻量化Transformer在手势识别中的应用：Bioformer
  • 深入解析ID3算法：信息熵驱动的决策树构建基石
  • 为车辆提供路径规划解决方案：技术演进、挑战与未来蓝图
  • 微处理器原理与应用篇---CISCRISC指令集架构
  • 2025最新Python 100个常用函数在线体验项目
  • 索引——高效查询的关键
  • python中学物理实验模拟：凸透镜成像和凹透镜成像
  • Python 的内置函数 hash
  • `shallowReactive` 与 `shallowRef`：浅层响应式 API
  • 从零开发ComfyUI插件：打造你的AI绘画专属工具
  • CMAKE
  • wordpress外贸独立站常用留言表单插件 contact form 7
  • Python新春烟花
  • NuttX Socket 源码学习
  • C++ 中 QVector 的判断与操作
  • app专项测试命令如何写？
  • csp基础之进制转换器
  • 组件之间的双向绑定：v-model
  • redis分布式锁 Redisson在电商平台开发中的实际应用
  • `teleport` 传送 API 的使用：在 Vue 3 中的最佳实践
  • 决策树：化繁为简的智能决策利器