Swift - 基础部分

Swift 前端之家
前端之家收集整理的这篇文章主要介绍了Swift - 基础部分，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

常量和变量

  • 常量和变量相当于一个容器，存储数据。常量和变量把一个名字名字和一个指定类型的值关联起来。常量的值一旦设定就不能更改，而变量的值可以任意更改。

声明常量和变量

  • Swift是强类型的语言，要求所有的常量和变量必须先声明，后使用，声明变量时必须显示或隐式指定变量的类型。

  • Swift用let来声明常量，用var来声明变量。

  1. // 声明常量
  2. let studentNumber = 1101
  3.  
  4. // 声明变量
  5. var studentName = "Edward"
  6.  
  7. // 常量允许被修改
  8. studentName = "Petter"
  • 在一行中声明多个常量或变量，用逗号隔开：
  1. var x = 0.0,y = 0.0,z = 0.0

注意：如果你的代码中有不需要改变的值，请使用let关键字将它声明为常量。只将需要改变的值声明为变量。

类型标注

  • 声明常量或变量时可加上类型标注，说明常量或变量中要存储的值的类型，程序要么通过let/var 变量名 ：类型的形式显示指定该常量或变量的类型，要么为该常量或变量指定初始值—Swift编译器将会根据该初始值确定常量或变量的类型。
  1. // 显示指定类型
  2. let age: Int = 21 // Int
  3. var name: String // String
  4.  
  5. // 隐式指定类型
  6. var zipCode = 610000 // Int
  7. let address = "ChengDu" // String

注意：声明常量时必须指定初始值，这是由于常量不允许被重新赋值；一般来说，常量或变量很少需要写类型标注，如果你在声明常量或变量时赋了初始值，系统会自动推断该常量或变量的类型。

常量和变量的命名

  • Swift允许使用任何字符作为常量或变量名，包括Unicode码。但是不允许包含数学符号、箭头、非法字符、连线与制表符，也不能以数字开头。
  1. let π = 3.1415926
  2.  
  3. var 姓名 = "Edward"
  4.  
  5. var �� = "dogName_Akitas"

输出常量和变量

  1. print(姓名) // 输出 Edward
  2.  
  3. print("Hello,word!") // 输出 Hello,word!
  4.  
  5. print("He's name is '\(姓名)'.") // 输出 He's name is 'Edward'.

注释

  • 单行注释
  1. // 这是一个当行注释
  • 多行注释
  1. /* 这是一个 多行注释 */
  • 嵌套注释
  1. /* 这是第一个多行注释的开头 /* 这是第二个被嵌套的多行注释 */ 这是第一个多行注释的结尾 */

分号

  • Swift不强制要求每条语句必须以;结尾，但如果要在一行内写多条独立语句，则需要以;隔开。
  1. let phoneSystem = "iOS"; print("The mobile phone system is '\(phoneSystem)'.")

整形

  • 整数就是没有小数部分的数字，比如42和-23。整数可以是有符号(正、负、零)或者无符号(正、零)。

  • Swift允许使用max或min访问对应类型的最大值或最小值。

  • Swift提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同。

浮点型

  • 浮点数是有小数部分的数字，比如3.14159,0.1 和-273.15 。

  • 浮点类型比整数类型表示的范围更大，可以存储比Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：

    • Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。

    • Float表示32位浮点数。精度要求不高的话可以使用此类型。

类型安全和类型推断

  • Swift是一个类型安全的语言，类型安全的语言明确了常量或变量的类型，如果声明的变量为String类型，则绝对不能赋值一个Int类型的值。

  • 由于Swift是类型安全的，所以它会在编译你的代码时进行类型检查，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。

  • 当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需 要显式指定类型。如果你没有显式指定类型，Swift会使用_类型推断来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单,只要检查你赋的值即可。

  • 因为有了类型推断，所以很少需要声明类型。

类型别名

  • 类型别名就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名，其格式为：typealias 类型别名 = 已有类型
  1. typealias MyString = String
  2.  
  3. var variable: MyString // variable为MyString类型即String类型，因此只能赋字符串

布尔型

  • Swift有一个基本的布尔类型，叫做Bool，用于表示逻辑上的“真”或“假”，其提供了两个布尔常量：true和false。

  • Bool类型的值或变量主要用作旗标来进行流程控制

  1. let isLogin: Bool = true
  2. if isLogin == true {
  3.     print("已登录！")
  4. }else {
  5.     print("未登录")
  6. }
  7.  
  8. // 输出 已登录！
  • Bool类型的值或变量也可用于三目运算符
  1. let isLogin: Bool = true
  2.  
  3. isLogin == true ? print("已登录！") : print("未登录")
  4.  
  5. // 输出 已登录！
  • 如果程序在使用Bool类型的地方使用了非Bool值，Swift的类型检查机制会报错。
  1. var i = 1
  2. if i {
  3.     // 这个例子不能通过编译，会报错
  4. }
  5.  
  6. var i = 1
  7. if i == 1 {
  8.     // 这个例子会编译成功
  9. }
  10.  
  11. // i == 1的比较结果是Bool类型,所以第二个例子可以通过类型检查

元组

  • 元组使用圆括号()把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

定义元组类型的变量

  1. // 定义元组变量，并指定初始值，系统推断该元组类型为：(String,Int,Double)
  2. var studentInfomation = ("Edward",1101,93.2)
  3.  
  4. // 使用元组类型定义元组变量
  5. var score: (String,Double)
  6.  
  7. // 为元组变量赋值时必须为所有成员都指定值
  8. score = ("语文",98.5)
  • Swift允许元组的成员可以再次是元组
  1. var programmingLanguage: (String,(String,String))
  2.  
  3. programmingLanguage = ("iOS",("Objective-C","Swift"))

获取元组中的元素值

  • Swift允许通过下标来访问元组的单个元素，元组的下标从0开始，元组的第1个元素的下标为0，第2个元素的下标为1……以此类推。
  1. var studentInfomation = ("Edward",93.2)
  2. var programmingLanguage: (String,(String,String))
  3.  
  4. programmingLanguage = ("iOS","Swift"))
  5.  
  6. print(studentInfomation.0) // 输出 Edward
  7. print(studentInfomation.1) // 输出 1101
  8.  
  9. print(programmingLanguage.0) // 输出 iOS
  10. print(programmingLanguage.1.0) // 输出 Objective-C
  • Swift允许将元组的元素拆分成单个的常量或变量，接下来即可正常使用这些常量或变量了。
  1. var studentInfomation = ("Edward",93.2)
  2.  
  3. let (stuName,stuNumber,stuscore) = studentInfomation
  4.  
  5. print(stuName) // 输出 Edward
  6. print(stuNumber) // 输出 1101
  7. print(stuscore) // 输出 93.2
  • 如果程序只需要部分元组的元素，分解的时候可以使用下划线_作为被忽略部分的占位符。
  1. var studentInfomation = ("Edward",93.2)
  2.  
  3. let (stuName,_,_) = studentInfomation
  4.  
  5. print("student's name is '\(stuName)'.") // 输出 student's name is 'Edward'.

为元组中的元素命名

  • Swift允许在定义元组时给单个元素命名，命名之后，即可通过名字来获取相应元素值。
  1. var 个人信息 = (姓名: "Charles",phoneNumber: 13219038892)
  2.  
  3. print("\(个人信息.姓名)的手机号码是：\(个人信息.phoneNumber)")
  4. // 输出 Charles的手机号码是：13219038892

可选类型

可选和nil

  • 在任何已有类型的后面紧跟?即可代表可选类型，可选类型的变量用于处理“值缺失”的情况。可选类型表示：
  1. 有值，等于 x
  2. 或者
  3. 无值，等于 nil
  • 例子，Swift的String类型有一个叫做Int()的方法，作用是将一个String值转换成一个Int值。然而，并不是所有的字符串都可以转换成一个整数。字符串 "123" 可以被转换成数字123 ，但是字符串abc不行。
  1. let possibleNumber = "123"
  2.  
  3. // convertedNumber 被推测为类型 "Int?",或者类型 "optional Int"
  4. let convertedNumber = Int(possibleNumber)
  5.  
  6. print(convertedNumber) // 输出 Optional(123)
  7.  
  8. // 如果possibleNumber的值为"abc"，则convertedNumber输出nil。
  • Swift使用nil代表“值缺失”，因此上面的例子中当possibleNumber的值为”abc”时，convertedNumber会输出nil。

注意：只有可选类型的变量或常量才能接受nil，非可选类型的常量或变量不能接受nil。如果声明一个可选常量或变量但是没有赋值，系统会自动将其置为nil。

  1. let a: Int = nil;  // Int类型不能置为nil，程序报错
  2. let b: Int? = nil; // Int?可选类型允许置为nil

if语句以及强制解析

  • Swift允许使用if语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”（==）或“不等”（!=）来执行比较。Int?类型与Int类型并不是相同的类型，程序不能直接把Int?类型的变量或常量当成Int类型的变量或常量使用，当你确定可选类型确实包含值之后，可在可选类型变量或常量后添加英文感叹号!进行强制解析。
  1. let roomNumber: Int? = 1101
  2.  
  3. if roomNumber == nil {
  4.     print("当前无房间！")
  5. }else {
  6.     print("当前有房间，房间号为：\(roomNumber!)")
  7. }
  8.  
  9. // 输出 当前有房间，房间号为：1101

注意：Swift的强制解析是有前提的：必须可选类型的变量或常量确实有值才能解析成功。使用!来获取一个不存在的可选值会导致运行时错误。

可选绑定

  • 可选绑定用于判断可选类型的变量或常量是否有值，如果可选类型的变量或常量有值就赋给另一个临时的变量或常量。
  1. var str = "123"
  2. if var temp = Int(str) {
  3.     print("转换成功，其值为：\(temp)")
  4. }else{
  5.     print("转换失败！")
  6. }
  7. // 输出 转换成功，其值为：123

隐式可选类型

  • 可选类型暗示了常量或者变量可以“没有值”。可选可以通过if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。

  • 有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。

  • 这种类型的可选状态被定义为隐式解析可选类型。把想要用作可选的类型的后面的问号( String? )改成感叹号( String! )来声明一个隐式解析可选类型。

  • 当可选类型被第一次赋值之后就可以确定之后一直有值的时候,隐式解析可选类型非常有用。隐式解析可选类型 主要被用在 Swift 中类的构造过程中。

  • 一个隐式解析可选类型其实就是一个普通的可选类型,但是可以被当做非可选类型来使用,并不需要每次都使用 解析来获取可选值。

  • 隐式可选类型与显示可选类型用法一致，区别在于对数据的解析，如String?与String!的区别在于：当程序需要获取String?的变量或常量的值时，程序必须在变量或常量后面添加!后缀执行强制解析；但当程序需要获取String!类型的变量或常量的值时，无需在变量或常量后添加!后缀执行强制解析。

  1. var phoneType: String! = "iPhone"
  2.  
  3. print(phoneType) // 输出 iPhone， 无需使用 ! 进行强制解析

注意： 如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

Guard语句

  • guard语句和if语句有点类似，都是根据其关键字之后的表达式的布尔值决定下一步执行什么。但与if语句不同的是，guard语句只会有一个代码块，不像if语句可以if else多个代码块。

  • guard语句判断其后的表达式布尔值为false时，才会执行之后代码块里的代码，如果为true，则跳过整个guard语句。

举例分析

  • 我们以今年高考为例，在进入考场时一般都会检查身份证和准考证，我们写这样一个方法：
  1. func checkup(person: [String: String!]) {
  2.  
  3.     // 检查身份证，如果身份证没带，则不能进入考场
  4.     guard let id = person["id"] else {
  5.         print("没有身份证，不能进入考场!")
  6.         return
  7.     }
  8.  
  9.     // 检查准考证，如果准考证没带，则不能进入考场
  10.     guard let examNumber = person["examNumber"] else {
  11.         print("没有准考证，不能进入考场!")
  12.         return
  13.     }
  14.  
  15.     // 身份证和准考证齐全，方可进入考场
  16.     print("您的身份证号为:\(id)，准考证号为:\(examNumber)，请进入考场!")
  17.  
  18. }
  19.  
  20. checkup(["id": "1101"]) // 输出 没有准考证，不能进入考场!
  21. checkup(["examNumber": "S1101"]) // 输出 没有身份证，不能进入考场!
  22. checkup(["id": "1101","examNumber": "S1101"]) // 输出 您的身份证号为:1101，准考证号为:S1101，请进入考场!

  • 上述代码中的第一个guard语句用于检查身份证，如果检查到身份证没带，也就是表达式为false时，执行大括号里的代码，并返回。第二个guard语句则检查准考证。

  • 如果两证齐全，则执行最后一个打印语句，上面的两个guard语句大括号内的代码都不会执行，因为他们表达式的布尔值都是true。

  • 这里值得注意的是，id和examNumber可以在guard语句之外使用，也就是说当guard对其表达式进行验证后，id和examNumber可在整个方法的作用域中使用，并且是解包后的。

guard与if语句的区别

  • guard必须强制有else语句

  • 只有在guard审查的条件成立，guard之后的代码才会运行 (像守卫一样，条件不符就不让过去)。

错误处理

  • 错误处理主要用于应对程序执行中出错的条件。相对于可选中运用值的存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传送至程序的其他部分。

  • 当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。

  1. func canThrowAnErrow() throws{
  2.  
  3.     //this function may or may not throw an error
  4.  
  5. }
  • 一个函数可以通过在声明中添加throws关键词来抛出错误消息。当你的函数能抛出错误消息时，你应该在表达式中前置try关键词。
  1. do {
  2.  
  3.     try canThrowAnErrow()
  4.     // 没有错误消息抛出
  5.  
  6. } catch {
  7.  
  8.     // 有一个错误消息抛出
  9. }
  • 一个do的声明创建了一个新的包含作用域，使得错误能被传播到一个或更多catch从句。

举例分析

如何建造异常类型？

  • 在Swift中，如果想要抛出错误，那么抛出的对象必须遵守ErrorType协议，enum枚举是建立异常类型的最好方法。
  1. // 出去玩可能被导致去不了的原因
  2. enum PlayError: ErrorType {
  3.  
  4.     case NoGoodWeather // 没有好天气
  5.     case NoMoney       // 没有钱
  6.     case NoTime        // 没有时间
  7.     case NoPartner     // 没有伙伴
  8. }

如何抛出异常？

  • 在抛出异常之前，我们需要在函数或方法的返回箭头->前使用throws来标明将会抛出异常，并在函数或者方法里使用throw扔出异常即可。
  1. // 检查导致不能出去玩的原因是否存在
  2. func checkIsPlay(isNoGoodWeather: Bool,isNoMoney: Bool,isNoTime: Bool,isNoPartner: Bool) throws {
  3.  
  4.     guard isNoGoodWeather else {
  5.         throw PlayError.NoGoodWeather
  6.     }
  7.  
  8.     guard isNoMoney else {
  9.         throw PlayError.NoMoney
  10.     }
  11.  
  12.     guard isNoTime else {
  13.         throw PlayError.NoTime
  14.     }
  15.  
  16.     guard isNoPartner else {
  17.         throw PlayError.NoPartner
  18.     }
  19. }
  • 上面这段代码使用了guard来进行unwrap optional value。

如何获取并处理异常？

  • 使用do-catch机制获取和处理异常
  1. func Play(isNoGoodWeather: Bool,isNoPartner: Bool) {
  2.     do {
  3.         try checkIsPlay(isNoGoodWeather,isNoMoney: isNoMoney,isNoTime: isNoTime,isNoPartner: isNoPartner)
  4.         print("随便耍！")
  5.     }catch PlayError.NoGoodWeather {
  6.         print("天气不好，不去耍了！")
  7.     }catch PlayError.NoMoney {
  8.         print("没有钱，不去耍了！")
  9.     }catch PlayError.NoTime {
  10.         print("没有时间，不去耍了！")
  11.     }catch PlayError.NoPartner {
  12.         print("没人陪我，不去耍了！")
  13.     }catch {
  14.         print("见鬼了")
  15.     }
  16. }
  • 这个do-catch语句和switch语句有一些相似之处，被捕获的错误详尽无遗，因此你可以使用这种样式来捕获抛出的错误。还要注意关键字try的使用。它是为了明确地标示抛出的代码行，因此当阅读代码的时候，你能够立刻找到错误在哪里。

不处理异常

  • 如果我不想处理异常怎么办，或者说，我非常确定某个方法或者函数虽然声明会抛出异常，但是我自己知道我在使用时候是绝对不会抛出任何异常的。这种情况下 我们可以使用try!。

断言

断言简介与使用

  • 断言会在运行时判断一个逻辑条件是否为true。如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码运行停止，你的应用被终止。

  • 可以使用assert函数来写一个断言。向assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为false的时候这条信息会被显示：

  1. let age = 16
  2.  
  3. assert(age >= 18,"有未成年人进入网吧！") // 因为age < 18，程序奔溃！

何时使用断言？

当条件可能为假时使用断言,但是最终一定要保证条件为真,这样你的代码才能继续运行。断言的适用情景:

  • 整数类型的下标索引被传入一个自定义下标脚本实现,但是下标索引值可能太小或者太大。

  • 需要给函数传入一个值,但是非法的值可能导致函数不能正常执行。

  • 一个可选值现在是nil,但是后面的代码运行需要一个非nil值。

注意：断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而,在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。

参考网址：
http://wiki.jikexueyuan.com/project/swift/
http://www.cocoachina.com/swift/20150619/12186.html

参考资料：《疯狂Swift讲义》

@H_404_1207@

猜你在找的Swift相关文章

Swift 正式开源，同时开源 Swfit 核心库和包管理器
Swift 正式开源！Swift 团队很高兴宣布 Swift 开始开源新篇章。自从苹果发布 Swfit 编程语...
Swift开源短短一天不到Github就有9000多star
快，快，快！动动您的小手，分享给更多朋友！ 苹果去年推出了全新的编程语言Swift，试图让...
苹果的Swift语言开源了！
开发者（KaiFaX） 面向开发者、程序员的专业平台！ 和今年年初承诺的一样，苹果贴出了Swif...
使用 Swift 构建自定义的ActivityIndicator View
本文由@Chun发表于Chun Tips ：http://chun.tips/blog/2014/12/11/shi-yong-swift-gou-jia...
Swift中编写单例的正确方式
本文由CocoaChina译者leon(社区ID)翻译 原文：THE RIGHT WAY TO WRITE A SINGLETON 在之前...
Swift中编写单例的正确方式
本文由CocoaChina译者leon(社区ID)翻译 原文：THE RIGHT WAY TO WRITE A SINGLETON 在之前...
Swift 的 NSDate 初学者指南
译者：ray16897188；校对：numbbbbb；定稿：Cee 如果问我在做过的所有项目中做的最多的事情...
10 个最佳的 Swift 教程实例
★ 时间就是金钱。你可以一开始就使用正确的 Swift 教程来节省时间。本文中提到的教程都是...
Swift Package Manager快速上手指南（一）：环境搭建
CSDN移动将持续为您优选移动开发的精华内容，共同探讨移动开发的技术热点话题，涵盖移动应...
编写高性能的 Swift 代码
下面这篇文档收集了一系列编写高性能 Swift 代码的要诀和技巧。文档的目标读者是编译器和标...
iOSAndroidSwiftHybridCocos2d-xFlutterXcodeSilverlightcocoaCordova
调试桥筛选栏假异步不会丢失AndPermissio权限申请抽屉式systemUI信号栏多行排列跨多行显示viewmode数据共享录制语音视频通话多行显示Studio3.5拉伸控件望远镜发动态走势图点赞控件显示牌冷启动v3签名v2签名v1签名本地html外接键盘流式标签