Swift语言里的泛型与异常处理

我感觉泛型挺难，希望对你们有帮助

//一个泛型a,b值交换的列子，可以传入什么类型

func mySwap<T>(inout a: T,inout b: T) {

let temp = a

a = b

b = temp

}

var a = 111

var b = 222

mySwap(&a, b: &b)

//普通整形a,b值交换列子，只能传入整形

func mySwap2(inout a: Int,inout b: Int) {

let temp = a

a = b

b = temp

}

var z = "aa"

var y = "bb"

//mySwap2(&z, b: &y)这里报错了，因为这里指定了必须是整形才能进行交换

//Swift<泛型> 模拟实现入栈出栈

//struct Stack<Element> {

// var containers = [Element]()

// mutating func push(e:Element) {

// containers.append(e)

// }

// mutating func pop() ->Element {

// return containers.removeLast()

// }

//}

//

//var data: Stack<Int> = Stack<Int>()

//data.push(1)

//data.push(2)

//data.push(3)

//data.pop()

//加入我们要对一个泛型进行扩展，我们只需要写泛型名就好，不要写<>里面的参数了

//extension Stack {

// var conut: Int {

// return containers.count

// }

//}

//

//var data2 = Stack<String>()

//

//data2.push("adas")

//data2.push("dasdasd")

//data2.conut

//泛型约束

//普通的计算下标的函数

//func index(arr: [Int],data: Int) ->Int {

// for(a,b) in arr.enumerate() {

// if b == data {

// return a

// }

// }

// return -1

//}

//

//let array = [1,4,5,6,3]

//index(array, data: 3)

//泛型的实现方式

//泛型是不可以使用== 必须继承系统的这个协议Equatable

protocol IA{

}

protocol IB{

}

extension Int: IA,IB{

}

func index<T:Equatable where T:IA,T:IB>(arr:[T],data: T) ->Int {

for (m,n) in arr.enumerate() {

if n == data {

return m

}

}

return -1

}

let array2 = [1,3,8,2]

index(array2,data:8)

class Person {

var salary = 0

}

func calc<T: Person>(persons:[T]) -> Int {

var total = 0

for p in persons {

total += p.salary

}

return total

}

//协议的关联类型

//协议的关联类型（associative type）

protocol Containter {

typealias Element

mutating func push(e: Element)

mutating func pop()-> Element

}

struct MyStack: Containter{

// typealias Element = Int

var containers = [Int]()

mutating func push(e: Int) {

containers.append(e)

}

mutating func pop() -> Int {

return containers.removeLast()

}

}

struct Stack<Element>: Containter {

//按照当前的实现，下面的代码由于类型推断，可以省略

// typealias Element = E

var containers = [Element]()

mutating func push(e: Element) {

containers.append(e)

}

mutating func pop() -> Element {

return containers.removeLast()

}

}

typealias MyInt = Int //给Int取个别名

let i: MyInt = 3

typealias s = String

let ss: s = "121212"

//扩展协议时的约束以及与协议关联类型的使用

protocol MM {

}

class MMClass: MM {

}

protocol NN : MM{

}

class NNClass: NN {

}

protocol Container {

typealias ItemType

}

extension Container where ItemType: MM {

var b: Int {return 5}

}

extension Container where ItemType: NN {

var b: Int {return 6}

}

class TestTest: Container {

typealias ItemType = MMClass //如果这里改为MMClass，那么aaaa.b输出结构是5

}

class TestTest2: Container {

typealias ItemType = Int

}

let aaaa = TestTest2()

//aaaa.b 报错

//Swift的修饰符 默认都是internal

internal class TestModifier {

func m() {

}

}

let tu = (TestModifier(),"aa")

//异常 Swfit异常处理有四种方式

//创建自己的异常，也是就错误类

enum PasswordError: ErrorType {

case LengthIsNotEnough

case TooSimple

}

//第一种 抛出去

func validatePwd(pwd: String)throws -> Bool {

let count1 = pwd.characters.count

if count1 < 6 {

throw PasswordError.LengthIsNotEnough

}

if count1 > 10 {

throw PasswordError.TooSimple

}

return true

}

//第二种 解决

do {

//可以写多行代码

try validatePwd("dasdasd")

//可以写多行代码

}catch {

print("error")

}

//第三种

let result = try?validatePwd("dadada")

if result == nil {

print("调用时出错")

}

//第四种

let result2 = try! validatePwd("dasdhua")

//defer有点类似异常处理中得finally，但是他也是可以用在非异常处理的情况

func m() {

print("你好")

defer {

print("你们好")

}

print("大家好")

}

m()