加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 百科 > 正文

Swift - 基础部分

发布时间:2020-12-14 01:52:02 所属栏目:百科 来源:网络整理
导读:常量和变量 常量和变量相当于一个容器,存储数据。常量和变量把一个名字名字和一个指定类型的值关联起来。常量的值一旦设定就不能更改,而变量的值可以任意更改。 声明常量和变量 Swift是强类型的语言,要求所有的常量和变量必须先声明,后使用,声明变量时

常量和变量

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

声明常量和变量

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

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

// 声明常量
let studentNumber = 1101

// 声明变量
var studentName = "Edward"

// 常量允许被修改
studentName = "Petter"
  • 在一行中声明多个常量或变量,用逗号隔开:
var x = 0.0,y = 0.0,z = 0.0

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

类型标注

  • 声明常量或变量时可加上类型标注,说明常量或变量中要存储的值的类型,程序要么通过let/var 变量名 :类型的形式显示指定该常量或变量的类型,要么为该常量或变量指定初始值—Swift编译器将会根据该初始值确定常量或变量的类型。
// 显示指定类型
let age: Int = 21 // Int
var name: String // String

// 隐式指定类型
var zipCode = 610000 // Int
let address = "ChengDu" // String

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

常量和变量的命名

  • Swift允许使用任何字符作为常量或变量名,包括Unicode码。但是不允许包含数学符号、箭头、非法字符、连线与制表符,也不能以数字开头。
let π = 3.1415926

var 姓名 = "Edward"

var ?? = "dogName_Akitas"

输出常量和变量

  • Swift使用print(_:)函数来输出常量和变量。
print(姓名) // 输出 Edward

print("Hello,word!") // 输出 Hello,word!

print("He's name is '(姓名)'.") // 输出 He's name is 'Edward'.

注释

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

分号

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

整形

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

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

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

浮点型

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

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

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

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

类型安全和类型推断

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

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

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

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

类型别名

  • 类型别名就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名,其格式为:typealias 类型别名 = 已有类型
typealias MyString = String

var variable: MyString // variable为MyString类型即String类型,因此只能赋字符串

布尔型

  • Swift有一个基本的布尔类型,叫做Bool,用于表示逻辑上的“真”或“假”,其提供了两个布尔常量:truefalse

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

let isLogin: Bool = true
if isLogin == true {
    print("已登录!")
}else {
    print("未登录")
}

// 输出 已登录!
  • Bool类型的值或变量也可用于三目运算符
let isLogin: Bool = true

isLogin == true ? print("已登录!") : print("未登录")

// 输出 已登录!
  • 如果程序在使用Bool类型的地方使用了非Bool值,Swift的类型检查机制会报错。
var i = 1
if i {
    // 这个例子不能通过编译,会报错
}

var i = 1
if i == 1 {
    // 这个例子会编译成功
}

// i == 1的比较结果是Bool类型,所以第二个例子可以通过类型检查

元组

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

定义元组类型的变量

// 定义元组变量,并指定初始值,系统推断该元组类型为:(String,Int,Double)
var studentInfomation = ("Edward",1101,93.2)

// 使用元组类型定义元组变量
var score: (String,Double)

// 为元组变量赋值时必须为所有成员都指定值
score = ("语文",98.5)
  • Swift允许元组的成员可以再次是元组
var programmingLanguage: (String,(String,String))

programmingLanguage = ("iOS",("Objective-C","Swift"))

获取元组中的元素值

  • Swift允许通过下标来访问元组的单个元素,元组的下标从0开始,元组的第1个元素的下标为0,第2个元素的下标为1……以此类推。
var studentInfomation = ("Edward",93.2)
var programmingLanguage: (String,(String,String))

programmingLanguage = ("iOS","Swift"))

print(studentInfomation.0) // 输出 Edward
print(studentInfomation.1) // 输出 1101

print(programmingLanguage.0) // 输出 iOS
print(programmingLanguage.1.0) // 输出 Objective-C
  • Swift允许将元组的元素拆分成单个的常量或变量,接下来即可正常使用这些常量或变量了。
var studentInfomation = ("Edward",93.2)

let (stuName,stuNumber,stuScore) = studentInfomation

print(stuName) // 输出 Edward
print(stuNumber) // 输出 1101
print(stuScore) // 输出 93.2
  • 如果程序只需要部分元组的元素,分解的时候可以使用下划线_作为被忽略部分的占位符。
var studentInfomation = ("Edward",93.2)

let (stuName,_,_) = studentInfomation

print("student's name is '(stuName)'.") // 输出 student's name is 'Edward'.

为元组中的元素命名

  • Swift允许在定义元组时给单个元素命名,命名之后,即可通过名字来获取相应元素值。
var 个人信息 = (姓名: "Charles",phoneNumber: 13219038892)

print("(个人信息.姓名)的手机号码是:(个人信息.phoneNumber)")
// 输出 Charles的手机号码是:13219038892

可选类型

可选和nil

  • 在任何已有类型的后面紧跟?即可代表可选类型,可选类型的变量用于处理“值缺失”的情况。可选类型表示:
有值,等于 x
或者
无值,等于 nil
  • 例子,Swift的String类型有一个叫做Int()的方法,作用是将一个String值转换成一个Int值。然而,并不是所有的字符串都可以转换成一个整数。字符串 "123" 可以被转换成数字123 ,但是字符串abc不行。
let possibleNumber = "123"

// convertedNumber 被推测为类型 "Int?",或者类型 "optional Int"
let convertedNumber = Int(possibleNumber)

print(convertedNumber) // 输出 Optional(123)

// 如果possibleNumber的值为"abc",则convertedNumber输出nil。
  • Swift使用nil代表“值缺失”,因此上面的例子中当possibleNumber的值为”abc”时,convertedNumber会输出nil。

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

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

if语句以及强制解析

  • Swift允许使用if语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。Int?类型与Int类型并不是相同的类型,程序不能直接把Int?类型的变量或常量当成Int类型的变量或常量使用,当你确定可选类型确实包含值之后,可在可选类型变量或常量后添加英文感叹号!进行强制解析。
let roomNumber: Int? = 1101

if roomNumber == nil {
    print("当前无房间!")
}else {
    print("当前有房间,房间号为:(roomNumber!)")
}

// 输出 当前有房间,房间号为:1101

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

可选绑定

  • 可选绑定用于判断可选类型的变量或常量是否有值,如果可选类型的变量或常量有值就赋给另一个临时的变量或常量。
var str = "123"
if var temp = Int(str) {
    print("转换成功,其值为:(temp)")
}else{
    print("转换失败!")
}
// 输出 转换成功,其值为:123

隐式可选类型

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

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

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

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

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

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

var phoneType: String! = "iPhone"

print(phoneType) // 输出 iPhone, 无需使用 ! 进行强制解析

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

Guard语句

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

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

举例分析

  • 我们以今年高考为例,在进入考场时一般都会检查身份证和准考证,我们写这样一个方法:
func checkup(person: [String: String!]) {

    // 检查身份证,如果身份证没带,则不能进入考场
    guard let id = person["id"] else {
        print("没有身份证,不能进入考场!")
        return
    }

    // 检查准考证,如果准考证没带,则不能进入考场
    guard let examNumber = person["examNumber"] else {
        print("没有准考证,不能进入考场!")
        return
    }

    // 身份证和准考证齐全,方可进入考场
    print("您的身份证号为:(id),准考证号为:(examNumber),请进入考场!")

}

checkup(["id": "1101"]) // 输出 没有准考证,不能进入考场!
checkup(["examNumber": "S1101"]) // 输出 没有身份证,不能进入考场!
checkup(["id": "1101","examNumber": "S1101"]) // 输出 您的身份证号为:1101,准考证号为:S1101,请进入考场!
  • 上述代码中的第一个guard语句用于检查身份证,如果检查到身份证没带,也就是表达式为false时,执行大括号里的代码,并返回。第二个guard语句则检查准考证。

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

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

guard与if语句的区别

  • guard必须强制有else语句

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

错误处理

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

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

func canThrowAnErrow() throws{

    //this function may or may not throw an error

}
  • 一个函数可以通过在声明中添加throws关键词来抛出错误消息。当你的函数能抛出错误消息时,你应该在表达式中前置try关键词。
do {

    try canThrowAnErrow()
    // 没有错误消息抛出

} catch {

    // 有一个错误消息抛出
}
  • 一个do的声明创建了一个新的包含作用域,使得错误能被传播到一个或更多catch从句。

举例分析

如何建造异常类型?

  • 在Swift中,如果想要抛出错误,那么抛出的对象必须遵守ErrorType协议,enum枚举是建立异常类型的最好方法。
// 出去玩可能被导致去不了的原因
enum PlayError: ErrorType {

    case NoGoodWeather // 没有好天气
    case NoMoney       // 没有钱
    case NoTime        // 没有时间
    case NoPartner     // 没有伙伴
}

如何抛出异常?

  • 在抛出异常之前,我们需要在函数或方法的返回箭头->前使用throws来标明将会抛出异常,并在函数或者方法里使用throw扔出异常即可。
// 检查导致不能出去玩的原因是否存在
func checkIsPlay(isNoGoodWeather: Bool,isNoMoney: Bool,isNoTime: Bool,isNoPartner: Bool) throws {

    guard isNoGoodWeather else {
        throw PlayError.NoGoodWeather
    }

    guard isNoMoney else {
        throw PlayError.NoMoney
    }

    guard isNoTime else {
        throw PlayError.NoTime
    }

    guard isNoPartner else {
        throw PlayError.NoPartner
    }
}
  • 上面这段代码使用了guard来进行unwrap optional value。

如何获取并处理异常?

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

不处理异常

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

断言

断言简介与使用

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

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

let age = 16

assert(age >= 18,"有未成年人进入网吧!") // 因为age < 18,程序奔溃!

何时使用断言?

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

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

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

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

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

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

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

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读