swift基础（一）

常量和变量

常量&变量的使用原则：
尽量先用 let，只有需要变的时候，再用 var，能够更加安全

// 定义变量
var i = 10
print(i)

i = 15
print(i)

//: 定义常量
let j = 20

// 常量一经定义不能自改数值
//j = 25
print(j)

数组

格式：[] / Int / Array()
let 不可变数组
var 可变数组

初始化数组

var mutableArray = [Any]()
mutableArray.append("当我唱起这首歌")
mutableArray.append("小红帽和大灰狼")

for arr in mutableArray {
    print(arr)
}

定义数组

let array:[Any] = ["lnj", "lmj"]

遍历

for arr in array {
    print(arr)
}

在swift中 数组可以存放任意类型

var mutableArray2 = ["停在这里", 123, 345.98] as [Any]

数组的基本操作

//增
mutableArray2.append("456")

for arr in mutableArray2 {
    print(arr)
}

//合并数组
mutableArray += array

for arr in mutableArray {
    print("合并完的数组元素\(arr)")
}

//删
mutableArray.remove(at: 0)

for arr in mutableArray {
    print("删除完数组中第一个元素\(arr)")
}

print(mutableArray.count)

//修改-替换
let range:CountableRange = (1..<1)

mutableArray.replaceSubrange(range, with:[7])


for (index,str) in mutableArray.enumerated() {
    print("\(index):\(str)")
}

for arr in mutableArray {
    print("替换完的数组元素\(arr)")
}

print(mutableArray.count)

mutableArray[2] = "fja;s"
for arr in mutableArray {
    print("替换完的数组元素\(arr)")
}

//添加
let addArrar:[Any] = ["后者添加1", "后者添加2", "后者添加3"]
mutableArray.append(addArrar)

for arr in mutableArray {
    print("后者添加过的数组元素\(arr)")
}

//插入
mutableArray.insert(345, at: 2)
print(mutableArray[2])

mutableArray.insert(contentsOf: addArrar, at: 3)
for arr in mutableArray {
    print("插入完的数组元素\(arr)")
}

字典

格式 [:]
let不可变字典
var 可变字典

var dict:[String: NSObject]
dict = [String: NSObject]()
let sex: Bool = true
dict = ["name":"张丽", "age":25, "weight":156.5, "height":180, "sex":sex] as [String: Any] as! [String : NSObject]

遍历字典

for (k, v) in dict {
    print("\(k) = \(v)")
}

获取元素

print("根据key值name取值 == \(String(describing: dict["name"]))")
print(dict["age"] as Any)

字典的基本操作

添加元素 如果key值不存在会新增
dict["gender"] = "man" as NSObject
dict

//替换元素
dict["sex"] = "woman" as NSObject
dict

//删除元素
dict.removeValue(forKey: "height")

//合并字典
var dict2 = ["score": 99]
for (k1, v1) in dict2 {
    dict[k1] = v1 as NSObject
}

for (k, v) in dict {
    print("\(k) = \(v)")
}

字符串

swift中的字符串是一个结构体，支持遍历
oc中的字符串是一个对象
swift中的字符串String和oc中的NSString可以很方便的进行转换

oc语言中的字符串是以\0结尾的，swift不是

var stringValue2 = "abc\0efg"
print(stringValue2)

var string = "面带微笑着"
for c in string {
    print(c)
}

字符串基本操作

//字符串拼接
var str2 = "假装过头了"
string += str
print(string)

let age:Int? = 30
let name = "小贱"

//字符串拼接的时候，如果是可选项，要特别注意，带上Optional
let str3 = "name = \(name), age = \(age!)"
print(str3)

//需要格式拼接 00:00:00
let formaterStr = String(format: "%02d:%02d:%02d", arguments: [9, 10, 22])
print(formaterStr)

//字符串截取，建议使用NSString
let str4 = "小二郎，上学堂"
//将String字符串转换成NSString
let nsStr: NSString = str4 as NSString
print("nsStr = \(nsStr)")
let subStr = nsStr.substring(with: NSMakeRange(3, 1))
let resultStr = nsStr.substring(with: NSMakeRange(0, 3)) + nsStr.substring(with: NSMakeRange(4, 3))
print(subStr)

//字符串转数组
let strArray = str4.components(separatedBy: "，")
for c in strArray {
    print(c)
}

//数组转字符串
let arrays = ["丽莎娜", "liability", "礼拜"]
let arrayStr = arrays.joined(separator: ",")
print(arrayStr)

元组(tuples)

可以使用一个变量来存储多个不同类型的值，把多个值组合成复合值
元组中的值可以是任意类型，并不要求是相同类型

let person = ("张三", 18, 175)
let personTwo = (twoName:"zhangli", twoAge:19)

从元组中取值

let (personName, personAge, personWeight) = person
print("姓名 == \(personName) 年龄 == \(personAge) 体重 == \(personWeight)")
//输出单斜杠 \
print("\\")
print("/")
print(personTwo.twoName)
print(personTwo.twoAge)

如果只是取部分值，那么其他的可以用下划线“_”代替

let (pName, _, _) = person
print(pName)

函数返回值可以是多个，OC中函数的返回值 只有一个

func personFunc () ->(String,Int,Int) {
    return ("asdf",11,22)
}

let dic = ["sdf":"asdf","age":22] as [String : Any]
for (k, v) in dic {
    print(k)
    print(v)
}

元组在switch语句中使用

let pointTuples = (3, 10)
switch pointTuples {
case (0, 0):
    print("坐标原点")
case (1...10, 1...10):
    print("x 和 y 坐标范围是位于1-10之间的")
case (_, 0):
    print("点在X轴上")
case (0, _):
    print("点在Y轴上")
default:
    print("其他")
}

自动推导

能够根据右边的代码，推导出变量的准确类型

let num = 10
print(#function)

let view = UIView(frame:CGRect(x: 10, y: 20, width: 50, height: 20))
//修改视图属性，依然使用常量（没有修改视图的指针地址）
view.backgroundColor = UIColor.red

//如果需要指定变量和常量的类型，可以使用 let x:类型 = 值
let a: Int = 3
print(a)

可选项optional 可选类型

常量使用之前必须初始化 不同类型之间的值不可以直接运算，如果没有值则默认nil，不是任何数据类型，不参与计算

let oy:Int?
oy = 20
// “ ！”强行解包，在可选值中选择非空值，如果值初始化nil，会崩溃
print(oy!)

let oy1:Int? = 22
print(oy1!)

逻辑分支

条件不需要（），语句必须有{}

//1>、简单的分支
if j < 6 {
    print(true)
} else {
    print(false)
}

//2>、三目（三目语法和OC一样）
i > 5 ? print(true) : print(false)

//3>、switch
/*
 1、switch 可以针对任意类型的值进行分支，不再局限整数
 2、switch 一般不需要break
 3、switch 如果多时，使用‘,’
 4、所有的分支至少需要一条指令，如果什么都不干，才使用break
 */

func abc (num:String){
    demo(num: "sf")
}

func demo(num:String) {
    switch num {
    case "10", "9":
        print("优")
    case "6":
        print("中")
    case "6":
        print("差")
    default:
        print("一般")
    }
}

let point = CGPoint(x: 10, y: 10)
switch point {
case let p where p.x == 0 && p.y == 0:
    print("原点")
default:
    print("其他点")
}

可选类型的判断

if let 和 guard let 的技巧
//使用同名的变量接收者，在后续使用的都是非空值，不需要解包；（可以避免命名的烦恼）
guard 守卫、守护
guard let 和 if let 刚好相反

let name:String? = "王五"
var age = 18

if let name = name {
    print(name + String(age))
} else {
    print("姓名或者年龄为空")
}

if name != nil {
    print(name! + String(age))
} else {
    print("姓名或者年龄为空")
}


//guard let 守护一定有值，如果没有直接返回

func demo2() {
    guard name != nil else {
        print("姓名或者年龄为 nil")
        return
    }
}

guard let 守护一定有值，如果没有直接返回
func demo2() {
guard name != nil else {
print(“姓名或者年龄为 nil”)
return
}
}

func demo3() {
    if name != nil && age > 10 {
        print(name! + String(age) + "房间打扫了")
        return
    }
}

if let 连用，判断对象是否为 nil ，{}内一定有值，不需要解包，可以直接使用
if var 连用，{}内可以对值进行修改

if let oName = name, var ageA = age {
    age = 33
}
print(age)

?? 是一个简单的三目
如果有值，使用值
没有值，使用 ?? 后边的值代替
?? 优先级比较低，在使用的时候最好加上 ()

print((j ?? 0) + (age ?? 0))

指定类型

在swift中不会做隐式转换，如果要对不同类型的数据进行计算，必须显示类型转换（强制类型转换）
swift中整数默认类型为Int64 == long
小数默认类型为Double(OC中使用比较多的是CGFloat)

let dValue: Double = 12.3
print(dValue)

let sum = Double(num) + dValue
print(sum)

let size = CGSize(width: 10, height: 20)
//Double和CGFloat 也需要转换
let res = size.width + CGFloat(dValue)
print(res)

var dV: Double = 11.1
var iV: Int
iV = Int(dV)

print("iV = " + String(iV))
print("dv = " + String(dV))

循环

循环Swift写法
…闭区间, ..<半闭区间
0…10 / 0..<10 中间不能有空格

//  0~9之间
for i in 0..<10
{
    print(i)
}

// 0~10
for i in 0...10
{
    print(i)
}

忽略： _
不关心下标可以使用 _ 忽略下标
在swift中 _ 使用非常广泛

 for _ in 0...10 {
    print("for循环 - 忽略下标")
}

while 循环 没有 ++ – 等操作 只有 += -=

var n = 0
while n < 0 {
    n += 1
}

do while

var m = 0
repeat {
    print(m)
    m += 1
} while m < 10

枚举关联值与值绑定模式

当枚举中的关联值和值绑定模式结合起来，就能够达到从枚举中取得关联值的效果

enum Organism {
    case plant
    case animal(legs: Int)
}

let pet = Organism.animal(legs: 4)
let plant = Organism.plant
print(pet)
print(plant)

switch pet {
case .animal(let legs):
    print("\(legs) 条腿的动物")
default:
    print("植物")
}

//这段代码中 animal的关联值时一个叫legs的常量。

通配符模式（Wildcard Pattern）

通配符模式是由一个下划线（_）构成，用于匹配并忽略任何值。当你想忽略被匹配的值时，可以使用该模式
例如，下面这段代码在闭区间1…3中迭代，每次迭代都会忽略该区间当前的值

for _ in 1...3 {
//
}

标识符模式（Identifier Pattern）

标识符模式匹配任何值，并将匹配的值和一个变量或者常量绑定起来。例如，在下面的常量声明中，someValue是一个标识符模式，匹配了Int类型的42

let someValue = 42

当匹配成功时，42被绑定（赋值）给常量 someValue
如果一个变量或常量声明的左边是一个标识符模式，那么这个标识符模式是值绑定的子模式

值绑定模式（Value-Binding Pattern）

值绑定模式把匹配到的值绑定给一个变量或常量。把匹配到的值绑定给常量时，用关键字 let，绑定给变量时，用关键字 var
在值绑定模式中的标识符模式会把新命名的变量或常量与匹配到的值做绑定。
例如，你可以拆开一个元组，然后把每个元素绑定到相应的标识符模式中

switch pointTuples {
    //将pointTuples 中的元素绑定到 x 和 y
case let (x, y):
    print(" The pointTuples is at（\(x), \(y)）")
default:
    print("其他")
}