• 初步接触
  • 可变参数
  • 枚举
  • 结构体
  • 错误处理
  • 泛型

由于项目需要和苹果发展的趋势,swift的学习势在必得,swift以其优秀的代码风格和机制,已然越升世界语言排行榜前列,我将系统的去学习和使用这门语言,并做好学习记录,希望能给自己和别人都带来帮助.

可变参数

swift中函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式:

func sumOf(_ numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum }
sumOf()
sumOf(42, 597, 12)

枚举

枚举de使用,默认情况下，Swift 按照从 0 开始每次加 1 的方式为原始值进行赋值，不过你可以通过显式赋值进行改变:

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        case .King:
            return "king"
        default:
            return String(self.rawValue)
        }
    } }
let ace = Rank.Ace                      //Ace
let aceRawValue = ace.rawValue          //1

let three = Rank.Three                  //Three
let threeValue = three.rawValue         //3
three.simpleDescription()               //"3"

let king = Rank.King                    //King
let kingValue = king.rawValue           //13
king.simpleDescription()                //"king"

使用 init?(rawValue:) 初始化构造器在原始值和枚举值之间进行转换:

if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()   //"3"
}

结构体

使用 struct 来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就 是结构体是传值，类是传引用。
此处留下一大坑 ... ...

错误处理

使用采用 Error 协议的类型来表示错误。

enum PrinterError: Error {
    case OutOfPaper
    case NoToner
    case OnFire 
}

使用 throw 来抛出一个错误并使用 throws 来表示一个可以抛出错误的函数。如果在函数中抛出一个错误，这个函 数会立刻返回并且调用该函数的代码会进行错误处理。

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError. NoToner
    }
    return "Job sent"
}

有多种方式可以用来进行错误处理。一种方式是使用 do-catch 。在 do 代码块中，使用 try 来标记可以抛出错误 的代码。在 catch 代码块中，除非你另外命名，否则错误会自动命名为 error 。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)                 //Job sent
} catch {
    print(error)
}

泛型

在尖括号里写一个名字来创建一个泛型函数或者类型。下面函数尖括号中的T代表一种类型,这种类型具体是什么类型,要根据调用时传入的数据类型进行判断

//MARK: - 泛型函数
func repeatItem<T>(repeating item: T, numberOfTimes: Int) -> [T] {
    var result = [T]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
let response = repeatItem(repeating: "knock", numberOfTimes:4)
print(response)        //["knock", "knock", "knock", "knock"]

你也可以创建泛型函数、方法、类、枚举和结构体。

// 重新实现 Swift 标准库中的可选类型 enum OptionalValue<Wrapped> {
case None
     case Some(Wrapped)
 }
 var possibleInteger: OptionalValue<Int> = .None
 possibleInteger = .Some(100)

在类型名后面使用 where 来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者 限定某个类必须有一个特定的父类。

 func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
     where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
         for lhsItem in lhs {
             for rhsItem in rhs {
                 if lhsItem == rhsItem {
                     return true
} }
         }
         return false
 }
 anyCommonElements([1, 2, 3], [3])

下一篇swift基本语法