15,数组array
//定义
var a = [1,2,3,4]
var b: [string] = ["1","2"]
var c : Array<double> = [1.3,2.3]
var d = Array(repeating: -1,count: 3)//初始值是-1 长度为3
//增
a + [5]//[1,2,3,4,5]
a.append(5)
//删
a.remove(at: 0)
//改
a[0] = 6
//查
a[0]
//插
a.insert(6,at: 3)
//排序
var array = ["A","B","C","D","E","F"]
array.sort(by: {(s1,s2) -> Bool in {
if (s1 > s2) {
return true
}
else {
return false
}
})
//过滤 过滤掉"D"
array.filter( {(item) -> Bool in {
if (item != "D") {
return true
}else{
return false
}
})
//数组的比较
var array1 = [1,2,3]
var array2 = [1,2,3]
if array1 == array2 {
}
//遍历
var array = [1,2,3]
for item in array {
print(item)//每个数组中的元素的值
}
for index in 0..<array.count {
print(array[index])
}
16,集合(无序 不能重复)
var setList = ["1","2","3"]
//长度
setList.count
//插入
setList.insert("4")//["1","2","3","4"]
//删除
setList.remove("1")
//合并
var setNew:Set = ["222","333"]
var set = setList.union(setNew)//重复的会合并
用的不多 自行查阅
17,Dictionary集合
var a: Dictionary<String,String> = ["a": "A"]//定义
var b: [String: String] = ["b": "B"]
基本操作
print(a["a"])//取值
a["a"] = "B"//修改
a["b"] = "b"//增加
a.remove...//删除
//过滤
dic.filter({(key, value) -> Bool in //把key为a的键值对过滤
if (key == "a") {
return false
}
return true
})
//循环遍历
for (key,value) in dic {
//循环出key和value
}
18,函数
//1,函数的定义
func test() {//简单定义
print("123")
}
func test() ->int{//带返回参数(int)的函数
return 3
}
func test(value: String) ->int{//带返回参数(int)和参数(string)的函数
print(value)
return 3
}
func test(value: String...) {//可变参数
//是个数组
for item in value {
print(item)
}
}
//关于 参数名称
func test(firstValue secondValue: string) {
)
//调用
test(firstValue: test)
//解释
firstValue:函数实际参数标签 (解释作用)外部调用名
secondValue: 形式参数名 (函数中拿到这个名来使用) 内部使用名
func test(name: String) {
}
test(name: "123")//只写一个 默认是外部名称 但是内部名称和外部名称相同
func test(_ name: String){
}
test("123") //_符号忽略外部名称 (外部名称和内部名称不能互用 内部名称不能忽略)
//assert断言 停止函数
assert(false,"停止运行")
19,guard else和if let语句
guard let a = a else {
//如果没有值就进入(不满足条件才进入)
}
if let a = a {
//如果有值就进入(满足条件才进入)
}
20,inout关键字 函数类型
//传引用
func test(param: inout int) {
param = param + 10
}
var a = 10
test(param: &a)
解释: 普通函数传入a之后 在函数中对a进行操作 不影响外部a 但是加了input关键字 就可以对外部的a进行操作 执行test之后 外部的a就变成了20
//函数类型由参数和返回值组成
func test(param: int) {
}
var a: ()->void //定义一个没有参数没有返回值的函数类型
var b: (Int, String)-> String //定义一个有参数有返回值的函数
//定义一个匿名函数
var c: ()->void = {()->void in
print("这是一个匿名函数")
}
c() //直接使用
//函数类型作为函数的参数类型
func test(a: ()->void) {
a()
}
var b: ()->void = {()->void in
print("函数当参数传递")
}
test(a: b) //打印 函数当参数传递
//函数类型还可以作为返回值
func play(value: Int) -> Int {
return 1
}
func test(param: Bool) -> (Int) -> Int {
return play
}
//内嵌函数: 在函数内部定义函数 然后进行返回
//匿名函数的几种简写方式
var a: ()-> void= {()-> void in
//实现
}
//没有参数没有返回值的简写
var a: ()-> void= {
//实现
}
21,枚举的定义和初始值
//定义
enum test {
case A //0
case B//1
}
print(test.A)
//设置枚举初始值
enum test: Int {
case A = 1
case B = 2
}
print(test.A.rawValue)
//遍历枚举
enum test: caseIterable {
case A //0
case B//1
}
test.allCases//拿到case数组 然后遍历就行了
22,结构体
//定义一个结构体 (和类的功能相似)
struct Student {
var name = "uknow"
var age = 0
var score = 0.0
var ispass = false
//初始化器
init(name: String,age: Int,score: Double) {
self.name = name
self. age = age
self. score = score
if self. score < 60 {
self.ispass = false
}else{
self.ispass = true
}
}
23,属性
struct Person {
var name: String {
set(param) {
}
get() {
return
}
}
//初始化器
init() {
}
}
//getter 方法和setter方法来间接检索和设置其他属性的值
//如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称 newValue。下面是使用了简化 setter 声明的 Rect 结构体代码：
struct AlternativeRect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set {
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}
//只读计算属性 只有getter没有setter的计算属性叫只读属性,但是不能设置新的值
//只读计算属性的声明可以去掉get关键字和花括号 直接return
struct Cuboid {
var width = 0.0, height = 0.0, depth = 0.0
var volume: Double {
return width * height * depth
}
}
//属性观察器
//willset 和didset
class StepCounter {
var totalSteps: Int = 0 {
willSet(newTotalSteps) {
print("将 totalSteps 的值设置为 \(newTotalSteps)")
}
didSet {
if totalSteps > oldValue {
print("增加了 \(totalSteps - oldValue) 步")
}
}
}
}
24,方法
//实例方法:实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。
//定义一个很简单的 Counter 类，Counter 能被用来对一个动作发生的次数进行计数：
class Counter {
var count = 0
func increment() {
count += 1
}
func increment(by amount: Int) {
count += amount
}
func reset() {
count = 0
}
}
//使用
let counter = Counter()
// 初始计数值是0
counter.increment()
// 计数值现在是1
counter.increment(by: 5)
// 计数值现在是6
counter.reset()
// 计数值现在是0
//self属性: 类型的没一个实例都有一个隐含属性叫做self 完全等于该实例本身 可以用self当做当前实例
func increment() {
self.count += 1
}
//类方法
class SomeClass {
class func someTypeMethod() {
// 在这里实现类型方法
}
}
SomeClass.someTypeMethod()
继承
一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类时，继承类叫子类，被继承类叫超类（或父类）。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
在 Swift 中，类可以调用和访问超类的方法、属性和下标，并且可以重写这些方法，属性和下标来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
可以为类中继承来的属性添加属性观察器，这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性还是计算型属性。
子类生成
子类生成指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以进一步完善。你还可以为子类添加新的特性。
重写
子类可以为继承来的实例方法，类方法，实例属性，类属性，或下标提供自己定制的实现。我们把这种行为叫重写。
如果要重写某个特性，你需要在重写定义的前面加上 override 关键字。这么做，就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少 override 关键字的重写都会在编译时被认定为错误。
override 关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
