Swift高级开发语言基础

var str = "Hello,playground"
// 变量声明规则
// var (let)变量名 = 值
var str1 = "abc"
str1 = "bcd"
// str1 = 2
// 类型推断,(根据给出的值对变量进行类型的推断和确定)

// ****************基本数据类型
var a = 10
var b = 20
// 关于整形的类型推断,在32位系统的环境下自动推断为Int32,64位环境 Int64
let maxnumber = 57 // 不可变的变量
// maxnumber++

// 指定变量类型 
// 语法格式:(var 变量:变量类型 = 值)
// 如果给定类型,在使用变量前进行赋值
var currentStudent: Int = 50
currentStudent++

// 浮点数自动类型推断为double(双精度)
var score = 90.2
// 需要使用float的话
var score1:Float = 90.5
// swift中不支持隐式类型转换,充分体现了swift的安全性,消除潜在威胁
//var sumscore = score + score1
// 必须转成同类型才可操作
// 类型转换 语法: 类型(变量)
var sumscore = score + Double(score1)
var sumscore1 = Float(score) + score1

// *************字符串
// 字符串自动推断类型为 string
let name = "赤发鬼"
// 字符型
let char:Character = "b"
// "+"运算符
let loClass = "150727"
let teaInfo = loClass + name
// "+"又名重载运算符,源于c++,可以直接用于字符串的拼接

// 字符串截取
// 1.
// string类型与Nsstring不同
var strTest = "0123456789"
// String.Index
var index = strTest.startIndex
var index_end = strTest.endindex
// 前一个位置predecessor
var index_p1 = index_end.predecessor()
var index_s1 = index.successor()
var subString = strTest.substringToIndex(index_s1)

// 2.
// 将String类型转成Nsstring类型
// 使用as关键字自定目标类型
var nsstring1 = (strTest as Nsstring).substringFromIndex(5)
var nsstring2 = (strTest as Nsstring).substringToIndex(4)

// 3.
var strTest2 = "01234567"
let index_str2 = strTest2.startIndex.advancedBy(3)
var subStringTest2 = strTest2.substringToIndex(index_str2)


// 在swift中,变量几乎支持所有的Unicode编码的字符,除了数学中的符号,下划线,特殊字符
var cat = "��"
var �� = "生气"
var 太阳 = "��"
var 日天 = "��☁️"

// 字符串可以通过传递一个值类型为Character的数组作为自变量初始化
let strCharacters:[Character] = ["a","b","c"]
let catStr = String(strCharacters)
print(catStr)


// **************数组
// 数组中只能存储相同类型的数据
var array = [1,2,3]// 自动推断为[Int]类型的数组
var array2 = ["12","21","12"]// [string]
var array3 = [1,"2","3"]
// 数组指定类型
// 1.语法:[Int]
var array4:[Int] = [1,3,4,5]
// 2.语法:array<Int>
var array5:Array<String> = ["1","3"]
var array6:Array = [1,"8"]
// 增加元素
array.append(4)
// 在某个位置插入数据
array.insert(2,atIndex: 1)
// 获取最后一个元素
array.last
// 获取第一个元素
array.first

// 删除
let c = array.removeAtIndex(1)
c

// 更改
array[0] = 5
array

// 查询
let d = array[1]

// 数组中重载元素安抚符的使用 +
array += array4
array
array4

// 区域运算符
// ... 1...2:从1到2得闭区间
// ..< 1..<2:从1到2得开区间
array[0...2]
array[0..<2]
array[0...2] = [11,22,33]
// 区间替换,数组中元素个数没有限制
array[0..<2] = [44,55,66,777]


//***************字典
// 键值对数组,字典的使用规则,键与键类型相同,值与值类型相同,键值类型可以不同
var dictionary = [1:"1",2:"2",3:"3"]
// 声明字典类型
// 1.[key:value]
var dictionary1:[Int: String] = [1:"2"]
// 2.Dictionary<key,value>
var dictionary2:Dictionary<String,Int> = ["1": 1]


// 查询
// 根据Key查询
let e = dictionary[1]
dictionary[1] = "a"
dictionary[4] = "4"
dictionary
// 根据key取值,进行赋值操作时如果key存在则执行更改操作,如果key不存在,执行插入操作

// 删除
var index_dic = dictionary.indexForKey(1)
dictionary.removeAtIndex(index_dic!)

//**************可选类型optional
// 可选类型的使用,可以声明nil的变量
// 语法规则 变量:变量类型?
var error:String? = nil
var score_xiaoming: Int? = nil
error = "error"
error! += "404"
error
// 可选类型的变量在赋时不需要加!,使用变量时需要加!
// !:解包
// 使用可选类型变量的时候,只有当程序开发人员确定当前可选类型有值是才会执行解包动作7

// **************元组
// 语法 () 源于关系型数组的概念,存储不类型的数据
// 元组可以作为函数的返回值,处理多返回值的情况
var status = (404,"Not Found!")
// 元组自带取值方式
status.0
status.1

// 可以对元组中数据进行命名获取
var status2:(num:Int,info:String) = status
status2.num

// 分支语句
// if 语句的条件必须是bool值或bool表达式
// BOOL值只能用true或者是false
let isOrNo = true
if isOrNo{
    print("true")
} else {
    print("false")
}


var count:Int? = nil
count = 20
if count > 0
{
    print(count!)
    // \()用于拼接变量和字符串
    print("数字count是\(count)")
} else {
    print(count)
}

let str_pinjie = "数字count是\(count)"

// 声明变量的表达式也可作为条件使用
if let count1 = count {
    print("ok")
} else {
    print("error")
}
// 注释:分置语句原则上必须保持完整

// 循环 while
var number = 0
while number < 3{
    number++
    print("number = \(number)")
}
// do...while
var number1 = 2
repeat {
    number1++
    print(number1)
}
while number1 < 5
// for

for (var number3 = 6; number3 < 10; number3++){
    print("number3 = \(number3)")
}

// for循环条件可以省略,但是分号不能省略
//for ; ; {
// print("循环")
//}

//for ; number < 2;{
// print(number)
// number++
//}


// for...in 循环,变量可以不声明,只作用于循环作用域中
for num in array {
    print(num)
}

var dic = [33 : "value"]
for value in dic {
    print(value)
    // 枚举字典的时候,获得的将是一个存放了键,值的元组,可通过元组的取值规范获取内容
    value.0
    value.1
}

// 使用元组枚举字典的时候,相当于为元组中的元素命名,可作为局部变量使用
for (key,value) in dic {
    print(key)
    print(value)
}

// 占位符:_
// 使用占位符忽略掉不想使用的变量
for (_,value) in dic {
    print(value)
}

for (key,_) in dic {
    print(key)
}

// 区域运算符在循环中的使用
for value in 0 ..< 1 {
    print(value)
}

for value in array[2..<3] {
    print(value)
}

// 分支 switch
var point = (2,0)
switch point {
case (0,0):
    print("原点")
case (_,0):
    print("x轴")
    // switch case 分支自带有break,如果想执行下一个分支,使用fallthrough
    fallthrough
case (0,_):
    print("y轴")
default:
    print("象限内")
}
// 只要case包含所有情况,可以不使用default分支
// switch语句必须包含所有的情况分支


// 值绑定
switch point {
case(0,0):
    print("原点")
case (let x,0):
    print("x轴")
    // fallthrough 不能下降到一个存在不确定变量的分支中
case (0,let y):
    print("y轴")
default:
    print("象限内")
}


switch point {
case(0,0)where x == 3 || x == 2:
    // where 在分支基础上可以添加限定条件,如果想添加多个限定条件的话,可以使用 && ||
    print("x轴")
case (0,let y):
    print("y轴")
default:
    print("象限内")
}

// 区间匹配
// switch 与区间运算符结合使用
var number2 = 20
switch number2 {
case 0...10:
    print(number2)
case 11...100:
    print(number2)
    fallthrough
case 101...200:
    print(number2)
default:
    print(number2)
}

for value in 1...100 {
    print(value)
    if value == 2 {
        break// 跳出循环
        // countinue // 跳出本次循环
    }
}

var tempString = "kjahfksiiqsaqawgwqghf"
// 遍历字符串 str.characters
// 当for...in循环与switch结合使用的时候,执行break语句首先被识别为switch分支自带的break,此时需要为循环添加别名,使用别名进行打断循环的操作
tempName: for tempStr in tempString.characters {
    switch tempStr{
        case "a","e","i","o","u":
            // 如果元音,打断循环
        print(tempStr)
        break tempName
    default:
        print(tempStr)
    }
}