SwiftNote-11
2016年05月22日 Swift

扩展

Swift允许对一个已存在类型进行功能的扩展(包括基础类型，如Int)，扩展可以做到：

  • 添加计算型属性，包括计算型静态属性
  • 添加实例方法和类型方法
  • 添加新的构造方法
  • 定义下标
  • 添加新嵌套类型并使用
  • 还可以在扩展一个类型的同时，适配一个或者多个协议

语法

使用extension关键字，后接对应的需要扩展的类型

1
2
3
4
5
6
7
8
extension ExistType // 扩展一个类型
{
  // extension code here
}
extension ExistType: ExistProtocol,SomeProcotol // 扩展一个类型的同时并符合某个协议
{
  
}

扩展可以添加功能，但是不能重写已有的方法功能

扩展计算型属性

  • 添加静态计算属性

    1
    2
    3
    4
    5
    extension Float
    {
    	static var PI:Float{return 3.14159}
    }
    print(Float.PI) // 3.14159

  • 添加实例计算属性

    1
    2
    3
    4
    5
    6
    7
    extension Float
    {
    	var dividedBy10:Float{return self / 10.0}
    }
    var x:Float = 11.0
    let res = x.dividedBy10
    print(res)

扩展构造方法

指定构造方法必须由原始实现给出，所以扩展只能扩展便捷构造方法

1
2
3
4
5
6
7
8
extension Int
{
	init(i:Float) // 四舍五入
	{
		self = Int(i + 0.5)
	}
}
print(Int(i:1.6)) // 输出2

扩展方法

可以扩展实例方法的类型方法

  • 扩展实例方法，如果实例方法要改变自身需要mutating关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    extension Int
    {
    	func repeatOutput()
    	{
    		for _ in 1 ..< self
    		{
    			print("repeat value \(self)")
    		}
    	}
    }
    5.repeatOutput()

    extension Int
    {
    	mutating func powBy(powNum powNum:Int) // 需要改变自己的值
    	{
    		let origion = self
    		for _ in 1 ..< powNum
    		{
    			self = self * origion
    		}
    	}
    }
    var x = 5
    x.powBy(powNum:3)
    print(x)

  • 扩展类型方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    extension Int
    {
    	func repeatOutput()
    	{
    		for _ in 1 ..< self
    		{
    			print("repeat value \(self)")
    		}
    	}
    	static func printSelf()
    	{
    		print("static method \(self)")
    	}
    }
    5.repeatOutput()
    Int.printSelf()

扩展下标

可添加新下标，类似于添加新方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
extension Int 
{
	subscript(digitIndex: Int) -> Int // int对应位置的数字
	{
		var index = digitIndex
		var decimalBase = 1
		while index > 0
		{
			decimalBase *= 10
			index -= 1
		}
		return (self / decimalBase) % 10
	}
}
print(34567[3])

扩展添加嵌套类型

可以向已有的类类型，枚举类型，结构体添加新的嵌套类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
extension Int 
{
	enum Kind 
	{
		case Negative, Zero, Positive
	}
	var kind: Kind
	{
		switch self 
		{
		case 0:
			return .Zero
		case let tmp where tmp > 0:
			return .Positive
		default:
			return .Negative
		}
	}	
}
func jugdeNum(num:Int)
{
	switch num.kind
	{
		case .Zero:
			print("Zero")
		case .Positive:
		    print("Positive")
		case .Negative:
		    print("Negative")
	}
}
jugdeNum(-12) // Negative
jugdeNum(0)   // Zero
jugdeNum(12)  // Positive