Swift--结构体struct、类class、泛型、数组切片

参考：类的的继承与类的访问权限
参考：swift中的泛型
参考：数组安全索引与数组切片

在Struct中的函数，默认（不添加mutating关键字）的函数对Struct中属性只有只读权限。如果你添加上mutating, 那么该函数就对属性持有读写的权限。

结构体

• 结构体类型的定义

//结构体类型的定义
struct MyPoint {
    var x:Float = 0
    var y:Float = 0
    
    mutating func setMyPoint(tempx:Float, tempy:Float) {
        x = tempx
        y = tempy
    }
    func display() {
        print("\(x),\(y)")
    }
}
var testPoint = MyPoint(x: 10, y: 10)
testPoint.display()

class

• class 的创建与使用

class MyPoint {
    var x:Float = 0
    var y:Float = 0
    init(x:Float = 1, y:Float = 1) {
        self.x = x
        self.y = y
    }
    func setMyPoint(tempx:Float, tempy:Float) {
        x = tempx
        y = tempy
    }
    func display() {
        print("\(x),\(y)")
    }
}
var testPoint = MyPoint()
testPoint.x
testPoint.y
var test2 = MyPoint(x: 10, y: 20)
test2.x
test2.y
var test3 = MyPoint(x: 10)
test3.x
test3.y

被final关键字所修饰的类是不能用来继承的

• 访问权限
  • public: 公有访问权限，类或者类的公有属性或者公有方法可以从文件或者模块的任何地方进行访问。那么什么样才能成为一个模块呢？一个App就是一个模块，一个第三方API, 第三等方框架等都是一个完整的模块，这些模块如果要对外留有访问的属性或者方法，就应该使用public的访问权限。
  • private: 私有访问权限，被private修饰的类或者类的属性或方法可以在同一个物理文件中访问。如果超出该物理文件，那么有着private访问权限的属性和方法就不能被访问。
  • internal: 顾名思义，internal是内部的意思，即有着internal访问权限的属性和方法说明在模块内部可以访问，超出模块内部就不可被访问了。在Swift中默认就是internal的访问权限。

泛型

1. 泛型函数

• 单一占位符泛型函数

//泛型 `MyCustomeType`泛型占位符传入的参数是什么类型`MyCustomeType`就是什么类型
//number1,number2要都是相同的数据类型（单一占位符泛型函数）
func swap<MyCustomeType> ( number1:inout MyCustomeType, number2:inout MyCustomeType) {
    let temp = number1
    number1 = number2
    number2 = temp
}

var tmpStr1 = "sssss"
var tmpstr2 = "xxxxx"
swap(&tmpStr1, &tmpstr2)
tmpStr1//xxxxx
tmpstr2//sssss

• 多个占位符的泛型函数

//参数使用的是不同的泛型占位符，所以其类型允许是不同的
func conect<FirstType, SecondType>(number1:FirstType, number2:SecondType) -> String {
    let tmp = "\(number1)" + "\(number2)"
    return tmp
}
let resulet = conect(number1: 10, number2: 10.2)//1010.2
let resulet2 = conect(number1: "aaa", number2: 1000)//aaa1000

2. 泛型类

//泛型类型数组，
class MyTestClass<MyCustomType> {
    var values = [MyCustomType]()
    func display() {
        for (index, item) in values.enumerated() {
            print(item)
        }
    }
}
let myClass = MyTestClass<String>()
myClass.values = ["aaa", "bbb", "ccc"]
myClass.display()//aaa,bbb,ccc

数组切片

• zip()函数

zip()函数接收两个序列，并且返回一个Zip2Sequence类型的数据

var zip1 = [1,2,3,4,5,6]
var zip2 = [9,8,7,6]
let zip12 = zip(zip1, zip2)
//[[1,2,3,4,5,6],[9,8,7,6]]

for (index, item) in zip12 {
    print("zip1:\(index), zip2:\(item)")
}
<!--输出是成对遍历的，如果某个数组中的元素是多余的，那么就会被忽略掉。-->
/*
 zip1:1, zip2:9
 zip1:2, zip2:8
 zip1:3, zip2:7
 zip1:4, zip2:6
 */

• 数组切片

数组切片的下标与原始数组中的下标保持一致。如果要取出切片arraySlices中的第一个值，我们要使用arraySlices[3], 而不是arraySlices[0]

var arrtest = "0123456789".characters.map({String($0)})
arrtest//["0","1","2","3","4","5","6","7","8","9"]
var arrSlices = arrtest[3...6] //["3","4","5","6"]
arrSlices[3]//"3"
//切片是原始数组的部分拷贝，所以修改切片或者修改原数组，两者互不影响，

//如果把切片转换成枚举，那么切片中与原始数组对应的下标关系将不存在
let enumerate = arrSlices.enumerated()
dump(enumerate)

for a in enumerate {
    print("a = \(a), a.0=\(a.0), a.1 = \(a.1)")
}
/*
 a = (offset: 0, element: "3"), a.0=0, a.1 = 3
 a = (offset: 1, element: "4"), a.0=1, a.1 = 4
 a = (offset: 2, element: "5"), a.0=2, a.1 = 5
 a = (offset: 3, element: "6"), a.0=3, a.1 = 6
 */

arrtest.remove(at: 1)
String removeAtIndex(): 移除指定索引的元素，并且返回被移除的元素。
String removeFrist(): 移除第一个元素，并返回被移除的元素。
Void removeFirst(n: Int): 这个函数的意思是移除数组前方的几个元素，如果n = 1, 的话就移除前面一个元素这时与String removeFirst()函数功能相同。如果n = 3, 就移除前3个元素。
�String removeLast(): 移除数组中最后一个元素。

运算符

• ??

/*
  在??运算符中能确保使用的可选类型变量中有值，如果没有值就不打开使用，可以把!省略掉。
 */
var developLanguage:String?
var selectLanguage:String

selectLanguage = developLanguage ?? "swift"//"swift"
developLanguage = "Object-C"
selectLanguage = developLanguage ?? "swift"//"Object-C"

...闭区间，..>半开区间