变量和常量的声明

//变量声明的形式
var name = "lucky"//直接赋值,系统可以自动推断出它为字符串类型
var age: Int //直接指明变量的数据类型
var string :String = "smile" //指明变量的类型并给它赋值

var a = 20 , b: String, c = "swift"//swift允许一行声明多个变量，用“,”隔开

print("his name is \(name)")//“\(变量)”这样的形式作为占位符

常量的声明，就是将var换成let

数据类型

//整形：用Int就可以了，对于32位平台，int就表示int32.对于64位平台，int就代表int64
let onemillion = 1_000_000//可以增加下划线作为分隔符，也可以在数值前添加0
print(onemillion)

//整形之间的转换必须是显示转换
var book1: Int16 = 100
var book2: Int32 = 30
var totalprice = Int32(book1) + book2
print(totalprice)


//浮点型
var w = -4.0 / 0.0
var f = 0.0/0.0
print(w)//得到负无穷大

//相同类型的浮点型才能进行计算
var width: Float = 2.1
var height: Double = 3.9

var area1 = width * Float(height)

var area2 = Int(width) * 4

类型别名

//类型别名
typealias Age = UInt64//用typealias将Age表示UInt64
let myage : Age = 10

元组

//元组声明的方式一：
var score = (140, 140, "优秀") //第一一个变量，它拥有3个参数，根据参数可以推断出参数的类型为int int string类型

//元组的声明方式二：指定好参数的类型，在对元组进行赋值
var health : (Int, Int, String)
health = (182, 78, "良好")//赋值时必须对所有的成员变量赋值
print(health)

//根据下标可以输出元素的值
print(health.0)

//元组的声明方式三：元组中还可以包涵元组
var test : (Int,(Int, String))
test = (10,(10, "swift"))
print(test.1.0)

//可以根据key value的方式声明元组变量
//定义元组变量，并给定初始值
//var score2 = (math: 140, english: 140, assessment: "a")

//指定value类型，根据key进行赋值。注意：key的顺序可以改变,也可以根据key取出元素的值
var score2 : (math: Int, english: Int, assessment: String)
score2 = (english: 140, math: 140, assessment: "swift")
print(score2.math)

可选类型

//可选类型
//任何已知类型后面紧跟？既可以代表可选类型 如：Int?
//可选类型的作用是表示值缺失的一种情况
var str2 = "hello"
var num : Int? = Int(str2)
print(num)//返回nil，nil在swift中也表示一个确切的值，标示值缺失

强制解析：

//强制解析：在变量或者常量后面添加!，注意：必须可选类型的变量和常量确实有值的情况下才能解析成功。
var num1: Int? = 10;
var num2: Int? = 20;
if num1 != nil && num2 != nil {
    let sum  = num1! + num2!//经过解析才能获得可选变量的值
}else{
    print("num1 或者 num2 为nil, 不能强制解析")
}

可选绑定：

//可选绑定：可以用在if和while中对可选类型的值进行判断并把值付给一个常量或者是一个变量
var str3 : String? = "swift"
if var tmp = str3 {
    print( (tmp))
}else{
    print("str3的值为nil，不能进行解析")
}

隐式解析可选类型：

//隐式解析可选类型：在已有类型的后面添加！，如：Int!适用于被赋值之后，不会重新变为nil的变量.swift会自动对变量进行强制解析。
var possiblestr: String! = "swift"
print(possiblestr)

接下来就说说swift中的运算符的概念

赋值运算符

///赋值运算符

var x = 3
var y = 4

//swift中不支持连续赋值
var a : Int
//var b = a = 20//swift中不支持连续赋值

算数运算符

//算数运算符:除法和求余
var c = 19/4
print(c)//得到整数部分

var d = 2.5 / 1.2
var f = 4.3 / 0.0//除数可以为0
print(d)//完全显示结果

//求余运算
var g = 5.2
//var h = -3.1
//var mod = g % h
//print(mod)//正负取决于被除数

//自增和自减
var a = 5
var b = a++ + 6//先执行运算，在自身加一
print(b)

var c1 = ++a + 6//现自身加一，在执行运算
print(c1)

溢出运算符

//溢出运算符，在加减乘除的前面加上一个&符号
var  willUnderflow = UInt8.min
//willUnderflow等于UInt8的最小值0
willUnderflow ＝ willUnderflow &- 1
print(willUnderflow)//根据二进制的计算返回结果

位运算符

//位运算符:针对的是二进制的计算
/*
 & 按位与
 ｜按位或
 ^按位或
 ~取反
 <<左位移
 >>右位移
 */

扩展后的赋值运算符

//扩展后的赋值运算符
/*
 += 对于 x += y 等价于 x = x +y
 -=
 *=
 /=
 &=
 |=
 */

区间运算符

//区间运算符 a..<b (包涵a但不包含b) a...b（包含a也包含b）
//半开区间运算符
for a in 0..<10{
    print(a)
}

//闭区间运算符
for a in 0...10{
    print(a)
}

比较运算符

//比较运算符：结果为Bool值，分为大于，等于，小于。
// ===特征相等运算符 !==特征不等运算符
//var c = a === b //只有a和b指向的类型实例相同时，c为true

逻辑运算符

//逻辑运算符
/*
 &&与
 ||或
 !非
 */

三目运算符

//三目运算符
var a = 5
var b = 3
var str = a > b ? "a大于b" : "a小于b"
print(str)

空合并运算符

//空合并运算符
let words = "hello"
var say : String?
var content = say ?? words//空合并的用法：say有值就会强制解包，content就为say的值；若say只是声明了一个变量，没有值，则content为words的值
print(content)

注意点：a ?? b
1.a必须是可选类型，b默认的类型必须要和a存储的类型保持一致
2.如果a为非空值，那么值b将不会被估值

流程控制

分支结构

常见的分支结构：
1.if判断
2.swift判断

let score = "c"

switch score {
    case "a":
    print("优秀")
    case "b":
    print("良好")
    case "c":
    print("中")
    case "d":
    print("及格")
    case "e":
    print("不及格")
default:
    print("成绩输入错误")
}

注意点：swift中每一个case块执行完毕后，会自动终止，不需要添加break。case中的代码必须包含至少一条可执行的语句，case中可以允许多个条件的存在，中间用“,”隔开。

swift提供了一个属性：fall through,使用fallthrough 语句贯穿，就是case执行完毕后，不会跳出循环，可以继续向下执行代码

var num = 5
var desc = "\(num)是"
switch num{
case 2, 3, 4, 5 :
    desc += "质数，而且还是"
    fallthrough
default :
    desc += "整数"
}
print(desc)//5是质数，而且还是整数

case后面的条件也可以为元组

var point = (X: 1 , y: 1)
switch point{
case (0 , 0) :
    print("(0 , 0)位于原点")
case (_ , 0) :
    print("(\(point.0) , 0)位于x轴上")
case (0...Int.max , 0...Int.max) :
    print("(\(point.0) , \(point.1)位于第一象限)")
default :
    break
}

case条件可以用于值绑定

//case值绑定，可以讲条件的值付给case中的新定义的变量
var point  = (x: 1 , y: 0)
switch point {
case (0 , 0):
    print("(0 , 0)位于原点")
case (var a , 0) :
    print("该点位于x轴上，x值为\(a)")
case var (x , y) where x > 0 && y > 0 ://条件值绑定
    print("(\(x) , \(y))位于第一象限")
default :
    break
}

循环结构

for循环

//for循环
for count in 0  ..< 10  {
    print(count)
}

let base = 3
let power = 10
var answer = 1
for _ in 1...power {//_表示可以忽略具体的变量
    answer *= base
}

嵌套循环

//标签：紧跟:的标示符，用来表示外层循环。只有放在循环语句或swift语句之前才有作用

outer: for i in 0..<5 {
    //内层循环
    for j in 0..<3{
        print("i的值为：\(i),j的值为\(j)")
        if j == 1 {
            break outer//通过标签outer结束外部循环
        }
    }
//break 结束循环，开始执行循环之后的代码；
//continue 忽略本次循环的剩下的语句，执行下一次循环，但不终止循环。

字符串的连接

var str = "hello"
str = str + "swift"
print(str)

//字符串与其它类型的拼接
str = "\(str),aaaaaa,\(100)"
print(str)

数组

//数组：可以有任意的类型
var arr = ["hello", "swift", 1, 3.1] as [Any]
print(arr)

//指定特定类型的数组
var arr1 = [String]()

字典

//字典
var dict = ["name" : "swift" , "age" : "3"]
print(dict)

//可以动态地为字典赋值
dict["sex"] = "man"
print(dict)