聲明變量和常量

//1.基本數據類型：Int 整形，Double 和Float表示浮點型，Bool布爾值，String文本型數據，Array 數組，Dictionary 字典
//2.常量 let ，變量var
let con = 100
var avi = 30
avi = 40
//3.一行中聲明多個常量或者變量，用逗號隔開
var a = 3, b = 4, c = 5
//4.類型標注：如果聲明的同時附了初始值，并不需要類型標注
var who: String
who = "xiaoming"
print(who)

swift的基本語法

類型轉換

//類型轉換
let a: UInt8 = 10
let b: UInt16 = 110
print("\(UInt16(a) + b)")

//整形轉變成浮點型
let sa = 3
let pi = 3.1415
let add = Double(sa) + pi
print(add)

元組

//元組的補充：可以把任意的類型組合成元組，元組可以看成是一個復合的值
let people = (18, "xiaoming")
//可以把元組的內容單獨的分成常量和變量
let (age, name) = people
print(age)
print(name)

//如果我們只是需要一部分元組值，則可以把要忽視的部分用下劃線進行標記
let (age1, _) = people
print(age1)

//通過下標也可以訪問元組中的元素
print(people.0)

//定義元組的時候也可以根據單個元素命名,通過名字獲取元素的值
let rec = (w: 10, h: 20)
print(rec.w)

可選類型

//可選類型：處理值可能缺失的情況，可以表示任意類型的值缺失的情況
let str : String? = "12345"

//用if語句表示是否是可選類型
if str != nil {
    print(str!)//只有加上!才能獲取可選類型的值，表示對可選類型的強制解析
}

//判斷可選類型是否包含值的方式稱為可選綁定,在它的語法中可以聲明常量接受，也可以聲明變量接受
/*
 可選綁定可以用if和while語句中來對可選類型的值進行判斷，并賦值給常量或者是變量
 注意點：在swift中nil表示的是一個確切的值，而在oc中他表示一個指向不存在對象的指針
 */
if let str1 = str {
    print(str1)
}
var  servercode : Int? = 404
servercode = nil //現在servercode 不包含值
var sunny : String?

//隱式解析可選類型：當確定一個變量的值已定不為nil時，就可以把它設置成隱式解析可選類型
//第一次被賦值之后，可以確定變量的值不為nil
var possiblestr: String! = "swift"
print(possiblestr)//可以不通過!來獲取變量的值

斷言

//在值缺失，或者值并不滿足特定的條件，代碼就不會繼續執行，此時需要觸發一個斷言結束代碼的運行，通過調試找到值缺失的原因
let age2 = -10
assert(age2>=0, "年齡要大于0")//assert就表示一個斷言，只有保證條件為真時，才能保證代碼可以繼續運行

運算符

//2.溢出運算符:在運算符的前面加上&符號 &＋，&－， &＊
var c = UInt8.min
c = c &- 1
print(c)

//swift可以對浮點數求余，而在oc中是不可以的
var rem = 10 / 2.3
print(rem)

//空合并運算符（a ?? b 對a的條件進行判斷，a不為nil執行a的語句，否則執行b的語句）
/*
 表達式a必須是可選類型
 默認值b的類型必須要和a存儲值的類型保持一致
 */
let words = "hello"
var say: String?
var content = say ?? words
print(content)

//閉區間運算符a...b 半開區間運算符a..<b , 注意中間沒有空格
for i in 1...5 {
    print(i)
}

字符串

//字符串
var str1 = "swift"
var str2 = String()//初始化字符串的實例
var str3 = str1 + "學習"http://字符串的拼接可以使用+號
print(str3)
str1 += "你好"http://+=將字符串拼接到自身
print(str1)

let char : Character = "!"
str1.append(char)
print(str1)//append拼接字符
print("str3 has \(str3) chars")

let quotation = "same"
let samequ = "same"
if quotation == samequ {//判斷字符串是否相同
    print("same")
}

var food = ["fruits:apple",
            "fruits:orange",
            "fruits:banana",
            "vegetable:tomato",
            "vegetable:potato"]
for fru in food {
    if fru.hasPrefix("fruits"){//hasPrefix查找特定的前綴
      print(fru)
    }
    if fru.hasSuffix("apple"){//hasSuffix判斷是否擁有特定的后綴
        print(fru)
    }
}

數組

//數組的聲明可以是顯性聲明，也可以推斷出數組的類型。數據放在數組之前，它的類型必須明確。
food.append("vegetable:aaaa")//通過append添加新的數據項
food[0...2] = ["ss", "nn"]//可以通過下標值替換數組中的元素。若替換的下標有3個，而右邊只有2個值，則swift會自動賦值為nil
print(food)

food.insert("meat", at: 0)//通過insert插入元素
food.remove(at: 0)//通過remove方法可以移除數組中的元素
food.removeLast()//移除最后一項的元素

//使用構造語法來創建一個由特定類型構成的空數組
var someint = [Int]()
print("someints is of type [int] with\(someint.count)items")

//可以創建特定大小并且所有數據都被默認的構造方法 如：浮點型，3個
var threedouble = [Double](repeating: 0.0, count: 3)

字典

//字典
/*
 swift的字典使用時需要具體規定可以存儲的鍵和值的類型，必須提前定義清楚，方法是通過顯性類型標注或者是類型推斷
 */
var person = ["age": 18,
                "name": "jack"] as [String : Any]

/*updateValue方法會在鍵不存在的時候設置值或者在鍵存在的情況下更新值。這個方法會返回更新值的原值，
 這樣方便我們檢查更新是否成功
*/
if let oldname = person.updateValue("tom", forKey: "name") {
    print("原來的值：\(oldname)")
}

/*
 2.removeValue方法也可以用來在字典中移除鍵值對
 3.每一個字典中的數據項都有（key, value）元組的形式返回，并且我們可以使用臨時常量或者變量分解這些元組
 */
for (key, value) in person{
    print(key,value)//字典元素是無序的，遍歷的時候不能保證順序
}

var dic = Dictionary<Int , String>()//聲明空字典
dic[16] = "年齡"http://為鍵為16，賦值為年齡
print(dic)


dic = [:]//聲明空字典的方式二

控制流

//控制流
let base = 3
let power = 10
var answer = 1
for _ in 1...power {//下劃線符號_(替代循環中的變量)能夠忽略具體的值，并且提供循環遍歷時對值的訪問
    answer *= base
}
print(answer)

//在switch中case中可以省略break
let count = 3_000_000_000
let countedthings = "stars in the milky way"
var naturalcount : String
switch count {
case 0:
    naturalcount = "no"
case 1...3:
    naturalcount = "a few"
case 4...9:
    naturalcount = "several"
case 10...99:
    naturalcount = "tens of"
case 100...999:
    naturalcount = "hundreds of"
case 1000...9999:
    naturalcount = "thounds of"
default:
    naturalcount = "millions and millions of"
}

函數

//函數
//函數的聲明格式：帶一個參數，有返回值的函數
func sayhello(personname: String) -> String{
    return "hello" + personname + "!"
}

//調用函數
print(sayhello(personname: "anna"))

//帶有2個參數有返回值的函數，中間用逗號分開
func lengthnumber(start: Int, end: Int) -> Int{
    return end - start
}
print(lengthnumber(start: 1, end: 10))

/*
 局部參數名 例如personname，只能在函數體內使用，外部參數名寫在局部參數名之前，用
 空格進行分割。
 */
func join(s1: String, toString s2: String, withjoiner joiner: String) -> String {
    return s1 + s2 + joiner
}
print(join(s1: "hello", toString: "swift", withjoiner: "!"))

/*
 joiner的值沒有被指定，函數會使用默認值（""），當未給帶默認值的參數提供外部
 參數名時，swift會自動提供外部名字。此時，外部參數名字和局部參數名字是一樣的
 */


/*
 沒有指定返回類型的函數返回void。 在swift中，void和空的元祖是一樣的
 */

func addtwoints(a: Int, b: Int) -> Int{
    return a + b
}

func multiplytwoints(a: Int, b: Int) -> Int{
    return a*b
}

/*
 定義一個叫做mathfunction的變量，類型是‘一個有2個int 類型的參數，并返回一個int類型值的函數’
 */
var mathfunction: (Int,Int) -> Int = addtwoints
print("results:\(mathfunction(2, 3))")


/*
 函數也可以當作參數
 */
func printmathresult(mathfunction: (Int, Int) -> Int, a: Int, b: Int){
    print(mathfunction(a, b))
}
print(printmathresult(mathfunction: addtwoints, a: 3, b: 5))

類

//類
//用class關鍵字進行標記
class person {
    //定義參數
    var name = "tina"
    var age = 19
    
    //定義函數
    func produce(){
        age += 1
    }
}

補充：結構體和枚舉中也可以定義方法