swift (一) var let 字符串 int double 元组 数组[] 字典[:] 可选类型 if while for 函数func 可选类型？

xcode 代码格式化

comand + a全选
ctrl + shift + i 格式化

var let

var声明的变量可以被修改

let声明的变量不能被修改

// var声明变量，可以修改
var a: Int = 20
a = 30

// let声明常量，赋值会不可以被修改
let b: Int = 20
//b = 30 //这里编译会报错

// let声明的常量可以在不在编译的时候确定
let b1:Int
b1 = a

//虽然可以一行声明多个变量，如下
//虽然可以一行定义多个变量，但是不推荐
var a = 10,b = 20

var a1,b1,c1 :Int
a1 = 100
b1 = 100
c1 = 100
print(a,b)

// 但是，如果实现格式化工具发现会拆分为一行定义一个变量
var a = 10
var b = 20

var a1: Int
var b1: Int
var c1: Int
a1 = 100
b1 = 100
c1 = 100

类型标注 + 类型推断

// 标注类型
var a:Int = 30
var b:String = "Hello world"
var c:Bool = true

// 自动推断
var a1 = 20
var b1 = "hello world"
var c1 = true

// 变量名称不能数字开头，不能关键字。如果非要用关键字，用反引号
var `var` = 100
print(`var`)

print

var a = 10
var b = 20
var c = 20
// print可以自定义结束符号，默认是回车
print(a,b,c,terminator: "\n-------下面是字符串的定义------\n")
var a1 = "Hello world"
var b1 =  "!"
// print可以自定义分隔符号，默认是空格
print(a1,b1,separator: "_")

// print字符串插值
var a = 10
var b = 20

// 插值
print("\(a) + \(b) = \(a + b)")

类型别名

typealias AudioSample = UInt16
// 取别名，可以调用原有的属性方法
var a = AudioSample.max

bool类型

只能是true和false两个值

var a:Bool = true
var b:Bool = false

字符串

// 字符串

var s1 = ""
var s2 = String()
if s1.isEmpty{

}

var s:String = "Hello world"
// 加反斜杠，是为了多行显示，增加可读性。其实还是一行
var ms:String = """
hello\
world
"""
print(ms)
print("--")

// 拓展字符，所有的字符串都不转义
var ms2 = #"""
    huiahsudias 121231\n\""\t
    asd
"""#
print(ms2)

//unicode
var a = "\u{1220}"


for i in 2665...10000 {

    // Unicode.Scalar 生成的是标量
//    if let scalar = Unicode.Scalar(i) {
//           print(String(scalar))
//       }
}

// 字符
let zifu1: Character = "!"
var zifuchuan1 = "Hello world"
//zifuchuan1 += zifu1 //类型不匹配，不能直接拼接
zifuchuan1.append(zifu1)

var content = "hello"
print(content[content.startIndex])
//print(content[content.endIndex]) 最后一个位置不能索引
print(content[content.index(before: content.endIndex)])

// 删除
print("-----删除字符串-------")
var r1 = "Hello world"
var r2:Character = "!"
// 插入一个字符
r1.insert(r2, at: r1.endIndex)
// 插入字符串
r1.insert(contentsOf: " This is a string text", at: r1.endIndex)

// 删除一个字符
print("removeat 之前",r1) // Hello world! This is a string text
r1.remove(at: r1.startIndex)

// 只删除了H
// r1 ello world! This is a string text
print("r1", r1)

// offsetBy:0表示只删除第一个，4
r1.removeSubrange(r1.startIndex...r1.index(r1.startIndex, offsetBy: 4))
print(r1) // world! This is a string text

print("字符串子串")
var longString = "This_is_a_long_string"
var index = longString.firstIndex(of: "a") ?? longString.endIndex
// 字符串子串没有是释放，原字符串也不会释放内存。所以临时用完，不可长期保存，如果长期报错，则需要重新转成String
var childString = longString[..<index]
var childStringNew = String(childString)


print("字符串比较 == !=")
var compare1 = "hello world"
var compare2 = "hello world"

if compare1 == compare2 {
    print("compare1 == compare2")
}

// 虽然他们的unicde不一样，但是都是表达的同样的字符，因此等价
// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"

if eAcuteQuestion == combinedEAcuteQuestion {
    print("These two strings are considered equal")
}

print("字符串hasPrefix   hasSuffix")
var prefix1 = "Hello Jack"
if prefix1.hasPrefix("Hello"){
    print("prefix1 begin with hello")
}
if prefix1.hasSuffix("Jack"){
    print("prefix1 end with Jack")
}

int double

// 整数类型
var a:Int
var a1:Int8
var a2:Int16
var a3:Int32
var a4:Int64
var a5:Int128
// Int默认是Int64
// 所有的Int类型都有对应的无符号类型，比如Int8，UInt8
// Int128是swift6新增加的类型
var a6:UInt8

print(Int128.max,Int128.min,separator: "\n")

// 浮点数
var a = 3.14 //默认就是Double
var a1:Float = 3.14
var a2:Double = 3.14

// 不同类型不能直接运算
//var total = a1 + a2
// 必须转成相同的类型
var total = a1 + Float(a2)

元组

// 元组，可以是任意类型

var a = (404, "http error")

var b = ("张三", 19, "北京")

// 语法错误，元组也是有类型
//b = a

// 也可以指定数据类型
var c:(String, Bool)
c = ("李白", true)

// 解构元组

let (c1, c2) = c
print(c1)//李白
print(c2)//true

集合类型

• 数组
• 集合
• 字典

数组

// 可变数组
var a = [100, 200, 300]
a.append(400)
print(a)

let b = [100, 200, 300]
// 不允许修改let变量
//b.append(400)

var a1:Array<Int> = []
a1.append(1)
a1.append(100)

// 简写这样
var a11:[Int] = []

// 虽然可以使用Any，但是不推荐
var a2:[Any] = ["Hello", 12]

// 初始化器语法创建数组
var a3 = [Int]()

print("使用默认值创建数组")
var defaultArray1 = Array(repeating: 100.1, count: 3)
var defaultArray2 = Array(repeating: 3.14, count: 3)
var defaultArray3 = defaultArray1 + defaultArray2

print("使用字面量创建数组")
var array2:[String] = ["hello", "world"]
print(array2)
// 也可以省略类型
var array22 = ["hello", "world"]
print(array22)

print("数组方法")

var array_func = [1, 2, 3]
print(array_func.count) // 3
if array_func.isEmpty {
    print("array_func 是空的")
}
// 追加元素
array_func.append(100)

// 拼接数组
array_func += [1, 2, 3]

// 获取数组元素 注意不能溢出
var array_func_0 = array_func[1]
print(array_func_0)

// 修改元素
array_func[0] = 123
// 指定位置插入
array_func.insert(345, at: 2)

print("删除元素")
var deleteArray = [100,200,300,400]
deleteArray.remove(at: 2)
deleteArray.removeFirst()
deleteArray.removeLast()
deleteArray.removeAll()

print("遍历数组")
var array_lit = [1, 2, 3, 4, 5]
for i in array_lit{
    print(i)
}
for (k,v) in array_lit.enumerated(){
    print(k,v)
}

集合

// 集合中的数据没有顺序，且不能重复
var s1 = Set<Int>()
s1.insert(1)
s1.insert(1)
s1.insert(100)
print(s1) // [1, 100]
s1 = [] //清空所有内容

var s2:Set<Int> = [100, 200]

// 可以推断是Set<String>类型
var s3:Set = ["jack", "john", "Lily"]

if s3.isEmpty {
    print("isEmpty")
}
if let ret = s3.remove("jack"){
    print("\(ret) removed")
}

if s3.contains("jobh"){

}

// 遍历
for v in s3 {
    print("\(v)")
}

// 集合的操作
// intersection 交集，两个集合都有的元素
// symmetricDifference 对称差集 仅属于其中一个集合，而不属于另一个集合
// union 并集 两个集合的所有元素
// subtracting 在一个集合，且不在另外一个集合中的元素

字典

// 字典
var dict1:[String:String] = [:]
dict1["name"] = "jack"
dict1 = [:] // 字典清空

var dic2:[String:String] = ["name":"zhangsan", "address":"Beijing"]

var dict3 = ["name":"zhangsan", "address":"Beijing"]

print(dict3.count)

if dic2.isEmpty{

}

if let oldvalue = dic2.updateValue("shanghai", forKey: "address") {
    print("old value is ", oldvalue)
}

// 删除
if let deleteValue = dic2.removeValue(forKey: "address"){

}

// 遍历
for (k,v) in dict3{
    print(k, v)
}
for k in dict3.keys{
    print(k)
}
for v in dict3.values {
    print(v)
}

可选类型

// 可选值

var a: Int?
print(a) // nil

a = 100
print(a) //Optional(100)

var c = a
print(c) // Optional(100)

// 可以通过两个问号，如果没有值，则返回后面的内容，
var v1:Int?
var value = v1 ?? 10
print("value is ", value)//10
v1 = 20
var value2 = v1 ?? 10 // 这里也解构了，是Int类型，不是Option类型
print("value2 is ", value2)//20

// 强制解包,如果为nil则崩溃
var value3 = v1! // 20

// 可以通过if let解构
if let v = a {
    print(v) // 100
}

// if var 或者if let都可以解构，可以取同样的名称，这里a = a!
if var a {
    // 这里是重新赋值的代码
    a = 10
    print(a) // 10
}
print(a) // Optional(100)

流程控制

if

let age = 18
let age1 = 20

if age > 18 {

    print("已经成年")
}

// if条件的括号可以写可以不写
if (age > 18) {
    print("已经成年")
}

if age > 18 {
    print("已经成年")
}else if age > 10 {
    print("青少年")
}


if age > 18 {
    print("已经成年")
}else if age > 10 {
    print("青少年")
}else{
    print("儿童")
}

if age > 20 && age1 > 100 {
    print("&&两个条件都成立进入这里")
}

if age > 20 || age1 > 100 {
    print("||其中一个条件成立进入这里")
}

// 去反
// 错误if !age > 20 因为！的优先级很高
if !(age > 20) {
    print("！条件不成立进入这里")
}

while

var sum = 0
var index = 0

while index <= 100 {
    sum += index
    index += 1
}
print(sum)

repeat while

var index = 0
var total = 0
repeat {
    total += index
    index += 1
}while(index < 101)
print(total)

for

// for

// for in 遍历数组
var a = ["Hello", "world"]
for v in a {
    print(v)
}
// for in 遍历字典
var b = ["name": "Jack", "addr": "Beijing"]
for (k, v) in b {
    print(k, v)
}


for v in 1..<5 {
    print("v is ", v)
}

let minuteInterval = 5
let minutes = 100
// 开区间
for tick in stride(from: 0, to: minutes, by: minuteInterval){
    // 每5个刻度调用一次
    print(tick)
}
// 闭区间
for tick in stride(from: 0, through: minutes, by: minuteInterval){
    // 每5个刻度调用一次
    print(tick)
}

switch

var a = "a"

switch a{
case "a":
    print("a")
case "b":
    print("b")
default:
    print("not match")
}

var result = switch a{
case "a":
    "hello"
case "b":
    "world"
default:
    "Jack"
}
print(result)

switch还支持多个匹配和范围匹配case "a", "A": ,case 5..<12: