字面量
var age = 10
var isRed = false
var name = "Jack"
常见的字面量的默认类型
- public typealias IntegerLiteralType = Int
- public typealias FloatLiteralType = Double
- public typealias BooleanLiteralType = Bool
- public typealias StringLiteralType = String
// 可以通过 typealias 修改字面量的默认类型，不建议更改
typealias FloatLiteralType = Float
typealias IntegerLiteralType = UInt8
var age = 10 // UInt8
var height = 1.68 // Float
Swift自带的绝大部分类型，都支持直接通过字面量进行初始化
- Bool、Int、Float、Double、String、Array、Dictionary、Set、Optional等
字面量协议
var b:Bool = false //ExpressibleByBooleanLiteral
var i:Int = 10 //ExpressibleByIntegerLiteral
var f0:Float = 10 //ExpressibleByBooleanLiteral
var f1:Float = 10.0 //ExpressibleByFloatLiteral
var d0:Double = 10 //ExpressibleByIntegerLiteral
var d1:Double = 10.0 //ExpressibleByDoubleLiteral
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:ExpressibleByIngerLiteral,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=\(nmae),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,x) 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）
通配符模式（Wildcard pattern）
_ 匹配任何值 _?匹配非nil值
enum Life {
case human(name:String,age:Int?)
case animal(namee: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")
}
}
标识符模式（Identifier Pattern）
给对应的变量，常量名赋值
var age = 10
let name = "jack"
值绑定模式（Value-Binding Pattern）
let point = (3,2)
switch point {
case let (x,y):print("The point is at(\(x),\(y))")
}
元祖模式（Tuple Pattern）
let point = [(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")
}
// default
var scores = ["jack":98,"rose":100,"kate":86]
for (name,score) in scores {
print(name,score)
}
枚举Case模式（Enumeration Case Pattern）
if case 语句等价于1个case的switch语句
func test (){
let age = 2
// 原来的写法
if age >= 0 && age <= 9 {
print("[0,9]")
}
// 枚举用例模式
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]")
}
test()
let ages:[Int?] = [2,3,nil,5]
for case nil in ages {
print("有nil值")
break
}// 有nil值
let points = [(1,0),(2,1),(3,0)]
for case let (x,0) in points {
print(x)
}
可选模式（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
类型转换模式（Type-Casting Pattern）
let num:Any = 6
switch num {
case is Int:print("is Int",num) // 编译器依然认为num是Any类型
// case let n as Int:print("as Int",n + 1) // 编译器墙砖为Int类型，并赋值给n常量
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())
表达式模式（Expression Pattern）
表达式模式用在case中
let point = (1,2)
switch point {
case (0,0):print("(0,0) is at the origin.")
case (-2...2,-2...2):
print(("\(point.0),\(point.1)) is near the origin")
default:
print("The point is at (\(point.0),\(point.1))")
}
自定义表达式模式
可以通过重载运算符，自定义表达式模式的匹配规则
struct Student {
var score = 0,name = ""
//pattern ：case后面的内容
//value： switch后面的内容
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")
}// >= 60
var info = (Student(score:70,name:"Jack"),"及格")
switch info {
case let (60,text):print(text)
default:break
} // 及格
extension String {
static func ~= (pattern:(String) -> Bool,value:String) -> Bool {
pattern(value)
}
}
func hasPrefix(_ s:String) -> ((String) -> Bool){
{
$0.hasPrefix(ss)
}
}
func hasSuffix(_ s:String) -> ((String) -> Bool){
{
$0.hasSuffix(ss)
}
}
var str = "jack"
swtich 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}
func greaterThan(_ num: Int) -> (Int) -> Bool{{$0 > num}})
extension Int {
static func ~= (pattern:(Int) -> Bool,value:Int) -> Bool {
pattern(value)
}
}
var age = 10
switch age {
case isEven:print(age,"是个偶数")
case isOdd:print(age,"是个奇数")
default:break
}
switch age {
case greaterThan(5):print(age,"大于5")
default:break
}
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}}
extension Int {
static func ~= (pattern:(Int) -> Bool,value:Int) -> Bool {
pattern(value)
}
}
var age = 9
switch age {
case ~>=0,~<=10:print("[0,10]")
case ~>10,~<20:print("(10,20)")
default:break
}// [0,10]
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,55
protocol Stackable { associatedtype Element}
protocol Container {
associatedtype Stack:Stackable where Stack.Element:Equtable
}
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 {}
