Swift复习资料【二】

二十、Swift从入门到放弃实例【一】

Swift从入门到放弃实例【一】

二十一、函数

//函数的定义
func FunName(){
    print("FunName 函数执行(无返回值，无参数)")
}
FunName()

func FunName2() -> Void{
    print("FunName 函数执行(无返回值，无参数)")
}
FunName2()
func FunName3() -> Int{
    return 100//(有返回值，无参数)
}
print(FunName3())
func FunName4(name:String) {
    print("name:\(name)" ) //有参数无返回值
}
FunName4(name: "名字")//内外部名称都是为name
func FunName5(name:String) ->String{
    return "名字是:" + name // 有参数、有返回值
}
print(FunName5(name: "Mr.ZJB"))

func FunName6(name:String...){
    print(type(of: name))
    for item in name {
        print(item)
    }
}
FunName6(name: "aa","bb")
//outname 外部调用, inname 内部使用
func FunName7(outname inname:String){
    print(inname)
}
FunName7(outname: "Hello world")
func FunName8(_ inname:String){ //忽略外部名称，内部名称不能忽略
    print(inname)
}
FunName8("FunName8")

二十二、断言

//断言
func assertTest(value:Int){
    if value < 10 {
        assert(false, "停止运行")
    }
    print(value)
}
assertTest(value: 1)

二十三、guard 语句

func text(parms:Int){
    guard parms < 10 else {
        print("进入")
        return
    }
    print("Hello")
}
text(parms: 1)
//等价test
func test2(parms:Int){
    if parms < 10 {
        print("Hello")
    }else{
        print("进入")
    }
}
test2(parms: 1)

可选项绑定

var a:String? = nil
func FunName(parms:String?){
    guard let value = parms else {
        print("parms 没值")
        return
    }
    print(value)
}
FunName(parms: a)

二十四、inout关键字

//inout 关键字
func name(param: inout Int){
    param = param * 2 // 如果没有inout关键字那么 param 就不能 param = param * 2
    print(param)
}
var a:Int = 20
print("传递前\(a)")
//正常函数是值传递，如果加了inout 就是引用传递
name(param: &a)
print("传递后\(a)")

二十五、函数类型

//函数类型
var a:() ->Void//->Void不能忽略
var b:(Int, String) -> String
var c:([Int]) ->(Int,String)
func text() ->Void{
    print("text1")
}
a = text
a()

func text2(params1:String, params2:Int) ->String{
    return params1 + String(params2)
}
var funcname:(String ,Int) ->String = text2
print(funcname("hello", 10))
print("-----------------")

二十六、匿名函数

//匿名函数
var AnonymousFun:() ->Void = {()-> Void in
    print("匿名函数")
}
AnonymousFun()
var AnonymousFun2:(String,Int) ->String = {(str:String,index:Int) ->String in
    print("匿名函数 有返回值，有参数")
    return str + String(index)
}
print(AnonymousFun2("hello",100))
var AnonymousFun3:([Int]) ->String = {(Items:[Int])->String in
    var temp = ""
    for  item in Items {
        temp = temp + String(item)
    }
    return temp
}
print(AnonymousFun3([1,2,3]))

二十七、匿名函数作为函数的参数

//匿名函数作为函数的参数
func text(){
    print("text方法没有参数、没有返回值")
}
func FunName(params:() -> Void){
    params()
}
FunName(params: text)
FunName(params: {() -> Void in
    print("匿名函数作为方法的参数，无返回值，无参数")
})
print("-----------------")
func sum(param:(Int, Int) -> Int) ->Int{
    let value = param(1,2)
    print("value = \(value)")
    return value
}
func add(a:Int,b:Int) ->Int{
    return a + b
}
print("Sum的Value:"+String(sum(param: add)))
sum { (a:Int, b:Int) -> Int in  //a:Int, b:Int 也可以简写a, b
    return a + b
}
var array = [1,23,5,2,5,6]
array.sort { (a, b) -> Bool in  //(Int, Int) -> Bool in 方法是参数
    if a < b  {
        return true
    }else{
        return false
    }
}

print(array)

二十八、函数作为方法的返回值

func play(value:Int) ->Int{
    return value * value
}
func play2(value:Int) ->Int{
    return value + value
}
func text(param:Bool) -> (Int) -> Int{
    return param ? play : play2
}

var fun = text(param: true) //play
print(type(of: fun))
print(fun(3))

二十九、内嵌函数

func text(param:Bool) -> (Int) -> Int{
    func play(value:Int) ->Int{
        return value * value
    }
    func play2(value:Int) ->Int{
        return value + value
    }
    return param ? play : play2
}

var fun = text(param: true) //play
print(type(of: fun))
print(fun(3))

三十、函数的简写

//函数的简写
var a:() ->Void = {
    print("没有参数，没有返回值的简写")
}
a()
func text2(param:(Int) -> Void){
    param(10)
}
text2 { (value) in
    print("text\(value)")
}
func text3(param:(Int,Int) -> Int){
    print(param(10,20))
}
text3 { (item, item2) -> Int in
    return item + item2
}
text3(param: {
    return $0 + $1
})
text3(param: {
     $0 + $1
})

三十一、定义枚举、设置枚举值

//定义枚举、设置枚举值
enum TestEnum{
    case A    //或者 case A,B,C
    case B
    case C
}
print(TestEnum.A)
func FunName(param:TestEnum){
    if param == TestEnum.A {
        print("a")
    }else if param == TestEnum.B{
        print("b")
    }else{
        print("c")
    }
}
print("---------")
FunName(param: TestEnum.B)
enum ValueEnum:Int{
    case A = 1
    case B = 2
}
print(ValueEnum.A) //A
print(ValueEnum.A.rawValue) //1

三十二、枚举相关值的设置

//枚举相关值的设置
enum TextEnum{
    case name(String)
    case age(Int)
    case xy(Int ,Int)
    
}
print(TextEnum.name("aassaas"))
func play(param:TextEnum){
    switch param {
    case TextEnum.name("Swift"):
        print("Swift")
    case TextEnum.age(10):
        print("10")
    case TextEnum.xy(20, 100):
        print(20,100)
    default:
        print("没有匹配")
    }
}
play(param: TextEnum.name("Swift1"))
play(param: TextEnum.age(10))
play(param: TextEnum.xy(100, 20))

三十三、枚举遍历

enum TextEnum:String,CaseIterable{
    case swiftui = "SwiftUI"
    case foundation = "Foundation"
}
for item in TextEnum.allCases{
    print(item)
}
for index in 0..<TextEnum.allCases.count {
    print(TextEnum.allCases[index])
}

三十四、结构体的定义和使用

//结构体的定义和使用
struct Student{
    var name = "unknow"
    var age = 0
    var score = 0.0
    var ispass = false
    static var schoolName = "清华大学"
    //空初始化器
    init() {
        
    }
    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
        }
    }
    //结构体不建议写get、set方法 getter setter是类的
    func getName() -> String {
        return self.name
    }
    func getAge() -> Int {
        return self.age
    }
    func getScore() -> Double {
        return self.score
    }
    func getIsPass() -> Bool {
        return self.ispass
    }
    //函数中修改结构体的值 需要用到mutating
    mutating func setScore(score: Double){
        self.score = score
        if self.score < 60 {
            self.ispass = false
        }else{
            self.ispass = true
        }
    }
    
}
var a = Student()
print(a.getName())
var b = Student(name: "张三", age: 19, score: 90)//创建结构体
print(b)
print(b.name)
print(b.getName())
b.setScore(score: 10)
print(b.score)
print(b.ispass)
//Student.schoolName = "123123"


struct Test{
    var age = 10
    let b = 100 // 无法通过结构体进行修改 例如 T.b =
}
var  t1 = Test() //如果用let 修饰 也无法修改
print(t1.age)
var t2 = Test()
print(t2.age)

print("-----")
t2.age = 100 //值传递
print(t2.age)
print(t1.age)

print("-----")

三十五、计算属性

//计算属性
struct Person {
   private var value = ""
    var name:String{
//        set(param){
//            value = param
//            print("set -" + value)
//        }
        set{
            value = newValue //如果没有set(),系统默认提供的是newValue
            print("set -" + value)
        }
        get{
            print("get - " + value)
            return value + " I Love You"
        }
        
    }
    init() {
        
    }
    init(name:String) {
        self.name = name
    }
}
var person = Person()
person.name = "小张"//setter
person.name //getter
var person2 = Person(name: "小李")
print(person2)

三十六、属性观察-属性监听

//属性观察-属性监听  OC->KVO
struct Person{
    var name: String = "unknow"{
//        willSet(new_Value){
//            print("newValue - " + new_Value)
//        }
//        didSet(old_Value){
//            print("old_Value - " + old_Value)
//
//        }
        willSet{
            print(newValue)
        }
        didSet{
            print(oldValue)
        }
         
    }
}
var person = Person()
person.name = "Swift" //不对get做监听

三十七、subscript 下标语法

//subscript 下标语法
struct Person {
    private var array:[String] = ["swift", "iso", "macos"]
    subscript(index:Int, param:String) ->String {
        set(newValue){
            print("set 方法")
            array.insert(newValue + param, at: index)
            print("----" + String(index) + "----" + newValue)
        }
        get{
            print("get 方法")
            
            return array[index]
        }
    }
}
var person = Person()

person[0,"hello"] = "hello"
print("Person[0]+",person[0,"asd"])//"asd" 没啥用
print("Person[1]+",person[1,"asd"])
print("Person[2]+",person[2,"asd"])
print("Person[3]+",person[3,"asd"])

三十八、类的实际传递是传引用、结构体传的是值

//类的实际传递是传引用、结构体传的是值

class Student{
    private var name:String = "unknow"
    private var age:Int = 0
    private var score:Double = 0.0
    private var ispass:Bool = false
    public static let schoolName = "清华"
    convenience init() { //如果要在一个init里面调用另一个init 需要使用convenience
        self.init(name:"unknow", age:10, score:0.0)
    }
    private func ispass(param:Double){
        self.score = param
        if score < 60 {
            self.ispass = false
        }else{
            self.ispass = true
        }
    }
    init(name:String, age:Int, score:Double) {
        self.name = name
        self.age = age
        self.ispass(param: score)
    }
   public func setScore(score:Double) {
        ispass(param: score)
    }
    public func getIsPass() -> Bool {
        return self.ispass
    }
    public func getName() -> String {
        return self.name
    }
    public func getAge() -> Int {
        return self.age
    }
    public static func get() -> String{
        return "Swift"
    }
}
var s1 = Student()
print(s1.getName())
print("------------")
var s2 = Student(name: "小张", age: 10, score: 40)
print(s2.getName()) //小张
print(s2.getIsPass()) //false
print(s2.getAge())
s2.setScore(score: 150)
print(s2.getIsPass()) //true
print(Student.schoolName) //清华
print(Student.get()) //Swift

class Teacher{
    var name = "Swift" //如果这里是let 无论是类还是结构体都不嫩修改
    init() {
        
    }
}
var t1 = Teacher()
var t2 = t1 //指向同一个实例，结构体是值传递。。。
print(t1.name)
print(t2.name)
print("-------------")
t2.name = "OC"
print(t1.name) //也变成了OC
print(t2.name)
let t3 = Teacher() //结构体如果在这里定义let 也不能修改
t3.name = "IOS"
print(t3.name)

三十九、在类中使用属性计算、属性观察

//在类中使用属性计算、属性观察
class Person{
    private var Value:String = ""
    var name: String{
        set{
            Value = newValue
            print("set - " + Value)
        }
        get
        {
            return "get -" + Value
        }
    }
    var age: Int  = 1{
        willSet{
            print("willSet =" + String(newValue))
        }
        didSet{
            print("didSet =" + String(oldValue))
        }
    }
}
var person = Person()
person.name = "hello"
print(person.name)
print("-------")
person.age = 10

类中的下标语法

//类中的下标语法
class Data{
    private var array1:[String] = ["Apple", "Goole"]
    private var array2:[String] = ["Android", "ios"]
    subscript(index:Int ,index2:Int) -> String {
        get{
            return array1[index] + "," + array2[index2]
        }
    }
}
var data = Data()
print(data[0,1])
print(data[1,0])

四十、 Swift从入门到放弃实例【三】