swift簡介

Swift 是一種支持多編程范式和編譯式的開源編程語言,蘋果于2014年WWDC（蘋果開發(fā)者大會）發(fā)布，用于開發(fā) iOS，OS X 和 watchOS 應(yīng)用程序。

Swift 結(jié)合了 C 和 Objective-C 的優(yōu)點并且不受 C 兼容性的限制。

Swift 在 Mac OS 和 iOS 平臺可以和 Object-C 使用相同的運行環(huán)境。

官方手冊：
swift官方手冊
swift中文手冊（5.0）

開發(fā)配置：xcode（開發(fā)工具），playground（編程環(huán)境）

xcode項目文件

launchscreen.storyboard：視圖文件（一般是在app剛加載的時候一瞬間的閃現(xiàn)視圖）

viewcontroller.swift：代碼文件

info.plist：系統(tǒng)設(shè)置文件

main.stotyboard：視圖文件

語法

變量與常量

注釋：

// 單行注釋

/*
多行注釋
*/

變量定義

var age = 18

常量定義

let age = 19

常見數(shù)據(jù)類型

類型安全

值推斷

// 自動推斷為整形
let age = 13
var age = 19

類型聲明

let age:Int = 13
var high:Double = 1.2
var name:String = "swift"
var t:Bool = false

強制類型轉(zhuǎn)換

var m:Double = 1.5
var n:Int = (Int)m + 1

運算符

和：&&
非：！
或：||

控制結(jié)構(gòu)

if語句

var p = 1
if p > 1 {
	print(1)
}
else if p < 1 {
	print(0)
}
else {
	print(2)
}

switch語句

var p = 1
switch p {
	case 0:
		print(0)
	case 1:
		print(1)
	case 2:
		print(2)
	default:
		print(false)
}

其他寫法

var m = "o"
switch m {
	case "a", "e", "i", "u", "e":
		print(true)
	default:
		print(false)
}

var n = 34
switch n {
	case 0...100:	// 包括100
		print(true)
	case 101..< 200:	// 不包括200
		print(false)
	default:
		print("none")
}

var p = 12
switch p {
	case Int.min...13:
		print(true)
	default:
		print(false)
}

循環(huán)結(jié)構(gòu)

for in

var arr:[Int] = [1, 2, 3]
for f in arr {
	print(f)
}

while

var i = 0
while i < 10 {
	print(i)
	i += 1	
}

數(shù)組

創(chuàng)建一個數(shù)組

// 1
var arr = [Int]()
// 2
var arr:[Int] = [1, 3, 4]
// 3
var arr = [Int](repeating: 10, count: 2)

修改數(shù)組

// 添加元素
var arr = [Int]()
arr.append(2)
arr.append(3)
arr += [4]
// 合并數(shù)組
var ar1 = [Int](repeating: 1, count: 3)
var ar2 = [Int](repeating: 2, count: 10)
var ar3 = ar1 + ar2

字典

創(chuàng)建字典

// 1
var someDict = [Int: String]()
// 2
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

修改字典

// 添加或更新元素
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("One 新的值", forKey: 1)

// 移除元素
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
// 1
var removedValue = someDict.removeValue(forKey: 2)
// 2
someDict[2] = nil

遍歷字典

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (key, value) in someDict {
   print("字典 key \(key) -  字典 value \(value)")
}

字典轉(zhuǎn)換成數(shù)組

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

還有count判斷鍵值對個數(shù)，isEmpty()判斷是否為空

函數(shù)

func funcname(形參) -> returntype
{
   Statement1
   Statement2
   ……
   Statement N
   return parameters
}

函數(shù)調(diào)用

func runoob(site: String) -> String {
    return (site)
}
print(runoob(site: "www.runoob.com"))

返回值類型

// 元組
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("最小值為 \(bounds.min)，最大值為 \(bounds.max)")
}

// 無返回值
func runoob(site: String) {
    print("菜鳥教程官網(wǎng)：\(site)")
}
runoob(site: "http://www.runoob.com")

參數(shù)范圍

// 局部函數(shù)參數(shù)，number 為局部參數(shù)名，只能在函數(shù)體內(nèi)使用
func sample(number: Int) {
    print(number)
}
sample(number: 1)
sample(number: 2)
sample(number: 3)

// 外部函數(shù)參數(shù)名，在局部參數(shù)名前指定外部參數(shù)名，中間以空格分隔，外部參數(shù)名用于在函數(shù)調(diào)用時傳遞給函數(shù)的參數(shù)
func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)

inout傳遞和地址傳遞

一般默認在函數(shù)中定義的參數(shù)都是常量參數(shù)，也就是這個參數(shù)你只可以查詢使用，不能改變它的值。

如果想要聲明一個變量參數(shù)，可以在參數(shù)定義前加 inout 關(guān)鍵字，這樣就可以改變這個參數(shù)的值了

func  getName(_ name: inout String).........

一般默認的參數(shù)傳遞都是傳值調(diào)用的，而不是傳引用。所以傳入的參數(shù)在函數(shù)內(nèi)改變，并不影響原來的那個參數(shù)。傳入的只是這個參數(shù)的副本。

當(dāng)傳入的參數(shù)作為輸入輸出參數(shù)時，需要在參數(shù)名前加 & 符，表示這個值可以被函數(shù)修改

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 現(xiàn)在的值 \(x), y 現(xiàn)在的值 \(y)")

函數(shù)類型

在 Swift 中，使用函數(shù)類型就像使用其他類型一樣。例如，你可以定義一個類型為函數(shù)的常量或變量，并將適當(dāng)?shù)暮瘮?shù)賦值給它

var addition: (Int, Int) -> Int = sum

函數(shù)嵌套

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

結(jié)構(gòu)體和枚舉

在此不做敘述

閉包

類和對象

計算屬性

除存儲屬性外，類、結(jié)構(gòu)體和枚舉可以定義計算屬性，計算屬性不直接存儲值，而是提供一個 getter 來獲取值，一個可選的 setter 來間接設(shè)置其他屬性或變量的值

class sample {
    var no1 = 0.0, no2 = 0.0
    var length = 300.0, breadth = 150.0
    
    var middle: (Double, Double) {
        get{
            return (length / 2, breadth / 2)
        }
        set(axis){
            no1 = axis.0 - (length / 2)
            no2 = axis.1 - (breadth / 2)
        }
    }
}
var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

print(result.no1)
print(result.no2)

如果計算屬性的 setter 沒有定義表示新值的參數(shù)名，則可以使用默認名稱 newValue

只讀計算屬性
只有 getter 沒有 setter 的計算屬性就是只讀計算屬性。

只讀計算屬性總是返回一個值，可以通過點(.)運算符訪問，但不能設(shè)置新的值。

class film {
    var head = ""
    var duration = 0.0
    var metaInfo: [String:String] {
        return [
            "head": self.head,
            "duration":"\(self.duration)"
        ]
    }
}

var movie = film()
movie.head = "Swift 屬性"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

全局變量(static關(guān)鍵字)

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // 這里返回一個 Int 值
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // 這里返回一個 Int 值
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // 這里返回一個 Int 值
   }
}

屬性觀察器

可以為屬性添加如下的一個或全部觀察器：

• willSet在設(shè)置新的值之前調(diào)用
• didSet在新的值被設(shè)置之后立即調(diào)用
• willSet和didSet觀察器在屬性初始化過程中不會被調(diào)用

class Samplepgm {
    var counter: Int = 0{
        willSet(newTotal){
            print("計數(shù)器: \(newTotal)")
        }
        didSet{
            if counter > oldValue {
                print("新增數(shù) \(counter - oldValue)")
            }
        }
    }
}
let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

注意：
不需要為無法重載的計算屬性添加屬性觀察器，因為可以通過 setter 直接監(jiān)控和響應(yīng)值的變化。

構(gòu)造器和析構(gòu)器

// 構(gòu)造器
init() {
	// do something
}
// 析構(gòu)器
deinit() {
	// do something
}

繼承

class a {
	// do something
}
class b: a {
	// do something
}

重寫
子類可以通過繼承來的實例方法，類方法，實例屬性，或下標(biāo)腳本來實現(xiàn)自己的定制功能，我們把這種行為叫重寫（overriding）

通過使用super前綴來訪問超類的方法，屬性或下標(biāo)腳本。

class SuperClass {
    func show() {
        print("這是超類 SuperClass")
    }
}

class SubClass: SuperClass  {
    override func show() {
        print("這是子類 SubClass")
    }
}

let superClass = SuperClass()
superClass.show()

let subClass = SubClass()
subClass.show()

swift協(xié)議

協(xié)議規(guī)定了用來實現(xiàn)某一特定功能所必需的方法和屬性。

任意能夠滿足協(xié)議要求的類型被稱為遵循(conform)這個協(xié)議。

類，結(jié)構(gòu)體或枚舉類型都可以遵循協(xié)議，并提供具體實現(xiàn)來完成協(xié)議定義的方法和功能。

協(xié)議定義

protocol SomeProtocol {
    // 協(xié)議內(nèi)容
}

遵循協(xié)議

struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 結(jié)構(gòu)體內(nèi)容
}
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 類的內(nèi)容
}

對屬性的規(guī)定

protocol classa {
    
    var marks: Int { get set }
    var result: Bool { get }
    
    func attendance() -> String
    func markssecured() -> String
    
}

protocol classb: classa {
    
    var present: Bool { get set }
    var subject: String { get set }
    var stname: String { get set }
    
}

class classc: classb {
    var marks = 96
    let result = true
    var present = false
    var subject = "Swift 協(xié)議"
    var stname = "Protocols"
    
    func attendance() -> String {
        return "The \(stname) has secured 99% attendance"
    }
    
    func markssecured() -> String {
        return "\(stname) has scored \(marks)"
    }
}

let studdet = classc()
studdet.stname = "Swift"
studdet.marks = 98
studdet.markssecured()

print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)

不做過多敘述，詳情可見swift協(xié)議規(guī)范

swift拓展

擴展就是向一個已有的類、結(jié)構(gòu)體或枚舉類型添加新功能。

擴展可以對一個類型添加新的功能，但是不能重寫已有的功能。

Swift 中的擴展可以：

• 添加計算型屬性和計算型靜態(tài)屬性
• 定義實例方法和類型方法
• 提供新的構(gòu)造器
• 定義下標(biāo)
• 定義和使用新的嵌套類型
• 使一個已有類型符合某個協(xié)議

extension SomeType {
    // 加到SomeType的新功能寫到這里
}

詳情可見swift拓展文章來源地址http://www.zghlxwxcb.cn/news/detail-655252.html

到了這里，關(guān)于Swift語言基礎(chǔ)的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！