swift 基础语法(常量、变量、数值、布尔型、元组)

xy_ss

发布于 2023-11-22 09:07:39

1630

发布于 2023-11-22 09:07:39

文章被收录于专栏：浮躁的喧嚣

常量和变量

声明常量和变量

常量和变量必须在使用之前声明使用let关键字声明常量使用var关键字声明变量

let a = 10  //声明一个名字是 a 的新常量，并赋值为10 
var b = 20 //声明一个名字是 b 的变量，并赋值为20

可以在一行中声明多个常量或者多个变量，用逗号隔开

var x = 10, y = 20
let  a = 30, b = 40

类型标注

var name: String //声明一个类型为String,名字为name的变量
name = "jay"

可以在一行中定义多个同样类型的变量，用逗号分割，并在最后一个变量名之后添加类型标注

var x, y, z: Double

注意：一般来说，很少写类型标注，如果你在声明常量或者变量的时赋了初始值，swift可以推断出这个常量或者变量的类型，上述的例子中，没有给name赋初始值，它使用的是指定变量类型

命名常量和变量

常量和变量名称几乎可以包含任何字符，包括Unicode字符

let π = 3.14159
let 你好 = "你好世界"
let 🐶🐶🐶🐶 = "dog"

打印常量和变量

 var name:String
 name = "jay"
 print(name) // jay
 print("name is \(name)")// name is jay

注释

// 这是一个注释
/*这是一个注释*/

与C中的多行注释不同，Swift中的多行注释可以嵌套在其他多行注释中。您可以通过启动多行注释块然后在第一个块中开始第二个多行注释来编写嵌套注释。然后关闭第二个块，然后是第一个块

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

分号

Swift并不强制要求你在每条语句的结尾处使用分号（;）

let cat = "🐱"

Swift也可以按习惯添加分号

let cat = "🐱";

有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句

let cat = "🐱"; print(cat)

整型

整数是整数，没有小数部分，如42、-23
整数有符号（正，零或负）如Int32
无符号（正或零）如UInt8

整数范围

let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型

Int与UInt

一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int 和 UInt，长度与当前平台的原生字长相同

在32位平台上，Int 和 Int32 长度相同
在64位平台上，Int 和 Int64 长度相同
在32位平台上，UInt 和 UInt32 长度相同
在64位平台上，UInt 和 UInt64 长度相同

浮点数

浮点数是有小数部分的数字，如3.14159、0.1 、 -273.15
Double表示64位浮点数（当你需要存储很大或者很高精度的浮点数时请使用此类型）
Float表示32位浮点数（精度要求不高的话可以使用此类型）

类型安全和类型推断

Swift是一个类型安全（type safe）的语言，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误

let meaningOfLife = 42 //推测为 Int 类型
let pi = 3.14159 // 当推断浮点数的类型时，Swift 总是会选择 Double 而不是Float

表达式中同时出现了整数和浮点数，会被推断为 Double 类型

let anotherPi = 3 + 0.14159 //anotherPi 会被推测为 Double 类型

数值型字面量

一个十进制数，没有前缀，如let decimalInteger = 17
一个二进制数，前缀是0b，如let binaryInteger = 0b10001
一个八进制数，前缀是0o，如let octalInteger = 0o21
一个十六进制数，前缀是0x，如let hexadecimalInteger = 0x11

数值型类型转换

常量a是UInt8类型，常量b是UInt16类型,它们不能直接相加，因为它们类型不同。所以要调用UInt16(a)来创建一个新的UInt16数字并用a的值来初始化，现在两个数字的类型都是 UInt16，可以进行相加。目标常量 c 的类型被推断为 UInt16，因为它是两个 UInt16 值的和

let a :UInt8 = 10
let b :UInt16 = 20
let c = UInt16(a) + b

整数和浮点转换

整数和浮点数的转换必须显式指定类型

  let a = 3
  let b = 0.14159
  //let c = a + b //报错
  let c = Double(a) + b //正确

浮点数到整数

 //当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说 4.75 会变成 4，-3.9 会变成 -3
  let d = Int(c)   //3

类型别名

给现有类型再起另一个名字，使用typealias关键字

typealias weight = UInt16   //weight被定义为UInt16的一个别名
var value = weight.min  //实际上是UInt16.min

布尔值

true
false

元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型, (Int,String),(Int,Int,Bool)

元组的定义

//定义元组时，可以在元组中命名各个元素
let http200Status = (statusCode: 200, description: "OK")
//也可以直接定义
let http404Error = (404,"Not Found")

元组的访问

可以将元组的内容分解为单独的常量或变量

let http404Error = (404,"Not Found")
let (statusCode,statusMessage) = http404Error;
print(statusCode)//404
print(statusMessage)//Not Found

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记

let http404Error = (404,"Not Found")
let (statusCode, _) = http404Error
print("The status code is \(statusCode)")//The status code is 404

通过下标来访问元组中的单个元素，下标从零开始

let http404Error = (404,"Not Found")
print("The status code is \(http404Error.0)")//The status code is 404
print("The status message is \(http404Error.1)")//The status code is 404

如果在元组中命名元素，则可以使用元素名称来访问这些元素的值

let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")// Prints "The status code is 200"
print("The status message is \(http200Status.description)")// Prints "The status message is OK"

元组作为返回值元组在临时组合值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组

可选类型（Optionals）

optionals

使用可选类型（optionals）来处理值可能缺失的情况
可选的代表两种可能性：
- 有值
- 没有值
一个可选的 XXX 被写作 XXX? ，问号暗示包含的值是可选类型，也就是说可能包含 XXX 值也可能不包含值。

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
print(convertedNumber)  //Optional(123)

因为该构造器可能会失败，所以它返回一个可选类型（optional）Int，而不是一个 Int。也就是说可能包含 Int 值也可能不包含值。

nil

给可选变量赋值为nil来表示它没有值：

var value: Int? = 10  // value 包含一个可选的 Int 值 10
value = nil  // value 现在不包含值

声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil

var message: String?  // message 被自动设置为 nil

注意： nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。

if 语句以及强制解析

可以使用 if 语句和 nil 比较来判断一个可选值是否包含值,使用(==)或(!=)来执行比较

如果可选类型有值，它将不等于 nil

var code: Int? = 10
if code != nil {
   print("code contains some integer value")
}

当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。这被称为可选值的强制解析（forced unwrapping）

var code: Int? = 10
if code != nil {
    print("code has an integer value of \(code!).")//code has an integer value of 10.
}

注意： 使用 ! 来获取一个不存在的可选值会导致运行时错误。使用 ! 来强制解析值之前，一定要确定可选包含一个非 nil 的值。

可选绑定（optional binding）

使用可选绑定来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量

var code: Int? = 10
if let constantName = code {
     print("code has an integer value of \(constantName!).")
}
//(1)判断constantName是否有值，如果没有值就不执行大括号中的内容；
//(2)如果constantName有值的话，就把constantName进行解包

隐式解析可选类型（implicitly unwrapped optionals）

有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。这种类型的可选状态被定义为隐式解析可选类型

把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型。

一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 String 和隐式解析可选类型 String 之间的区别：

let name: String? = "xiaoming."
let studentName: String = name!  // 需要感叹号来获取值

let city: String! = "Shanghai."
let studentCity: String = city // 不需要感叹号

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

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021-06-08，如有侵权请联系 cloudcommunity@tencent.com 删除

swift