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拓展
版权归原作者 妖怪喜欢风 所有, 如有侵权,请联系我们删除。