Swift3.0 语法总结

Swift 前端之家
前端之家收集整理的这篇文章主要介绍了Swift3.0 语法总结，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

代码下载

代码下载地址

前言

最近找工作，很多单位都需要掌握Swift这门语言，发现Swift将是大势所趋啊！自己之前也断断续续学习过一阵子，但是学以致用啊，项目开发都是用Objective-C不用就容易忘，这段时间得闲就整理出这篇文章，可以说是自己的学习回顾吧，希望对大家有用！这都是些基本的东西，没有做过多的描述。后面我会更新一些Swift较深入探讨的文章。

数据类型

1.基本数据类型有：整型：Int,浮点型：Float,双精度浮点型：Double,字符型：Character,字符串型：String

定义常量：var x: Float = 42.0
定义变量：let y: Int = 12

注意：Swift可以推断出数据的类型，所以在变量常量声明的时候可以省略数据类型。

var x = 12
let y = 42.0

2.字符串的声明：

let name : String = "綦帅鹏"
let age : Int = 10
print("My name is " + name + "," + String(age) + " years old!")
print("My name is \(name),\(age) years old!")

注意：
- Swift中字符串可以通过”+”来拼接。
- 在Swift字符串中可以通过”(名称)”来获取常量、变量的值。

3.元组：元组是一系列不同类型数据的有序集合，可以包含不同的数据类型，通过”.下标”来获取对应的数据。

//元组
let student = ("綦帅鹏",27,"打球")
print("学生：\(student.0),\(student.1)岁，喜欢\(student.2)！")

4.数组：数组是一系列相同类型的数据的有序集合，数组中的数据类型必须相同。

//数组，数组中数据的类型必须相同
var studentsName = ["张三","李四","王五"]
//添加数据
studentsName.append("赵六")
print(studentsName)
//添加多个数据，也可以理解为数组合并
studentsName += ["綦帅鹏","綦朝晖"]
print(studentsName)
//添加数据到指定位置
studentsName.insert("廖腾逸",at: 0)
print(studentsName)
//修改数据
studentsName[1] = "廖雨琦"
print(studentsName)
//移除数据
studentsName.remove(at: 2)
print(studentsName)
//移除最后一个数据
studentsName.removeLast()
print(studentsName)
print(studentsName)
//移除所有数据
studentsName.removeAll()
print(studentsName)

5.字典：字典是一系列相同类型的数据的无序集合，数据是由键值对存在的，并且键不能为nil。

//字典：不能将key指定为nil
var product = ["name":"iPhone5","size":"4寸"]
print(product)
//取值
print(product["name"]!)
//添加数据
product["address"] = "香港"
print(product)
//修改数据
product["size"] = "4英寸"
print(product)
//删除数据
product["address"] = nil
print(product)

//字典数组搭配
print([[1, 2, 3],["1","2","3"]])
print([["name": "张三","address": "湖南"],["name": "李四","address": "北京"]])
//空数组
var arr: Array<Int> = []
arr.append(1)
print(arr)
var otherArr = [Int]()
otherArr += [2]
print(otherArr)
//空字典
var dic = Dictionary<String,String>()
dic["name"] = "张三"
print(dic)

6.数组与字典的遍历

//数组遍历
for item in [1,2,3] {
    print(item)
}
for (index,item) in [1,3].enumerated() {
    print("\(index): \(item)")
} //遍历字典
for (key,value) in ["name": "张三","address": "湖南"] {
    print("\(key):\(value)")
}

流程控制

1.for循环

let arr = [1,3,4,5,6,7,8,9,10]
for num in arr {
    print(num)
}
for item in 1...10 {
    print(item)
}
for item in 1..<10 {
    print(item)
}
for item in [1,10].reversed() {
    print(item)
}

2.if…else…选择

let lightColor = "red"
if lightColor == "red"
{
    print("Stop!")
}
else
{
    print("Go!")
}

3.while循环和switch…case…选择

let limit = 75
var speed = 0
while speed < 100 {
    speed += 1
    switch speed {
    case 0..<20:
        print("太慢啦！")
    case 20..<40:
        print("快点行吗！")
    case 40..<60:
        print("速度起来啦！")
    case 60...limit:
        print("别超速呀，我的哥！")
    default:
        print("超速啦，我的哥！")
    }
    if speed > limit {
        break
    }
}

注意：在Swift中可以不需要使用break关键字

函数

1.函数的定义：func 函数名(参数1名: 参数类型,参数2名: 参数类型) -> 返回值类型

func add(num: Int,otherNum: Int) -> Int {
    return num + otherNum
}
print(add(num: 10,otherNum: 20))

2.参数个数变化的函数定义：在函数的最后一个参数中用…来添加多个参数

//可变参数，只能在函数的最后一个参数中用...来添加多个参数
func addAllNums(nums: Float...) -> Float {
    var result : Float = 0.0
    for item in nums {
        result += item;
    }

    return result
}
print(addAllNums(nums: 10,20,30,40,50,60,70,80,90,100))

3.带默认参数的函数

//默认参数
func circleArea(r: Double = 10) -> Double{
    return M_PI*r*r
}
print(circleArea())
print(circleArea(r: 100))

4.高阶函数：Swift中函数可以做参数也可以做返回值

//找出最大数
func findMax(nums: Double...) -> Double {
    var result : Double = -Double.infinity//负无穷大
    for item in nums {
        if item > result {
            result = item
        }
    }

    return result
}
print(findMax(nums: 12,3333,32413,324,34124,3432))
//找出最小数
func findMin(nums: Double...) -> Double {
    var result : Double = Double.infinity
    for item in nums {
        if item < result {
            result = item
        }
    }

    return result
}
print(findMin(nums: 12,3432))

//函数返回函数
func findNum(type: String) -> (Double...) -> (Double) {
    if type == "max" || type == "Max" {
        return findMax
    }
    return findMin
}
print(findNum(type: "Max")(1,32,34,23) + findNum(type: "Min")(2,323,233,1,323))

5.函数嵌套：在函数中定义使用函数

//函数嵌套
func randomNum(type:String) -> Int {
    func randomPositive() -> Int {
        return Int(arc4random())
    }
    func randomNegative() -> Int {
        return -(Int)(arc4random())
    }

    if type == "randomPositive" {
        return randomPositive()
    }

    return randomNegative()
}
print(randomNum(type: "randomPositive"))
print(randomNum(type: "randomNegative"))

注意：函数中的参数inout关键字会改变函数体外的变量值，同时在调用该函数的时候，此参数需传地址而不是值。

//变量参数，inout关键字会改变函数体外的变量值
func ascendingSort(num1: inout Int,num2: inout Int,num3: inout Int) -> [Int]
{
    var temp : Int
    if num1 > num2 {
        temp = num1;
        num1 = num2;
        num2 = temp;
    }
    if num2 > num3 {
        temp = num2;
        num2 = num3;
        num3 = temp;
    }

    return [num1,num2,num3]
}
var num1 = 3
var num2 = 2
var num3 = 4
print(ascendingSort(num1: &num1,num2: &num2,num3: &num3))
print([num1,num3])

闭包

1.说明：闭包与函数类似，就是一个代码块分装了其所处环境的所有状态。在闭包之前声明的所有变量常量都会被闭包所捕获，从本质上说闭包保留定义它时的程序状态。函数是有名称的闭包，闭包是无名称的函数。
2.定义一个计算单利的闭包

var simpleClosure = {(amount: Double,interestRate: inout Double,years: Int) -> Double in
    interestRate = interestRate/100
    var interest = Double(years) * interestRate * amount

    return interest + amount
}

3.高阶函数就是使用（闭包或函数）作为参数或返回值

//闭包做函数的参数
func loanCalculator(amount: Double,years: Int,calculator: (Double,inout Double,Int) -> Double) -> Double
{
    return calculator(amount,&interestRate,years)
}
var rate : Double = 3.875
print(loanCalculator(amount: 10000,interestRate: &rate,years: 5,calculator: simpleClosure))

类

Swift中的类基本上就类的变量、常量、函数、继承等内容，十分简单方便。

枚举

枚举的定义方式如下，可以给枚举类型的数据设置值也可以不设置值

/// 颜色类型枚举
enum ColorType {
    case RGB
    case CMYK
    case HSB
}
let type: ColorType = .RGB
print(type)

/// 学科枚举
enum Subject: String {
    case Chinese = "语文"
    case Math = "数学"
    case English = "英语"
}
let subjece: Subject = .Chinese
print(subjece)

结构体

Swift中的结构体和C语言类似，同时Swift的结构体还包括方法，这使得与类十分相似。不过结构体是不能继承的，并且结构体是值类型的数据结构，而类是引用类型的数据结构。
- 值类型：每次赋值都将创建副本，并把副本赋值给新的变量或常量，变量或常量存储的是副本。
- 引用类型：说白了，引用类型就是指针，不管赋值给多少变量或者常量，他们都指向同一个对象，变量和常量存储的都是指向这个对象的引用，而不是副本。

struct Color {
    var R: Double = 0.0
    var G: Double = 0.0
    var B: Double = 0.0
    var Alpha: Double = 0.0

    func stringValue() -> String {
        let limit: Double = 255.0
        let rInt: Int = Int(self.R*limit)
        let gInt: Int = Int(self.G*limit)
        let bInt: Int = Int(self.B*limit)
        let alphaInt: Int = Int(self.Alpha*limit)

        let result: String = String.init(format: "%02X%02X%02X%02X",rInt,gInt,bInt,alphaInt)
        return result
    }
}
let red: Color = Color(R: 1.0,G: 0.0,B: 0.0,Alpha: 1)
print(red)
print(red.stringValue())

协议

指定了类和结构需要实现的方法和变量，optional关键字可以定义协议中选择实现的方法和变量，一个结构体或者类可以实现多个协议，值得注意的是协议之间是可以继承的。

//多协议
protocol AreaComputetionProtocol {
    func computeArea() -> Double
}
protocol PerimeterComputetionProtocol {
    func computePerimeter() -> Double
}
struct RectAngle: AreaComputetionProtocol,PerimeterComputetionProtocol {
    var width,height: Double

    internal func computeArea() -> Double {
        return width*height
    }

    internal func computePerimeter() -> Double {
        return 2*(width + height)
    }
}
let rect: RectAngle = RectAngle(width: 3.0,height: 4.0)
print(rect.computeArea())
print(rect.computePerimeter())

//协议继承
protocol TriangeleProtocol: AreaComputetionProtocol,PerimeterComputetionProtocol {
    var a: Double {get set}
    var b: Double {get set}
    var c: Double {get set}
    var base: Double {get set}
    var height: Double {get set}
}
struct Triangle: TriangeleProtocol {
    var a: Double = 0.0
    var b: Double = 0.0
    var c: Double = 0.0
    var base: Double = 0.0
    var height: Double = 0.0
    func computeArea() -> Double {
        return base*height/2.0
    }
    func computePerimeter() -> Double {
        return a + b + c
    }
}
let triangle: Triangle = Triangle(a: 3,b: 4,c: 5,base: 3,height: 4)
print(triangle.computeArea())
print(triangle.computePerimeter())

说到协议就不得不说委托，委托是为了让一个类或结构体能够将工作和决策交给另一个类或结构去完成。

//委托：让一个类或结构能够将工作和决策交给另一个类或结构去完成
/// 售货机协议
protocol VendingMathineProtocol {
    /// 是否投币
    var coinInserted: Bool {get set}

    /// 能否售货
    func shouldVend() -> Bool
}

/// 自动售货机类，遵守售货机协议
class Vendor: VendingMathineProtocol {
    var coinInserted: Bool = false

    /// 如果投币则售货否则不售货
    ///
    /// - Returns: 是否售货
    func shouldVend() -> Bool {
        if coinInserted {
            coinInserted = false
            return true
        }
        else
        {
            return false
        }
    }
}

/// 可乐机类
class ColaMethine {
    // 自动售货机类，遵守售货机协议
    var vendor: VendingMathineProtocol
    init(vendor: VendingMathineProtocol) {
        self.vendor = vendor
    }

    /// 投币
    func insertCoin() {
        vendor.coinInserted = true
    }

    /// 销售可乐按钮事件
    func pressColaButton() -> String {
        if vendor.shouldVend() {
            return "Here's a cola!"
        }
        else
        {
            return "You must insert coin!"
        }
    }
    /// 销售啤酒按钮事件
    func pressRootBeerButton() -> String {
        if vendor.shouldVend() {
            return "Here's a Root Beer!"
        }
        else
        {
            return "You must insert coin!"
        }
    }
}
let methine: ColaMethine = ColaMethine.init(vendor: Vendor.init())
print(methine.pressColaButton())
methine.insertCoin()
print(methine.pressColaButton())
methine.insertCoin()
print(methine.pressRootBeerButton())
print(methine.pressColaButton())

扩展

不继承而扩展类的功能，扩展能够以非侵入式的方式，增加类、结构、甚至基本类型的行为和功能，类似于Objective_C的类别，但是强大得多。基本使用如下：

// MARK: - 可乐机的扩展
extension ColaMethine {
    /// 健怡可乐按钮事件
    func pressDietColaButton() -> String {
        if vendor.shouldVend() {
            return "Here's a Diet Cola!"
        }
        else
        {
            return "You must insert coin!"
        }
    }
}
methine.insertCoin()
print(methine.pressDietColaButton())

1.扩展基本数据类型：不能在扩展中添加常规存储属性，但可以添加计算属性：值是通过计算获得的属性

let limit: Double = 1024.0
// MARK: - 为Int64扩展属性，获取存储单位的换算结果
extension Int64 {
    var K: String {return String.init(format: "%fK",Double(self)/limit)}
    var M: String {return String.init(format: "%fM",Double(self)/limit/limit)}
    var G: String {return String.init(format: "%fG",Double(self)/limit/limit/limit)}
    var T: String {return String.init(format: "%fT",Double(self)/limit/limit/limit/limit)}
}
let bytes: Int64 = 2345346457
print(bytes.K)
print(bytes.M)
print(bytes.G)
print(bytes.T)

2.mutating关键字：如果要修改自身的值而不是返回计算的结果，那么就得使用mutating关键字

// MARK: - 为Double数据类型扩展方法
extension Double {
    /// 平方值
    mutating func squra() {
        self = self*self
    }

    /// 立方值
    mutating func cube() {
        self = self*self*self
    }
}
var num: Double = 1.5
num.squra()
print(num)
num.cube()
print(num)

Swift内存管理

Swift以ARC方式为引用类型数据管理内存，这种方式是由编译器提供支持的。每一个引用类型的数据都有一个引用计数的的属性，当这个对象被创建的时候它的引用计数就为1，当这个对象在应用程序运行过程中被传递，就可能被多个“所有者”持有并使用。当“所有者”获得所有权时引用计算就相应加1，而在放弃所有权时引用计数就相应减1，直到引用计数为0时（所有的“所有者”都放弃了所有权），对象就会被销毁，它所占用的内存归还给内存池，供其他对象使用。

1.循环引用：循环引用就是指不同对象之间相互持有对方，这样造成了对象永远被“所有者”所占有，而无法释放，从而形成内存泄漏。
- 普通对象之间的循环引用：这种循环引用可以使用weak关键字来打破。

//循环引用
class ClassA {
    var b: ClassB!
    //销毁时调用
    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
class ClassB {
    var a: ClassA!
    //销毁时调用
    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
var aClass: ClassA! = ClassA()
var bClass: ClassB! = ClassB()
aClass.b = bClass
bClass.a = aClass

//使用"weak"可以解决对象之间相互引用而造成的循环引用
class ClassC {
    var d: ClassD!
    //销毁时调用
    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
class ClassD {
    weak var c: ClassC!
    //销毁时调用
    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
var cClass: ClassC! = ClassC()
var dClass: ClassD! = ClassD()
cClass.d = dClass
dClass.c = cClass
cClass = nil
dClass = nil
    @H_478_1403@闭包内的循环引用：闭包是引用类型的数据，类的实例变量强引用了闭包，而如果闭包中再引用了类对象的话，就会造成循环引用。在闭包定义中添加”[unowned self] in”可以解决闭包内的循环引用。@H_155_1404@ 
class Student {
    var name: String = ""
    var age: Int = 0
    lazy var info: () -> Void = {
        print("name:\(self.name),age:\(self.age)")
    }

    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
var student: Student! = Student()
student.name = "张三"
student.age = 10
student.info()
student = nil
class People {
    var name: String = ""
    var age: Int = 0
    lazy var info: () -> Void = { [unowned self] in
        print("name:\(self.name),age:\(self.age)")
    }

    deinit {
        print("\(type(of: self)) 销毁了！")
    }
}
var people: People! = People()
people.name = "张三"
people.age = 10
people.info()
people = nil

说明：一个对象在销毁的时候会调用deinit，而一个变量赋值为nil时就会放弃对原有对象的持有。

泛型

不指定数据的类型，只是指定一个占位符。编译器负责对数据类型进行检查。使用方式如下：

func valueEqual<T: Equatable>(value1: T,value2: T) -> Bool {
    return value1 == value2
}

运算符重载：只需定义一个运算符命名的函数就可以对运算符进行重载。

/// 二维矩阵结构体
struct TwoDimensionalMatrix {
    var a11: Double,a12: Double
    var a21: Double,a22: Double
}
/// 重载+运算符，实现二维矩阵的相加
func +(matrix: TwoDimensionalMatrix,otherMatrix: TwoDimensionalMatrix) -> TwoDimensionalMatrix {
    return TwoDimensionalMatrix.init(a11: matrix.a11 + otherMatrix.a11,a12: matrix.a12 + otherMatrix.a12,a21: matrix.a21 + otherMatrix.a21,a22: matrix.a22 + otherMatrix.a22)
}
/// 重载*运算符，实现二维矩阵的相乘
func *(matrix: TwoDimensionalMatrix,otherMatrix: TwoDimensionalMatrix) -> TwoDimensionalMatrix {
    return TwoDimensionalMatrix.init(a11: matrix.a11 * otherMatrix.a11,a12: matrix.a12 * otherMatrix.a12,a21: matrix.a21 * otherMatrix.a21,a22: matrix.a22 * otherMatrix.a22)
}
let matrix: TwoDimensionalMatrix = TwoDimensionalMatrix.init(a11: 1,a12: 2,a21: 3,a22: 4)
let otherMatrix: TwoDimensionalMatrix = TwoDimensionalMatrix.init(a11: 1,a22: 4)
print(matrix + otherMatrix)
print(matrix * otherMatrix)

相等与相同

相等是指值相等，相同是指指向的对象为同一个对象。使用==来判断值的相等，用===来判断是否为同一个对象。

let a: Int = 1
let b: Int = 1
class IntClass {
    var value: Int = 0
    init(value: Int) {
        self.value = value
    }
}
let intA: IntClass = IntClass.init(value: 1)
let intB: IntClass = IntClass.init(value: 1)
print(a == b)
print(a != b)
print(intA === intB)
print(intA !== intB)
原文链接：https://www.f2er.com/swift/321848.html

猜你在找的Swift相关文章

Swift 正式开源，同时开源 Swfit 核心库和包管理器
Swift 正式开源！Swift 团队很高兴宣布 Swift 开始开源新篇章。自从苹果发布 Swfit 编程语...
Swift开源短短一天不到Github就有9000多star
快，快，快！动动您的小手，分享给更多朋友！ 苹果去年推出了全新的编程语言Swift，试图让...
苹果的Swift语言开源了！
开发者（KaiFaX） 面向开发者、程序员的专业平台！ 和今年年初承诺的一样，苹果贴出了Swif...
使用 Swift 构建自定义的ActivityIndicator View
本文由@Chun发表于Chun Tips ：http://chun.tips/blog/2014/12/11/shi-yong-swift-gou-jia...
Swift中编写单例的正确方式
本文由CocoaChina译者leon(社区ID)翻译 原文：THE RIGHT WAY TO WRITE A SINGLETON 在之前...
Swift中编写单例的正确方式
本文由CocoaChina译者leon(社区ID)翻译 原文：THE RIGHT WAY TO WRITE A SINGLETON 在之前...
Swift 的 NSDate 初学者指南
译者：ray16897188；校对：numbbbbb；定稿：Cee 如果问我在做过的所有项目中做的最多的事情...
10 个最佳的 Swift 教程实例
★ 时间就是金钱。你可以一开始就使用正确的 Swift 教程来节省时间。本文中提到的教程都是...
Swift Package Manager快速上手指南（一）：环境搭建
CSDN移动将持续为您优选移动开发的精华内容，共同探讨移动开发的技术热点话题，涵盖移动应...
编写高性能的 Swift 代码
下面这篇文档收集了一系列编写高性能 Swift 代码的要诀和技巧。文档的目标读者是编译器和标...
iOSAndroidSwiftHybridCocos2d-xFlutterXcodeSilverlightcocoaCordova
调试桥筛选栏假异步不会丢失AndPermissio权限申请抽屉式systemUI信号栏多行排列跨多行显示viewmode数据共享录制语音视频通话多行显示Studio3.5拉伸控件望远镜发动态走势图点赞控件显示牌冷启动v3签名v2签名v1签名本地html外接键盘流式标签