Swift学习笔记之A Swift Tour

Swift1.0的时候一时兴起学习了一下swift的基本语法，现在Swift已经更新到 2.1了,自己吧学到的也忘得差不多了，接下来重新复习一下。

今天先记录一下学习swift初见相关知识点。
微信公众账号lecoding同步更新

1. if 条件语句

//---------------------- 1.1  if 联系 ------------------------/

var optionalString: String?
if let name = optionalString {
    greeting="Hello, \(name)"
}
greeting // Hello

1.2 使用 ?? 取代默认值

let wildcat="lecoding"
print("欢迎关注微信公众账号：\(optionalString ?? wildcat)")

//打印结果：欢迎关注微信公众账号：lecoding

1.3 switch

/*
* 1. Switch 语句必须有Default选项
* 2. 不用加 break, 找到第一个匹配的分支自动结
*
**/
let animal = "wildcat"
switch  animal {
case "dog":
    print("It's a Dog!")
case "cat", "monkey":
    print("its cat or monkey")
case let x where x.hasPrefix("wild"):
    print("It's wild")
case "wildcat":
    print("It is wildcat")
default:
    print("I don't know")
}

//打印结果： It's wild

1.4 for-in

//1. 遍历
let numbersDictionary = [
    "first": [12,23,1,23,34,43],
    "second": [2,23,123,4,43],
    "third": [82,-23,1,23,84,3]
]
var min=Int.max
for (key, numberlist) in numbersDictionary {
    for number in numberlist{
        if number < min{
            min=number
        }
    }
}
print("\(min)")

//打印结果： -23

//2. `..<` 表示范围 , `..< `不包括上界， `...` 包括上界
var count=0
for i in 0..<4 {
    count++
}
print("\(count)")
//打印结果：4
count=0
for i in 0...4 {
    count++
}
print("\(count)")

//打印结果：5

2. 函数

2.1 定义函数

func sayHello (name: String, words: String) -> String {
    return "\(name) say:\" \(words)\"。"
}
sayHello("Lves", words: "欢迎关注公众号：lecoding")

//打印结果： Lves say:" 欢迎关注公众号：lecoding"。

2.2 函数返回多个值

func caculateStatistics(numbers: [Int]) -> (min: Int, max: Int, sum: Int){
    var min = numbers[0]
    var max = numbers[0]
    var sum = 0
    for num in numbers{
        if num > max{
            max = num
        }else if num < min {
            min = num
        }
        sum+=num
    }
    return (min, max, sum)
}

let result = caculateStatistics([23,34,45,4562,-23,0])
print(result.max)  //打印结果：4562
print(result.min)  //打印结果：-23
print(result.2)  //打印结果：4641

在swift中，函数支持嵌套，函数既可以当做另一个函数的参数，也可以当做另一函数的返回值；
函数也是一种数据类型

2.3 函数嵌套

func functionInFunc() ->Int {
    var num1 = 0
    func add() {
        num1++
    }
    add()
    return num1
}
let result1 = functionInFunc()  // 1

2.4 函数作为返回值

func getSumFunction()->((Int,Int)->Int) {
    func getSum(num1: Int,num2: Int)->Int{
        return num1 + num2
    }
    return getSum  //返回函数名
}
var getSumFun=getSumFunction()  //获得求和函数
let result2=getSumFun(10, 20)
result2   //30

2.5 函数作为参数

//第三个参数是一个函数类型的参数
func compareFunc(num1: Int ,num2 : Int ,paramFunc:(Int,Int)->Int)->Int {
    return paramFunc(num1,num2)
}
//把求和函数传入进行求和
let compareResult=compareFunc(1, num2: 12, paramFunc: getSumFun)
// compareResult = 13

3. 闭包

函数是一种特殊的带有名字的闭包。
匿名闭包使用in把 参数和返回值类型 与 闭包体 分离。

3.1 闭包定义

var numArray1 = [10, 21, 2, 0, 65, 26]
//对数组中的每个元素取反后返回，原数组不会变
let numArray2 = numArray1.map({
    (number:Int) -> Int in
    return -number
})
//注释：数组.map() 对当前数组运用闭包内的规则然后返回一个新的数组
print(numArray1, numArray2)

打印结果： [10, 21, 2, 0, 65, 26] [-10, -21, -2, 0, -65, -26]

3.2 闭包简写

如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
上边的闭包你也可以写成下面这样：

let numArray3 = numArray1.map({number in
    return -number
})

print(numArray1, numArray3)

打印结果： [10, 21, 2, 0, 65, 26] [-10, -21, -2, 0, -65, -26]

你可以通过 参数位置 而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。
当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。

//数组排序
let sortedNumbers = numArray1.sort { $0 > $1 }
print(sortedNumbers)

打印结果： [65, 26, 21, 10, 2, 0]

4. 对象和类

1.定义Person类

class Person {
    // MARK: - Properties
    ///姓名
    var name: String
    ///年龄
    var age:Int?
    let hasParants:Bool = true
    
    // MARK: - Lifecycle
    //构造函数
    init(name: String){
        self.name = name
    } 
    // MARK: - Private
    func sayHello() ->String{
        return "Hello, My Name is \(name),欢迎关注微信公众账号：lecoding。iOS开发文章实时更新！"
    }
}

var per1 = Person(name: "Lves")
per1.age=24
var sayHi = per1.sayHello()
//"Hello, My Name is Lves,欢迎关注微信公众账号：lecoding。iOS开发文章实时更新！"

2. 定义Person的子类

class Student: Person {
    var className: String
    init(name: String, className: String) {
        self.className=className
        super.init(name: name)
        age = 20
    }
    
    override func sayHello() -> String {
        return "I am a Student From class \(className)"
    }
}

var stu = Student(name: "Lves", className: "一年级")
stu.age        //20
stu.sayHello() //"I am a Student From class 一年级"


class Square {
    var width : Float = 0.0
    
    var perimeter: Float{
        get {
            return 4*width
        }
        
        set {
            width = newValue/4.0
        }
    }
    
}

5. 枚举和结构体

5.1 枚举

//1. 在swift中枚举可以包含方法
enum WeekType {
    case Mon
    case Tue, Wed, Thu, Fri
    case Sat, Sun
    
    func myDescription () -> String{
        switch self {
        case .Mon:
            return "Monday"
        case .Tue:
            return "Tuesday"
        case .Wed:
            return "Wednesday"
        case .Thu:
            return "Thursday"
        case .Fri:
            return "Friday"
        case .Sat:
            return "Saturday"
        case .Sun:
            return "Sunday"
        }
    }
}
let weekday = WeekType.Thu              // Thu
let desc = weekday.myDescription()      // "Tuesday"

//枚举定义了类型之后，可以使用 .rawValue 查看原值
enum FromControllerType: String {
    case First = "FirstController"
    case Second = "SecondController"
}
let from = FromControllerType.First     // First
print(from.rawValue)
//打印结果："FirstController"

5.2. 结构体

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

struct Week {
    var weekday : WeekType
    func myDescription() ->String {
        return "My Weekday is \(weekday.myDescription())"
    }
    
}

let structVar = Week(weekday: .Fri)
structVar.myDescription()     // "My Weekday is Friday"

6. 协议和扩展

6.1. 协议

protocol DescriptionProtocal {

    var simpleDescrition: String { get }
    mutating func adjust()
}

类、枚举、结构体都可以实现协议
类实现协议

class DescripClass: DescriptionProtocal {
    var simpleDescrition:String {
        return "I'm a Class"
    }
    func adjust() {
    
    }
}

结构体实现协议

注意:声明SimpleStructure时候mutating关键字用来标记一个会修改结构体的方法。SimpleClass的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。

struct DescripStruct: DescriptionProtocal {
    var simpleDescrition: String = "I'm a Struct"
    mutating func adjust() {
        simpleDescrition += "123"
    }
}
var structConformProtocal = DescripStruct()
structConformProtocal.adjust()
structConformProtocal.simpleDescrition // "I'm a Struct123"

枚举实现协议

enum DescripEnum: DescriptionProtocal {
    case Success, Error
    
    var simpleDescrition: String {
        get {
            switch self {
            case .Success:
                return "You are Success"
            case .Error:
                return "You are Failure"
            }
        }
    }
    func adjust() {
    }
}
var enumConformProtocal = DescripEnum.Success
enumConformProtocal.simpleDescrition  //"You are Success"

protocol AbsoluteProtocal {
    mutating func absolute() -> Double
}

6.2 扩展

使用extension来为现有的类型添加功能，比如新的方法和计算属性。你可以使用扩展在别处修改定义，甚至是从外部库或者框架引入的一个类型，使得这个类型遵循某个协议。

//拓展 Double 类型同时实现 DescriptionProtocal、AbsoluteProtocal 两个协议

extension Double:DescriptionProtocal,AbsoluteProtocal {
    var test:String{
        return "demo"
    }
    var simpleDescrition:String {
        return "The double value is: \(self)"
    }
    mutating func adjust() {
        self = -self
    }
    mutating func absolute() ->Double {
        return abs(self)
    }
}

var doubleNumber:Double = 12.5
doubleNumber.simpleDescrition       //"The double value is: 12.5"
doubleNumber.adjust()               // -12.5

var oriNumber:Double = -100
var resultDouble=oriNumber.absolute()  //取反
resultDouble                // 100

oriNumber.test              // "demo"

7. 泛型

enum optionalValue<Type> {
    case none
    case other(Type)
}

var enumOfInt:optionalValue<Int> = .none
enumOfInt = .other(12)
print(enumOfInt)

打印结果：other(12)

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

转载请注明原文链接：http://lvesli.com/2016/05/25/A-Swift-Tour/
微信公众账号同步更新：lecoding,你也可以扫描下方二维码：

qrcode_for_gh_af22362bf4bb_258.jpg