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 = 13
var age = 19
类型声明
let age:Int = 13
var high:Double = 1.2
var name:String = "swift"
var t:Bool = false
强制类型转换
var m:Double = 1.5
var n:Int = (Int)m + 1
运算符
和：&&
非：！
或：||
控制结构
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)
}
循环结构
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
}
数组
创建一个数组
// 1
var arr = [Int]()
// 2
var arr:[Int] = [1, 3, 4]
// 3
var 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
字典
创建字典
// 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)")
}
字典转换成数组
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 = 1
var y = 5
swapTwoInts(&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.09
print(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 = 100
NewCounter.counter = 800
注意：
不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。
构造器和析构器
// 构造器
init() {
// do something
}
// 析构器
deinit() {
// do something
}
继承
class a {
// do something
}
class b: a {
// do something
}
重写
子类可以通过继承来的实例方法，类方法，实例属性，或下标脚本来实现自己的定制功能，我们把这种行为叫重写（overriding）
通过使用super前缀来访问超类的方法，属性或下标脚本。
| 重写 | 访问方法，属性，下标脚本 |
|---|---|
| 方法 | super.somemethod() |
| 属性 | super.someProperty() |
| 下标脚本 | super[someIndex] |
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 = 98
studdet.markssecured()
print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)
不做过多叙述，详情可见swift协议规范
swift拓展
扩展就是向一个已有的类、结构体或枚举类型添加新功能。
扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
Swift 中的扩展可以：
- 添加计算型属性和计算型静态属性
- 定义实例方法和类型方法
- 提供新的构造器
- 定义下标
- 定义和使用新的嵌套类型
- 使一个已有类型符合某个协议
extension SomeType {
// 加到SomeType的新功能写到这里
}
详情可见swift拓展