Swift语言基础

swift基础

• swift简介
• xcode项目文件
• 语法
• • 变量与常量
  • • 类型安全
    • 强制类型转换
  • 运算符
  • 控制结构
  • • if语句
    • switch语句
  • 循环结构
  • 数组
  • 字典
  • 函数
  • • inout传递和地址传递
    • 函数类型
    • 函数嵌套
  • 结构体和枚举
  • 闭包
  • 类和对象
  • • 计算属性
    • 构造器和析构器
    • 继承
  • swift协议
  • swift拓展

Swift 是一种支持多编程范式和编译式的开源编程语言,苹果于2014年WWDC（苹果开发者大会）发布，用于开发 iOS，OS X 和 watchOS 应用程序。

Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。

Swift 在 Mac OS 和 iOS 平台可以和 Object-C 使用相同的运行环境。

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

开发配置：xcode（开发工具），playground（编程环境）

launchscreen.storyboard：视图文件（一般是在app刚加载的时候一瞬间的闪现视图）

viewcontroller.swift：代码文件

info.plist：系统设置文件

main.stotyboard：视图文件

变量与常量

注释：

// 单行注释

变量定义

var age = 18

常量定义

let age = 19

常见数据类型

类型安全

值推断

// 自动推断为整形let age = 13var age = 19

类型声明

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

强制类型转换

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

运算符

和：&&
非：！
或：||

控制结构

if语句

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

switch语句

var p = 1switch 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 = 34switch n {case 0...100:// 包括100print(true)case 101..< 200:// 不包括200print(false)default:print("none")}var p = 12switch p {case Int.min...13:print(true)default:print(false)}

循环结构

for in

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

while

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

数组

创建一个数组

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

修改数组

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

字典

创建字典

// 1var someDict = [Int: String]()// 2var 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"]// 1var removedValue = someDict.removeValue(forKey: 2)// 2someDict[2] = nil

遍历字典

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]for (key, value) in someDict {   print("字典 key \(key) -  字典 value \(value)")}

字典转换成数组

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]let dictKeys = [Int](someDict.keys)let dictValues = [String](someDict.values)

还有count判断键值对个数，isEmpty()判断是否为空

函数

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

函数调用

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("菜鸟教程官网：\(site)")}runoob(site: "http://www.runoob.com")

参数范围

// 局部函数参数，number 为局部参数名，只能在函数体内使用func sample(number: Int) {    print(number)}sample(number: 1)sample(number: 2)sample(number: 3)// 外部函数参数名，在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数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传递和地址传递

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。

如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了

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

一般默认的参数传递都是传值调用的，而不是传引用。所以传入的参数在函数内改变，并不影响原来的那个参数。传入的只是这个参数的副本。

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改

func swapTwoInts(_ a: inout Int, _ b: inout Int) {    let temporaryA = a    a = b    b = temporaryA}var x = 1var y = 5swapTwoInts(&x, &y)print("x 现在的值 \(x), y 现在的值 \(y)")

函数类型

在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它

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

函数嵌套

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())

结构体和枚举

在此不做叙述

闭包

类和对象

计算属性

除存储属性外，类、结构体和枚举可以定义计算属性，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值

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 没有定义表示新值的参数名，则可以使用默认名称 newValue

只读计算属性
只有 getter 没有 setter 的计算属性就是只读计算属性。

只读计算属性总是返回一个值，可以通过点(.)运算符访问，但不能设置新的值。

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.09print(movie.metaInfo["head"]!)print(movie.metaInfo["duration"]!)

全局变量(static关键字)

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在设置新的值之前调用
• didSet在新的值被设置之后立即调用
• willSet和didSet观察器在属性初始化过程中不会被调用

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

注意：
不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。

构造器和析构器

// 构造器init() {// do something}// 析构器deinit() {// do something}

继承

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

重写
子类可以通过继承来的实例方法，类方法，实例属性，或下标脚本来实现自己的定制功能，我们把这种行为叫重写（overriding）

通过使用super前缀来访问超类的方法，属性或下标脚本。

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协议

协议规定了用来实现某一特定功能所必需的方法和属性。

任意能够满足协议要求的类型被称为遵循(conform)这个协议。

类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。

协议定义

protocol SomeProtocol {    // 协议内容}

遵循协议

struct SomeStructure: FirstProtocol, AnotherProtocol {    // 结构体内容}class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {    // 类的内容}

对属性的规定

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 协议"    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 = 98studdet.markssecured()print(studdet.marks)print(studdet.result)print(studdet.present)print(studdet.subject)print(studdet.stname)

不做过多叙述，详情可见swift协议规范

swift拓展

扩展就是向一个已有的类、结构体或枚举类型添加新功能。

扩展可以对一个类型添加新的功能，但是不能重写已有的功能。

Swift 中的扩展可以：

• 添加计算型属性和计算型静态属性
• 定义实例方法和类型方法
• 提供新的构造器
• 定义下标
• 定义和使用新的嵌套类型
• 使一个已有类型符合某个协议

extension SomeType {    // 加到SomeType的新功能写到这里}

详情可见swift拓展

来源地址：https://blog.csdn.net/qq_48322523/article/details/120176676