Swift3学习笔记- 0

欢迎访问我的博客muhlenXi，该文章出自我的博客。

版权声明：本文为muhlenXi原创文章，转载请注明出处，未经允许不得转载.

导语：

Swift是一个新的编程语言，使用它可以开发iOS、macOS、watchOS和tvOS等平台上的App，它比C和Objective-C语言更好的胜任这项工作，Swift采用安全的编程模式，它加入了一些现代的特色使得编程更加容易、更加灵活和更加有趣，Swift基于成熟的受人喜爱的 Cocoa 和 CocoaTouch 框架，这是一个重新定义软件是如何开发的机会！Just enjoy it！。

点击阅读全文来了解一下详情吧。

Swift之初体验

单一变量

在屏幕上打印 hello，world!

print("hello,world!")

定义一个变量和改变变量的值

var myVariable = 42
myVariable = 50

定义一个常量

let myConstant = 38

我们定义常量和变量的时候可以不显示的声明常量或变量的数据类型，编译器会根据你设置的初始值去推测数据的类型。

带数据类型的常量的声明是这样的。

let myWeight:Double = 54.0

字符串类型转换。

let label = "the width is "
let width = 94
let widthLabel = label + String(width)

还有个更简单的方式。

let apples = 3
let oranges = 5
let appleSummary = "I hava \(apples) apples"
let fruitSummary = "I have \(apples + oranges) pieces of fruit"

定义一个不可变数组

let animals = ["猴子","大象","兔子"]

定义一个可变数组

var fruitLists = ["苹果汁","香蕉","梨","葡萄"]
fruitLists[0] = "苹果"       //修改 
fruitLists.append("猕猴桃")  //增加        
fruitLists.remove(at: 4)    //删除

定义一个空的数组

let animals = [String]()

定义一个不可变字典

let wheelsOfCar = ["独轮车":1,"自行车":2,"小汽车":4]

定义一个空的字典

let emptyDictionary = [String: NSInteger]()

定义一个可变字典

var wheelsOfCar = ["独轮车":1,"自行车":2,"小汽车":4]
wheelsOfCar["三轮车"] = 3   //增加或修改
wheelsOfCar.removeValue(forKey: "三轮车")  //删除
print("\(wheelsOfCar)")

控制流

`if - else` 条件判断语句

let scores = [75,43,103,87]
var count = 0
    for score in scores {
        if score > 50 {
           count += 1
       } else {
                count += 0
       }
    }
print("分数大于零的科目个数：\(count)")

if或else后面的（）可以省略，但是 {} 不能省略！

可选值操作

let optionalName:String? = "张三"
var greeting = "hello!"
if let name = optionalName {
         greeting = "hello,\(name)"
    }else {
        greeting = "optionalName is nil"  //当名字为nil时会执行这句
    }
print(greeting)

我们也可以用操作符??给可选值设定一个默认值，当可选值为nil时会自动以默认值填充！

let nickName:String? = nil
let defaultName = "李四"
let informalGreeting = "Hi \(nickName ?? defaultName)"
print(informalGreeting)

switch - case 条件判断语句

let vegetable = "土豆"
switch vegetable {
case "辣椒":
      print("辣椒吃多了容易上火。")
case "红薯", "土豆":
      print("这种蔬菜淀粉含量比较高。")
case let x where x.hasSuffix("瓜"):
      print("\(x) 属于瓜类的一种")
default:
      print("这种蔬菜的信息暂未获得。")
}

通过 for - in 来遍历数组或字典

let intersetingNumbers = ["素数":[2,3,5,7,11,13],"斐波纳契数":[1,1,2,3,5,8],"平方数":[1,4,9,16,25]]
var largest = 0
//找出这些数中的值最大的数
for (_,numbers) in intersetingNumbers {
            
    for number in numbers {
                
        if number > largest {
           largest = number
        }
     }
}
print(largest)

可以通过 for-in 来控制循环次数

//全闭区间
var sum = 0
for i in 0...4 {
            
   sum = sum + i  //循环5次
}
print(sum)
        
//半开半闭区间
var sum1 = 0
for i in 0..<4 {
            
   sum1 = sum1 + i  //循环4次
}
print(sum1)

`while` 循环和 `repeat - while` 循环

//先判断后执行
var n = 2
while n < 100 {  
     n = n * 2
}
print(n)  //输出128

//先执行后判断        
var m = 2
repeat {       
    m = m * 2
}while m < 100
print(m)  //输出128

函数和闭包

用`func`声明一个函数，`()`中是参数，`->`后面是返回值的类型

func greet(person: String,day :String) -> String {
        
    return "你好 \(person),今天是 \(day)。"
}

函数的调用：

let str:String = greet(person: "张三", day: "星期天")  //调用函数
print(str)

禁止设置默认参数名

当我们声明函数时不指定参数的名字时，参数的名字默认为形式参数的名字，当然，我们可以通过_来禁止设置默认参数名

func greet(_ person:String, on day:String) -> String {
        
    return "Hello \(person),today is \(day)"
}

方法调用是这样：

print(greet("Tom", on: "Monday"))

使用元组(tuple)来创建复合值

func calculateStatistics(scores:[Int]) -> (min:Int,max:Int,sum:Int) {
        
        var min = scores[0]
        var max = scores[0]
        var sum = 0

        for score in scores {
            
            if score > max {
                max = score
            } else if score < min {
                min = score
            }
            
            sum += score
        }
        return (min,max,sum)
}

函数调用时这样的：

let statistics = calculateStatistics(scores: [5,3,100,25,4])
print("min = \(statistics.min)")
print("max = \(statistics.max)")
print("sum = \(statistics.2)")

*函数的参数个数也可以是不确定的 *

func sumOf(numbers:Int...) -> Int {
        
   var sum = 0
   for num in numbers {
       sum += num
   }
   return sum
}

调用是这样的：

print(sumOf())                       //输出0
print(sumOf(numbers: 100,200,50))    //输出350

函数可以嵌套，嵌套的函数可以读取或修改外部函数的变量的值。

//函数定义
func returnFifteen() -> Int {
     var y = 10
     func add() {
         y += 5
     }
     add()
     return y;
}

//函数调用：
print(returnFifteen())

函数的返回值也可以是函数。

//生成一个增量器
func makeIncrementer() -> ((Int) -> Int) {
        
   func addOne(number:Int) -> Int {
       return number + 1
   }
   return addOne;
}

//方法调用
let increment = makeIncrementer()
print(increment(7))

函数的参数也可以是函数。

func lessThanTen(number:Int) -> Bool {
        
    return number < 10
}
    
//检查数组中是否包含小于10的元素
func checkArray(list:[Int],condition:(Int) -> Bool)  -> Bool {
        
 for item in list {
            
      if condition(item) {
           return true
      }
  }
        
    return false
}

函数调用是这样的：

let numbers = [18,9,17,12]
let ret = checkArray(list: numbers, condition: lessThanTen)
print(ret)

函数是闭包的一种特殊形式,可以用`{}`实现一个闭包，在闭包中用`in`来分离参数和返回值类型。

let numbers = [20,19,7,12]

//将数组中的元素的值加倍
let mappedNumbers = numbers.map({number in number * 2})
print(mappedNumbers)

//逆序排列数组中的元素
let sortedNumbers = numbers.sorted{$0 > $1}
print(sortedNumbers)

对象和类

用`class`来创建一个类，属性的声明和常量、变量的声明方式一样，方法和函数的声明方式也一样。

可以通过init来生成一个initializer来初始化对象。

可以通过deinit来生成一个deinitializer，当对象被释放时做一些清理工作。

类的声明如下：

//声明一个几何体
class Shape {
        
     var numberOfSides = 0   //边的个数
     var name :String        //几何体的名字
        
        
     init(name:String) {
         self.name = name
     }
        
     //简单描述
     func simpleDescription() -> String {
          return "这个叫\(name)的几何体有\(numberOfSides)条边"
     }
}

类的对象的生成：

let shape = Shape.init(name: "七边形")
shape.numberOfSides = 7
print(shape.simpleDescription())

类的继承

如果该类是继承某一父类的子类，则声明子类的时候要用:+ 父类名来表明其继承自什么类。当没有父类的时候，可以省略不写。

当子类要覆写父类的方法时，子类方法前要添加关键词 override

声明一个继承Shape的Square类

//正方形
class Square: Shape {
        
     var sideLength:Double   //边长
        
     init(sideLength:Double,name:String) {
            
         self.sideLength = sideLength
         super.init(name: name)
         numberOfSides = 4
     }
        
     override func simpleDescription() -> String {
            
     return "这个叫\(name)的几何体有\(numberOfSides)条边,边长为\(sideLength)cm"
     }
        
     //计算面积
     func area() -> Double {
            
            return sideLength * sideLength
     }
        
 }```

*子类对象的创建:*

```objc
let square = Square.init(sideLength: 4, name: "正方形")
print("面积是：\(square.area())")
print(square.simpleDescription())

类的属性，也可以自己生成getter和setter方法：

//等边三角形
class EquialateralTriangle: Shape {
        
     var sideLenth :Double = 0
        
     init(sideLength:Double,name:String) {
         self.sideLenth = sideLength
         super.init(name: name)
         numberOfSides = 3
     }
        
     //周长
     var perimeter:Double {
         set {
                sideLenth = newValue / 3.0
            }
         get {
                return sideLenth * 3.0
            }
     }
        
     override func simpleDescription() -> String {
         return "这是一个边长为\(sideLenth)的等边三角形"
     }
}

等边三角形对象的创建:

let triangle = EquialateralTriangle.init(sideLength: 5, name: "等边三角形")
//获取周长
print("周长是：\(triangle.perimeter)")
triangle.perimeter = 12
//获取修改周长后的边长
print("边长是：\(triangle.sideLenth)")
print(triangle.simpleDescription())

枚举和结构体

用`enum`来声明一个枚举，枚举中也可以关联函数

第一个枚举值默认是0，我们也可以指定第一个枚举值为我们想要的值。

举个 🌰 ：

enum Direction : NSInteger {
     case up = 1,
     down,
     left,
     right
        
     func description() -> String {
        switch self {
            case .up:
                return "向上"
            case .down:
                return "向下"
            case .left:
                return "向左"
            case .right:
                return "向右"
         }
      }
}

调用如下：

let direc = Direction.down
print(direc)
print(direc.rawValue)
print(direc.description())

我们也可以通过rawValue来初始化一个枚举的选项，得到的是一个可能值。

let direc = Direction(rawValue: 2)
print(direc!.description())

枚举中的选项还可以和不同的常量值关联，当我们创建一个枚举的实例时，就可以初始化不同的常量值。

enum ServerResponse {
     case result(String,String)
     case failure(String)
}

用`struct`来声明一个结构体，枚举中也可以关联函数

举个 🌰 ：

//矩形类
struct Rectangle {
        
     var origin:CGPoint
     var width:Float
     var height:Float
        
     func area() -> String {
            
            let area = width * height
            return "\(area)"
     }
        
     func perimeter() -> Float {
            return (width + height) * 2
     }
}

简单运用

let myRectangle = Rectangle(origin: CGPoint.init(x: 0, y: 0), width: 5, height: 6)
print("周长：\(myRectangle.perimeter())")
print("面积：\(myRectangle.area())")

协议和类扩展

用`protocol`来声明一个协议。

protocol TestProtocol {
    var simpleDescription:String { get }
    mutating func adjust()
}

类、枚举和结构体都可以遵循协议

class TestClass: TestProtocol {
        
    var value:Int = 108

    var  simpleDescription: String = "这是一个测试类"
    func adjust() {
         simpleDescription.append("+测试值是\(value)")
    }
}
    
struct TestStruct:TestProtocol {
        
    var simpleDescription: String = "一个测试结构体"
    mutating func adjust() {
            simpleDescription.append("+ 遵循协议")
    }
}

简单运用

let test = TestClass()
test.adjust()
print(test.simpleDescription)
        
var testStruct = TestStruct()
testStruct.adjust()
print(testStruct.simpleDescription)

用`extension`来声明一个类扩展，给存在的类增加一个方法或算值属性。

举个 🌰 ：

extension Int
{
    //简介 算值属性
    var simpleDescription:String {
        return "the number \(self)"
    }
    //自增2
    mutating func addTwo() {
        self = self + 2
    }
    
}

简单使用

var num:Int = 8
print(num.simpleDescription)
num.addTwo()
print(num)

用extension也可以让存在的类或数据类型遵循某项协议。

protocol testProtocol {
    var simpleDescription:String {
        get
    }
    mutating func adjust()
}

extension Double: testProtocol
{
    var simpleDescription: String
        {
        return "Double value \(self)"
    }
    
    mutating func adjust() {
        self *= 2
    }
}

简单运用：

var pi:Double = 3.14
print(pi.simpleDescription)
pi.adjust()
print(pi)

错误处理

通过遵循错误协议Error来声明一个错误类型。

enum PrinterError:Error {
    case outOfPaper
    case noToner
    case onFire
}

用throw来抛出错误和用throws来标记一个可以抛出错误的函数，当函数抛出错误时，函数会立即返回，并调用错误处理方法。

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

用do-catch来处理错误，在do代码块中，调用可抛出错误的函数时，前面需要用try来标记,而在catch代码块中，错误的默认名字是error，除非设置了一个别名。

do {
        let printerResponse = try send(job: 1040, toPrinter: "Nerver Has Toner")
        print(printerResponse)
        
    } catch {
        print(error)
    }
}

可以用多重catch代码块来详细处理错误

do {
        let printerResponse = try send(job: 1040, toPrinter: "Nerver Has Toner")
            print(printerResponse)
        } catch PrinterError.onFire {
            print("打印机过热，休息一会儿再使用")
        } catch PrinterError.noToner{
            print("打印机没墨了，请添加墨水")
        } catch {
            print("纸张用完，请添加纸张")
    }

另一种处理错误是用try?将结果转换成一个可选值，如果函数抛出错误，这个错误将被丢弃，结果为nil，否则返回值是一个包含结果的可选值。

let printerSuccess = try? send(job: 1884, toPrinter: "hello world")
let printerFailure = try? send(job: 1884, toPrinter: "Nerver Has Toner")

使用defer代码块来声明函数返回前需要执行的语句，该语句不管函数是否抛出错误都会执行。

var fridgeIsOpen = false
let fridgeContent = ["milk","eggs","apple"]
    
func fridgeContains(food:String) -> Bool {
        
        fridgeIsOpen = true
        defer {
            fridgeIsOpen = false
        }
        
        let result = fridgeContent.contains(food)
        return result
        
}

简单运用

let ret = fridgeContains(food: "banana")
print(ret)
print(fridgeIsOpen)

泛型

用`<name>`声明一个泛型或泛型方法。

func makeArray<Item>(repeat item:Item, numberOfItems:Int) -> [Item] {
        
        var result = [Item]()
        for _ in 0..<numberOfItems {
            result.append(item)
        }
        return result
        
}

//函数调用
print(makeArray(repeat: "Apple", numberOfItems: 7))

函数、类、枚举、结构体等也可以声明成泛型的方式

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}

//简单调用
var possibleValue:OptionalValue<Int> = .none
possibleValue = .some(200)
print(possibleValue)

在方法名后面来使用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
}

简单运用

let ret = anyCommonElements([1,2,3], [5])
print(ret)

结束语：

在这里查阅Swift3官方文档

感谢阅读，有什么不对的地方可以给我留言，一起学习，一起进步！

最后编辑于：2017.12.04 06:24:42

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,457评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,837评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,696评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,183评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,057评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,105评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,520评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,211评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,482评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,574评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,353评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,213评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,576评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,897评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,174评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,489评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,683评论 2赞 335

Swift3学习笔记- 0

导语：

Swift之初体验

单一变量

在屏幕上打印 hello，world!

定义一个变量和改变变量的值

*定义一个常量 *

字符串类型转换。

*定义一个不可变数组 *

*定义一个可变数组 *

*定义一个不可变字典 *

*定义一个可变字典 *

控制流

*if - else 条件判断语句 *

可选值操作

switch - case 条件判断语句

通过 for - in 来遍历数组或字典

可以通过 for-in 来控制循环次数

*while 循环 和 repeat - while 循环 *

函数 和 闭包

用func声明一个函数，()中是参数，->后面是返回值的类型

禁止设置默认参数名

使用元组(tuple)来创建复合值

函数可以嵌套，嵌套的函数可以读取或修改外部函数的变量的值。

函数的 返回值 也可以是函数。

函数的 参数 也可以是函数。

函数是闭包的一种特殊形式,可以用{}实现一个闭包，在闭包中用in来分离参数和返回值类型 。

对象 和 类

用class来创建一个类，属性的声明和常量、变量的声明方式一样，方法和函数的声明方式也一样。

类的继承

类的属性，也可以自己生成getter和setter方法：

枚举 和 结构体

用enum来声明一个枚举，枚举中也可以关联函数

用struct来声明一个结构体，枚举中也可以关联函数

协议 和 类扩展

用protocol来声明一个协议。

用extension来声明一个类扩展，给存在的类增加一个方法或算值属性 。

错误处理

泛型

用<name>声明一个泛型或泛型方法。

结束语：

推荐阅读更多精彩内容

定义一个常量

定义一个不可变数组

定义一个可变数组

定义一个不可变字典

定义一个可变字典

`if - else` 条件判断语句

`while` 循环和 `repeat - while` 循环

函数和闭包

用`func`声明一个函数，`()`中是参数，`->`后面是返回值的类型

函数的返回值也可以是函数。

函数的参数也可以是函数。

函数是闭包的一种特殊形式,可以用`{}`实现一个闭包，在闭包中用`in`来分离参数和返回值类型。

对象和类

用`class`来创建一个类，属性的声明和常量、变量的声明方式一样，方法和函数的声明方式也一样。

枚举和结构体

用`enum`来声明一个枚举，枚举中也可以关联函数

用`struct`来声明一个结构体，枚举中也可以关联函数

协议和类扩展

用`protocol`来声明一个协议。

用`extension`来声明一个类扩展，给存在的类增加一个方法或算值属性。

用`<name>`声明一个泛型或泛型方法。