Swift语言基础

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（编程环境）

xcode项目文件

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

viewcontroller.swift：代码文件

info.plist：系统设置文件

main.stotyboard：视图文件

语法

变量与常量

注释：

// 单行注释/*
多行注释
*/

变量定义

var age =18

常量定义

let age =19

常见数据类型
类型关键字整形Int浮点型Double布尔型Bool字符串型String

类型安全

值推断

// 自动推断为整形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)}elseif p <1{print(0)}else{print(2)}

switch语句

var p =1switch p {case0:print(0)case1:print(1)case2: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 {case0...100:// 包括100print(true)case101..<200:// 不包括200print(false)default:print("none")}var p =12switch p {caseInt.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)// 2
someDict[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()判断是否为空

函数

funcfuncname(形参)-> returntype
{Statement1Statement2
   ……
   Statement N
   return parameters
}

函数调用

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

返回值类型

// 元组funcminMax(array:[Int])->(min:Int,max:Int)?{if array.isEmpty{returnnil}var currentMin = array[0]var currentMax = array[0]for value in array[1..<array.count]{if value < currentMin {
            currentMin = value
        }elseif value > currentMax {
            currentMax = value
        }}return(currentMin, currentMax)}iflet bounds =minMax(array:[8,-6,2,109,3,71]){print("最小值为 \(bounds.min)，最大值为 \(bounds.max)")}// 无返回值funcrunoob(site:String){print("菜鸟教程官网：\(site)")}runoob(site:"http://www.runoob.com")

参数范围

// 局部函数参数，number 为局部参数名，只能在函数体内使用funcsample(number:Int){print(number)}sample(number:1)sample(number:2)sample(number:3)// 外部函数参数名，在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数funcpow(firstArg a:Int, secondArg b:Int)->Int{var res = a
   for_in1..<b {
      res = res * a
   }print(res)return res
}pow(firstArg:5, secondArg:3)

inout传递和地址传递

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

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

funcgetName(_ name:inoutString).........

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

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

funcswapTwoInts(_ a:inoutInt,_ b:inoutInt){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

函数嵌套

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

结构体和枚举

在此不做叙述

闭包

类和对象

计算属性

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

classsample{var no1 =0.0, no2 =0.0var length =300.0, breadth =150.0var 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 的计算属性就是只读计算属性。

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

classfilm{var head =""var duration =0.0var 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关键字)

structStructname{staticvar storedTypeProperty =" "staticvar computedTypeProperty:Int{// 这里返回一个 Int 值}}enumEnumname{staticvar storedTypeProperty =" "staticvar computedTypeProperty:Int{// 这里返回一个 Int 值}}classClassname{classvar computedTypeProperty:Int{// 这里返回一个 Int 值}}

属性观察器

可以为属性添加如下的一个或全部观察器：

• willSet在设置新的值之前调用
• didSet在新的值被设置之后立即调用
• willSet和didSet观察器在属性初始化过程中不会被调用

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

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

构造器和析构器

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

继承

classa{// do something}classb: a {// do something}

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

通过使用super前缀来访问超类的方法，属性或下标脚本。
重写访问方法，属性，下标脚本方法super.somemethod()属性super.someProperty()下标脚本super[someIndex]

classSuperClass{funcshow(){print("这是超类 SuperClass")}}classSubClass:SuperClass{overridefuncshow(){print("这是子类 SubClass")}}let superClass =SuperClass()
superClass.show()let subClass =SubClass()
subClass.show()

swift协议

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

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

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

协议定义

protocolSomeProtocol{// 协议内容}

遵循协议

structSomeStructure:FirstProtocol,AnotherProtocol{// 结构体内容}classSomeClass:SomeSuperClass,FirstProtocol,AnotherProtocol{// 类的内容}

对属性的规定

protocol classa {var marks:Int{getset}var result:Bool{get}funcattendance()->Stringfuncmarkssecured()->String}protocol classb: classa {var present:Bool{getset}var subject:String{getset}var stname:String{getset}}classclassc: classb {var marks =96let result =truevar present =falsevar subject ="Swift 协议"var stname ="Protocols"funcattendance()->String{return"The \(stname) has secured 99% attendance"}funcmarkssecured()->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协议规范

swift拓展

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

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

Swift 中的扩展可以：

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

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

详情可见swift拓展