本文系統整理 Swift 3 的常用語法,涵蓋常量與變量、數據類型、邏輯分支、循環、字符串、數組、字典、元組、可選類型、函數、類與運算符重載等核心知識點,適合作為開發速查手冊。
Swift 規定:定義標識符時必須明確它是常量還是變量。用 let 定義常量(不可修改),用 var 定義變量(可修改)。
// let 常量 let age : Int = 24 // var 變量 var name = "qiuxuewei" var PI:Double = 3.1415
注意:常量是指指向的對象不可再被修改,但仍可透過指針修改對象內部的屬性。實務中建議先用常量,需要修改時再改為變量,更安全。
// 用 let 定義常量,仍可修改對象內部屬性,推薦使用
let view = UIView(frame: CGRect(x: 16, y: 64, width: 100, height: 100))
view.backgroundColor = UIColor.red
let btn = UIButton(type: UIButtonType.custom)
btn.frame = CGRect(x: 8, y: 8, width: 64, height: 64)
btn.setTitle("確定", for: UIControlState.normal)
btn.backgroundColor = UIColor.green
view.addSubview(btn)
Swift 的數據類型包括整型、浮點型、對象類型、結構體類型等。
Int(與平台相關,默認,相當於 OC 的 NSInteger)、Int8、Int16、Int32、Int64。
UInt(與平台相關,相當於 OC 的 NSUInteger)、UInt8、UInt16、UInt32、UInt64。
Float(32 位浮點)、Double(64 位浮點,默認)。
// 定義 Int 類型變量 m,賦值 10 var m : Int = 10 // 定義 Double 類型常量 n,賦值 3.14 let n : Double = 3.14
Swift 是強類型語言,任何標識符都有明確類型。若定義為整型,就不可再賦值浮點型:
// 定義變量時未指定類型,但因賦值 20(整型),i 為整型 var i = 20 // 錯誤寫法:之後賦值浮點型會報錯 // i = 30.5 // 正確寫法 var j = 3.33 j = 6.66
進行基本運算時必須保證類型一致,不同類型需先轉為相同類型:
let a = 20 let b = 13.14 let c = Double(a) + b print(c)
分支即 if/switch/三目運算符等判斷語句,用於控制程式執行流程。
Swift 的判斷必須有明確的真假值,不再「非 0 即真」,必須是 Bool 值(false/true)。
// 判斷句必須有真假值
var d:Int = 2;
if d != 0 {
}else{
}
var score = 99
if score < 60 {
print("不及格")
}else if score < 80{
print("及格")
}else if score < 100{
print("優秀")
}else{
print("畢業")
}
// 可選類型,只有聲明成可選類型後才能判斷是否為空
let ifView :UIView? = UIView();
if ifView != nil{
print("有")
}else{
print("沒有")
}
格式與 OC 保持一致:
// 三目運算符 a == score ? a : score
guard 是 Swift 2.0 新增的語法,與 if 類似,目的是提高程式可讀性。它必須帶有 else 語句:條件為 true 時跳過 else,執行語句組;條件為 false 時執行 else,轉跳語句一般是 return、break、continue 和 throw。
guard 條件表達式 else {
// 轉跳語句
break
}
語句組
var Age = 18
func online(age:Int) -> Void{
guard age >= 18 else {
print("回家去")
return
}
print("可以上網")
}
online(age: Age)
let sex = 0
// 普通用法,case 後可不跟 break(默認會有 break)
switch sex{
case 0: print("男")
case 1: print("女")
default: print("未知")
}
// 判斷多個值
switch sex{
case 0,1: print("正常人")
default: break
}
// case 穿透需加 fallthrough
let Sex = 0
switch Sex {
case 0: fallthrough
case 1: print("正常人")
default: print("其他")
}
// 浮點型 switch 判斷
let f = 3.14
switch f {
case 3.14: print("π")
default: print("not π")
}
// 字符串判斷
let sexStr = "人妖"
switch sexStr {
case "男": print("男")
case "女": print("女")
default: print("人妖")
}
// 區間判斷:開區間 0..<10 表示 0~9;閉區間 0...10 表示 0~10
score = 59
switch score{
case 0..<60: print("不及格")
case 60..<80: print("及格")
case 80...100: print("優秀")
default: break
}
Swift 3 之後摒棄了 C 語言的 for(i=0; i<6; i++) 格式:
// 0-4 循環
for i in 0 ..< 5 {
print(i)
}
// 0-5 循環
for i in 0 ... 5 {
print(i)
}
// 2 次循環不需要變量
for _ in 0 ..< 3{
print("Hello world!")
}
判斷必須有正確真假,沒有非 0 即真:
var aa = 0
while aa < 10 {
// Swift 3 後摒棄 a++,改為 a+=1
aa += 1
}
print(aa)
Swift 把 do-while 改為 repeat-while:
var bb = 0
repeat {
print(bb)
bb += 1
} while bb < 10
OC 中字符串是 NSString(寫作 @""),Swift 中是 String(寫作 "")。使用 String 的原因:它是結構體、性能更高,支援直接遍歷,並可與 NSString 無縫轉換。
// 字符串
let str = "I am qiuxuewei"
// 遍歷字符串
for cc in str.characters{
print(cc)
}
// 字符串截取:轉為 NSString 操作
let MyName = (str as NSString).substring(from: 5)
// 字符串與其他類型拼接
let tempHeight : Double = 1.83
let tempHeight1 = "身高 \(tempHeight) cm"
let tempHeight2 = "身高" + "\(tempHeight)" + "cm"
// 字符串格式化,用於保留 n 位小數或格式化時間
let min : Int = 9;
let doc : Int = 8;
let time: String = String(format: "%02d分 : %02d秒", arguments: [min, doc])
數組(Array)是一串有序的、由相同類型元素構成的集合,元素有序且可重複。Swift 數組是泛型集合,分為不可變數組(let 修飾)與可變數組(var 修飾)。
// 不可變數組
let arr1 : [String] = ["邱學偉","王珂惠","媽媽"]
let arr2 = ["邱學偉","王珂惠"]
let arr3 = ["邱學偉","煙台大學","不羈閣","瘋火科技"]
// 可變數組
var arrM1 = arr3;
var arrM2 : [Any] = ["身高", 1.83 ]
// 添加元素
arrM1.append("10000000")
// 刪除元素:刪除最後一個並返回
arrM1.removeLast()
// 移除指定下標元素
arrM1.remove(at: 0)
字典按鍵訪問元素,由鍵集合與值集合構成,鍵不可重複、值可重複,鍵值成對出現。Swift 字典是 Dictionary 泛型集合,分為不可變(let)與可變(var)。
// 不可變字典
let dict1 : Dictionary<String,AnyObject> = ["name":"邱學偉" as AnyObject,"age":24 as AnyObject]
let dict2 : [String : AnyObject] = ["name" : "邱學偉" as AnyObject, "height" : 1.83 as AnyObject]
let dict3 : [String : Any] = ["name" : "邱學偉", "age" : 24]
// 可變字典
var dictM1 : Dictionary<String, AnyObject>
var dictM2 : [String : Any]
var dictM3 = ["name" : "邱學偉", "age" : 24] as [String : Any]
// 操作字典
dictM3["height"] = 1.83 // 增
dictM3.removeValue(forKey: "age") // 刪
dictM3["老婆"] = "王珂惠" // 改
// 遍歷字典
for key in dictM3.keys{ }
for value in dictM3.values { }
for (key,value) in dictM3 { print(key , value) }
// 字典合併
var dictM4 = ["學歷" : "本科","電話" : "110"] as [String : Any]
for (key,value) in dictM3 {
dictM4[key] = value
}
Swift 新增的數據類型,類似數組或字典,可用於定義一組數據,常用作函數返回值。
// 定義元組,常用作函數返回值
let tuple2 = (crazyfire1 : "ZAR", crazyfire2 : "擴散", person : 6)
// 常用定義方法
let tuple1 = ("ZAR","擴散","Wish",6);
let (crazyfire1,crazyfire2,person1,personNumber) = ("ZAR","擴散","Wish",6)
// 用法
tuple2.crazyfire1
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)
OC 中未使用的變量可賦值 0 或 nil;Swift 中 nil 是特殊類型,因強類型無法直接賦值,於是推出可選類型,取值為「有值/空值」。
// 錯誤寫法
// var optionalNameError : String = nil
// 正確定義寫法
var optionalNameRight : String? = nil // 方法1
var optionalName : Optional<String> // 方法2
class person{
var optionalName : Optional<String>
}
// 可選類型拆包,強制解包可能崩潰,需先判斷
optionalName = "xiaoming"
let xxxName = "呵呵哒的" + optionalName!
// 判斷後再解包
var phoneNum : String?
phoneNum = "+86 110"
if phoneNum != nil{
var changePhoneNum = "new" + phoneNum!
}
// 可選綁定,判斷是否有值並拆包
if let tempPhoneNum = phoneNum {
print("解包後有值")
}
// 應用場景
let URLString = "www.qiuxuewei.com"
let URL : NSURL? = NSURL(string: URLString)
if URL != nil{
let request = NSURLRequest(url: URL! as URL)
}
if let tempURL = URL {
let request = NSURLRequest(url: tempURL as URL)
}
即 OC 中的方法,定義格式:func 函數名(參數列表) -> 返回值類型 { 代碼塊 return 返回值 }
// 1. 無參數,無返回值(" -> Void " 可省略)
func run() -> Void{ print("跑跑跑...") }
run()
func run2() { print("省略後,跑跑跑...") }
run2()
// 2. 有參數,無返回值
func callPhone(PHONE : String) -> Void{ print("打電話給 \(PHONE)") }
callPhone(PHONE: "110")
// 3. 無參數,有返回值
func readMsg() -> String{ return "今天早起學習了麼?" }
print(readMsg())
// 4. 有參數,有返回值
func add(number1 : Double, number2 : Double) -> Double{ return number1 + number2 }
print(add(number1: 100, number2: 9.99))
默認參數:未傳入具體參數時可使用默認值。
func makeSport(type : String = "籃球") -> Void{ print("打\(type)") }
makeSport()
makeSport(type:"排球")
可變參數:參數個數可變化,類型必須相同,在參數類型名後加 (...) 即可。
func sum(numbers : Double...) -> Double{
var total : Double = 0.00
for number in numbers {
total += number
}
return total
}
print(sum(numbers: 1,2,3))
引用類型(指針傳遞):默認參數是值傳遞,若想改變外面的變量,需在函數內部將傳遞值設為變量。
// 值傳遞
func swap1( a:Double, b:Double){
var b = b
var a = a
let temp = a
a = b
b = temp
print("交換後: a\(a) ,b\(b)")
}
swap1(a: 1, b: 9)
class Person : NSObject{
// 存儲屬性
var name : NSString?
var age = 0
var height = 0.00
}
class student : Person {
var chineseScore = 0.0
var mathScore = 0.0
// 計算屬性,由其他屬性計算而來
var totalScore : Double{
return chineseScore + mathScore
}
var avgScore : Double{
return ( chineseScore + mathScore ) * 0.5
}
// 類屬性,須通過類名獲取
static var scoreCount : Int = 2;
}
let stu = student();
stu.name = "邱學偉"
stu.age = 18
stu.chineseScore = 119
stu.mathScore = 120
stu.totalScore
stu.avgScore
student.scoreCount
自定義構造函數:
class Animal : NSObject{
var type : String?
var name : String?
init(type : String, name : String) {
self.type = type;
self.name = name;
}
}
let cat = Animal(type: "貓", name: "咪咪")
cat.type
cat.name
字典轉模型的自定義構造函數:
class Dog : NSObject{
var master : String = ""
var age : Int = 0
init(dict : [String : Any]) {
self.master = dict["master"] as! String
self.age = dict["age"] as! Int
}
}
let 哈士奇 = Dog(dict: ["master" : "邱學偉", "age" : 10])
哈士奇.master
哈士奇.age
Swift 支援類的繼承,可在本類構造方法中調用父類構造:
class Dog : Animal{
var master : String = ""
var age : Int = 0
init(dict : [String : Any]) {
super.init(type: "貓科", name: "二哈")
self.master = dict["master"] as! String
self.age = dict["age"] as! Int
}
}
let 哈士奇 = Dog(dict: ["master" : "邱學偉", "age" : 10])
哈士奇.type
哈士奇.name
哈士奇.master
哈士奇.age
這在 Java 中也是熟悉的語法。注意自定義類不可繼承自 NSObject,因為 NSObject 是用 OC 封裝的,帶有大量 OC 語法特性。
class Person: AnyObject {
// 運算符重載:參數類型不同
func sum(num1 : Int,num2 : Int) -> Int {
return num1 + num2
}
func sum(num1 : Double,num2 : Double) -> Double {
return num1 + num2
}
// 參數個數不同
func sum(num1 : Int,num2 : Int,num3 : Int) -> Int {
return num1 + num2 + num3
}
}