iOS-Swift3常用語法
阿新 • • 發佈：2018-12-25
常量和變數
在Swift中規定:在定義一個識別符號時必須明確說明該識別符號是一個常量還是變數
使用let來定義常量,定義之後不可以修改
使用var來定義變數,定義之後可以修改
//定義標示符表明是變數還是常量!
//let 常量
let age : Int = 24
//var 變數
var name = "qiuxuewei"
var PI:Double = 3.1415注意事項:
常量:是指向的物件不可以再進行修改.但是可以通過指標獲得物件後,修改物件內部的屬性
在真實使用過程中,建議先定義常量,如果需要修改再修改為變數(更加安全)
//定義常量View 和 btn 可以利用指標指向的不可修改的物件,對物件內屬性進行更改,推薦使用let定義常量
let view = UIView(frame: CGRect(x Swift中資料型別
Swift中的資料型別也有:整型/浮點型/物件型別/結構體型別等等
整型
有符號
常用:Int : 和平臺相關(預設,相當於OC的NSInteger)
Int8 : 有符號8位整型
Int16 : 有符號16位整型
Int32 : 有符號32位整型
Int64 : 有符號64位整型
無符號
UInt : 和平臺相關(常用,相當於OC的NSUInteger)(預設)
UInt8 : 無符號8位整型
UInt16 : 無符號16位整型
UInt32 : 無符號32位整型
UInt64 : 無符號64位整型
浮點型
Float : 32位浮點型
Double : 64浮點型(預設)
// 定義一個Int型別的變數m,並且賦值為10
var m : Int = 10 Swift是強型別的語言
Swift中任何一個識別符號都有明確的型別
即如果將一變數定義為整型,就不可對他進行浮點型的賦值
// 定義變數時沒有指定明確的型別,但是因為賦值給i一個20.20為整型.因此i為整型
var i = 20
// 錯誤寫法:如果之後賦值給i一個浮點型數值,則會報錯
// i = 30.5
// 正確寫法
var j = 3.33
j = 6.66Swift中在進行基本運算時必須保證型別一致
//對不同型別的變數/常量進行運算需要將其轉化為相同型別的
let a = 20
let b = 13.14
let c = Double(a) + b
print(c)
邏輯分支
分支即if/switch/三目運算子等判斷語句,通過分支語句可以控制程式的執行流程
if語句
在Swift的判斷句中必須有明確的真假
不再有非0即真
必須有明確的Bool值
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 : scoreguard
guard是Swift2.0新增的語法
它與if語句非常類似，它設計的目的是提高程式的可讀性
guard語句必須帶有else語句，它的語法如下：
當條件表示式為true時候跳過else語句中的內容，執行語句組內容
條件表示式為false時候執行else語句中的內容，跳轉語句一般是return、break、continue和throw
guard 條件表示式 else {
// 條換語句
break
}
語句組//guard
var Age = 18
func online(age:Int) -> Void{
guard age >= 18 else {
print("回家去")
return
}
print("可以上網")
}
online(age: Age)switch
//switch 用法
//sex:0 -> 男 sex:1 -> 女
let sex = 0
//普通用法 - case後可以不跟break(預設會有break)
switch sex{
case 0:
print("男")
case 1:
print("女")
default:
print("未知")
}
//可判斷多個值
switch sex{
case 0,1:
print("正常人")
//如果case穿透需要加此關鍵字
// fallthrough
default: break
// print("不正常")
}
//如果希望出現之前的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("人妖")
}
//區間判斷
//swift中的區間常見有兩種
//開區間:0..<10 表示:0~9,不包括10
//閉區間:0...10 表示:0~10
score = 59
switch score{
case 0..<60:
print("不及格")
case 60..<80:
print("及格")
case 80...100:
print("優秀")
default: break
}
迴圈
for迴圈
在swift3以後摒棄了C語言常用的 var i = 0; i < 6; i++ 格式
//for 迴圈
//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!")
}
while迴圈
while的判斷句必須有正確的真假,沒有非0即真
var aa = 0
while aa < 10 {
//在swift3以後摒棄了 a++ 操作 改為 a+=1
aa += 1
}
print(aa)
repeat while迴圈
swift中將 do-while 改為 repeat-while
var bb = 0
repeat {
print(bb)
bb += 1
} while bb < 10
字串
OC和Swift中字串的區別
在OC中字串型別時NSString,在Swift中字串型別是String
OC中字串@”“,Swift中字串””
使用 String 的原因
String 是一個結構體，效能更高
NSString 是一個 OC 物件，效能略差
String 支援直接遍歷
Swift 提供了 String 和 NSString 之間的無縫轉換
//字串
let str = "I am qiuxuewei"
//遍歷字串
for cc in str.characters{
print(cc)
}
//字串擷取 將String轉化為NSSring 操作 (xxx as 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: <#T##String#>, arguments: <#T##[CVarArg]#>)
let time: String = String(format: "%02d分 : %02d秒", arguments: [min, doc])
陣列
陣列（Array）是一串有序的由相同型別元素構成的集合
陣列中的集合元素是有序的，可以重複出現
Swift中的陣列
swift字典型別是Array，是一個泛型集合
陣列分成:可變陣列和不可變陣列
使用let修飾的陣列是不可變陣列
使用var修飾的陣列是可變陣列
//陣列
//b不可變陣列
let arr1 : [String] = ["邱學偉","王珂惠","媽媽"]
let arr2 = ["邱學偉","王珂惠"]
let arr3 = ["邱學偉","煙臺大學","不羈閣","瘋火科技"]
//可變陣列
var arrM1 = arr3;
var arrM2 : [Any] = ["身高",1.83 ]
//新增元素
arrM1.append("10000000")
//刪除元素
//刪除最後一個元素並且會把最後一個元素返回
arrM1.removeLast()
//移除指定下標元素
arrM1.remove(at: 0)
/遍歷陣列
//通過下標遍歷
for i in 0..<arrM1.count{
// print(arrM1[i])
}
//直接遍歷元素值
for item in arrM1{
// print(item)
}
//區間遍歷
arrM1.append("老婆")
for item in arrM1[0..<2]{
// print(item)
}
//數組合並 必須相同型別陣列
let arr01 = ["小碼哥","黑馬",7000] as [Any]
let arr02 = ["邱學偉","努力"] as [Any]
let arr03 = arr01 + arr02
字典
字典允許按照某個鍵來訪問元素
字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合
鍵集合是不能有重複元素的，而值集合是可以重複的，鍵和值是成對出現的
Swift中的字典
Swift字典型別是Dictionary，也是一個泛型集合
Swift中的可變和不可變字典
使用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["老婆"] = "王珂惠"
//遍歷字典
//key
for key in dictM3.keys{
// print(key)
}
//value
for value in dictM3.values {
// print(value)
}
//key和value
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(基本屬性型別)或者賦值為空(物件型別)
在swift開發中,nil也是一個特殊的型別.因為和真實的型別不匹配是不能賦值的(swift是強語言)
但是開發中賦值nil,在所難免.因此推出了可選型別
可選取值: 有值/空值
//可選型別
//錯誤寫法!//var optionalNameError : String = nil
//正確定義寫法
//定義方法1:
var optionalNameRight : String? = nil
//定義方法2:
var optionalName : Optional<String>
class person{
var optionalName : Optional<String>
}
//可選型別拆包
optionalName = "xiaoming"
//一般在拆包時需要對可選型別進行判斷,是否為空
//此種寫法容易產出崩潰點
let xxxName = "呵呵噠的" + optionalName!
//定義
var phoneNum : String?
phoneNum = "+86 110"
//swift中如果進行強制解包操作會崩潰,所以在解包的時候需要進行判斷
if phoneNum != nil{
var changePhoneNum = "new" + phoneNum!
}
//可選繫結,判斷phoneNum是否有值,1如果沒有值直接跳過,2如果有值拆包後將值賦值給tempPhoneNum
if let tempPhoneNum = phoneNum {
print("解包後有值")
}
//可選型別應用場景
let URLString = "www.qiuxuewei.com"
let URL : NSURL? = NSURL(string: URLString)
//建立NSRequest物件
//需要先判斷可選型別資料是否有值
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.沒有引數,沒有返回值
func run() -> Void{
print("跑跑跑...")
}
run()
//其中如果函式木有返回值, " -> Void "可以省略!
func run2() {
print("省略後,跑跑跑...")
}
run2()
//2.有引數,沒有返回值
func callPhone(PHONE : String) -> Void{
print("打電話給 \(PHONE)")
}
callPhone(PHONE: "110")
func callPhone2(PHONE : String){
print("打電話給 \(PHONE)")
}
callPhone2(PHONE: "119")
//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:"排球")
可變引數
swift中函式的引數個數可以變化，它可以接受不確定數量的輸入型別引數
它們必須具有相同的型別
我們可以通過在引數型別名後面加入（…）的方式來指示這是可變引數
//可變引數
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{
//儲存屬性
//1>如果型別是結構體或類,定義為可選型別
//2>如果是基本資料型別,定義時直接初始化0 / 0.0
var name : NSString?
var age = 0
var height = 0.00
}
class student : Person {
//儲存屬性
var chineseScore = 0.0
var mathScore = 0.0
//計算屬性,由其他屬性值計算而來
var totalScore : Double{
//可省略get
// get{
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
哈士奇.ageswift支援類的繼承,此寫法是繼承自其他類本類的構造方法
//字典轉模型 構造方法
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
}
}