望其项背 iOS - swift: 变量，常量，基本数据类型，类型转换，类型别名，元组，可空类型，运算符，??，类型后跟!和?，值后跟!和?，m...n，m...，...n，m..<n，控制台打印数据，注释可嵌套，语句末尾可以不加分号，数据转换
示例如下:
SwiftView01.swift
/*
* 本例用于演示变量，常量，基本数据类型，类型转换，类型别名，元组，可空类型，运算符，??，类型后跟!和?，值后跟!和?，m...n，m...，...n，m..<n，控制台打印数据，注释可嵌套，语句末尾可以不加分号，数据转换
*/
import SwiftUI
struct SwiftView01: View {
var result: String = "";
init() {
// print() - 在控制台打印数据
print("webabcd");
/*
/*
* 注释可嵌套
*/
*/
result = sample1(); // 变量和常量
result += "
";
result += sample2(); // 基本数据类型
result += "
";
result += sample3(); // 元组
result += "
";
result += sample4(); // 可选类型（Optional），即可空类型
result += "
";
result += sample5(); // 运算符
result += "
";
result += sample6(); // 范围运算符（m...n，m...，...n，m..<n）
result += "
";
result += sample7(); // 数据的类型转换
}
var body: some View {
VStack {
HStack {
Text(result)
Spacer()
}
Spacer()
}
}
func sample1() -> String {
var a = ""; // var - 变量
a = "a"
let b = "b"; // let - 常量（准确的说是不可变变量，即在运行时决定而不是编译时决定）
let 中文 = "c"; // 变量名支持任意 unicode 字符
let `var` = "d"; // 用 swift 的关键字做变量名的话要用 `` 包围起来
let e = "e", f = "f"; // 在一行里声明多个变量用 , 隔开
let g = "g" // 语句末尾可以不加分号（除非多条语句在同一行）
return a + b + 中文 + `var` + e + f + g; // abcdefg
}
func sample2() -> String {
// 支持 Int, Int64, UInt, UInt64, Float, Double, Bool, String, Character 等基本数据类型
let a: Int = 10; // 通过在变量名后面加上 :数据类型 来指定变量的数据类型（不指定的话则由编译器自己推断）
let b: Double = 10.0;
// var c = a + b; // 注意：swift 不支持数据类型的隐式转换，这句会编译时报错的
let c = Double(a) + b; // 需要对数据类型做强制转换
let d = 1.0; // 编译器会将数据类型推断为 double 而不是 float
let e = 0b11111111; // 二进制
let f = 0o377; // 八进制
let g = 0xff; // 十六进制
// e 跟在十进制数后面，代表 10 的 n 次方，结果是 double 类型，此句意为 123 乘以 10 的 3 次方
let h = 123e3;
// p 跟在二进制数后面，代表 2 的 n 次方，结果是 double 类型，此句意为 15 乘以 2 的 3 次方
let i = 0xfp3;
// 通过 _ 连接数字，以便阅读
let j = 12_345_67.1_23_4567;
// typealias - 为类型指定别名
typealias MyInt = Int;
let k: MyInt = 100;
// 10, 10.0, 20.0, 1.0, 255, 255, 255, 123000.0, 120.0, 1234567.1234567, 100
return "(a), (b), (c), (d), (e), (f), (g), (h), (i), (j), (k)";
}
func sample3() -> String {
// 元组（Tuple）用于将多个值组成一个复合值
var a: (Int, Bool, String) = (1, true, "webabcd");
// 通过 .0 .1 .2 之类的访问元组中指定索引位置的元素
a.0 = 100;
// 元组分解，如果你不想用元组中的某些元素，就用 _ 代表他
let (b, c, _) = a;
// 元组定义时，可以指定每个元素的名称
var d = (p1:"v1", p2:"v2");
// 通过指定元素名称访问元组中的指定元素
d.p1 = "v100";
// 100, true, webabcd, 100, true, v100, v2
return "(a.0), (a.1), (a.2), (b), (c), (d.p1), (d.p2)";
}
func sample4() -> String {
// 类型后面跟 ? 用于声明可选类型（Optional），即可空类型
let a: Int? = nil;
let b: Int? = 100;
// 值后面跟 ! 用于强制取出可空类型中的值
// let a2 = a!; // 此句会运行时报错，因为 a 是 nil
let b2 = b!; // 此句运行正常，b2 会被推断为 Int 类型，而不是 Int? 类型
// 类型后面跟 ! 用于在需要的时候将可空类型隐式转换为对应的不可空类型
let c: Int! = b; // c 的类型是 Int?
let c2 = c; // c2 的类型是 Int?
let c3: Int = c; // c3 的类型是 Int
let c4 = c + 0; // c4 的类型是 Int
// 如下方式用于尝试取出可空类型中的值
if let d = b { // 可以取出可空类型 b 中的值，这里 d 会被推断为 Int 类型，而不是 Int? 类型
// nil, Optional(100), 100, Optional(100), Optional(100), 100, 100, 100
return "(a), (b), (b2), (c), (c2), (c3), (c4), (d)";
} else { // 可空类型 b 是 nil
return "不会走到这里"
}
}
func sample5() -> String {
// 经典的 + - * / 之类的运算符都是支持的，三元运算符 ? : 也是支持的
// 但是 ++ 和 -- 都是不支持的
let a: Int? = nil;
// ?? 的意思是：左侧的数据是 nil 则返回右侧的值，否则返回左侧的值
let b: Int = a ?? 123;
let c: String? = "webabcd";
let d: String? = nil
// 值后面跟 ? 然后再调用属性或方法的意思如下
// 1、左侧不为 nil 则调用右侧的属性或方法，然后将结果转换为对应的可空类型
// 2、左侧为 nil 则忽略右侧调用的属性或方法，直接返回 nil
// c?.count 的结果是 Optional(7)
// c!.count 的结果是 7
// d?.count 的结果是 nil
// nil, 123, Optional(7), 7, nil
return "(a), (b), (c?.count), (c!.count), (d?.count)";
}
func sample6() -> String {
let a = ["a", "b", "c", "d", "e", "f", "g"];
// 索引位置 2 到末尾
let b = a[2...]; // ["c", "d", "e", "f", "g"]
// 索引位置起始到 2
let c = a[...2]; // ["a", "b", "c"]
// 索引位置 2 到 4
let d = a[2...4]; // ["c", "d", "e"]
// 索引位置 2 到 3
let e = a[2..<4]; // ["c", "d"]
return "(a), (b), (c), (d), (e)";
}
func sample7() -> String {
// 以下演示如何做数据的类型转换（注：Swift 是不支持数据类型的隐式转换的）
let a = "123"; // String 类型
let b = Int(123) // Int 类型
let c = [1, 2, 3] // Array<Int> 类型
let d = Set(c) // Set<Int> 类型
let e = Array(d) // Array<Int> 类型
let f = Array<Int>(d) // Array<Int> 类型
let g = [Int](d) // Array<Int> 类型
return "(type(of: a)), (type(of: b)), (type(of: c)), (type(of: d)), (type(of: e)), (type(of: f)), (type(of: g))";
}
}