可选类型

/*

/*

/*

/*

 subscripts(下标): 访问对象中数据的快速情势

 subscripts(下标): 访问对象中数量的飞速方式

 可选类型:

 可选类型:

 所谓下标脚本语法便是力所能及通过, 实例[索引值]来做客实例中的数据

 所谓下标脚本语法正是能够由此, 实例[索引值]来走访实例中的数据

 可选类型的精神实际上是3个枚举;

 可选类型的本色实际上是多少个枚举;

 类似于从前我们走访数字和字典, 其实Swift中的数组和字典正是叁个结构体

澳门葡京备用网址, 类似于在此以前我们走访数字和字典, 其实斯维夫特中的数组和字典正是二个结构体

 None 没有值

 None 没有值

 

 

 Some 有值

 Some 有值

 Array:      subscript (index: Int) -> T

 Array:      subscript (index: Int) -> T

 格式: Optional<类型> 可能在档次前面加上?号

 格式: Optional<类型> 或许在品种后边加上?号

 Dictionary: subscript (key: Key) -> Value?

 Dictionary: subscript (key: Key) -> Value?

 由于可选类型在Swift中四处可见, 全数系统做了这一个语法糖, 在品种后边加上?

 由于可选类型在斯维夫特中处处可知, 全体系统做了这些语法糖, 在档次前边加上?

 arr[0] == arr.subscript(0)

 arr[0] == arr.subscript(0)

 */

 */

 dict[“key”] == dict.subscript(“key”)

 dict[“key”] == dict.subscript(“key”)

 

 

 */

 */

var opa: Optional<Int>

var opa: Optional<Int>

 

 

var opb: Int?

var opb: Int?

struct Student {

struct Student {

 

 

    var name: String = “HaRi”

    var name: String = “HaRi”

//基本类型变量, 在动用在此以前务必开始展览开端化, 不然报错;

//基本类型变量, 在利用在此之前务必开始展览伊始化, 不然报错;

    var math: Double = 98.0

    var math: Double = 98.0

//目标: 安全, 不管曾几何时方法都以有含义的;

//指标: 安全, 不管哪天方法都以有含义的;

    var chinese: Double = 99.0

    var chinese: Double = 99.0

//普通变量和可选类型的分别, 普通变量唯有一种情况, 有值;

//普通变量和可选类型的分别, 普通变量唯有一种情况, 有值;

    var english: Double = 100.0

    var english: Double = 100.0

//注意: 斯威夫特中的变量和 OC/C 的不均等, OC/C能够未有值, 是八个随机值;

//注意: 斯威夫特中的变量和 OC/C 的分歧, OC/C能够未有值, 是多个随机值;

    

    

var nora: Int

var nora: Int

    func score(course: String) -> Double

    func score(course: String) -> Double

nora = 10

nora = 10

    {

    {

print(nora)

print(nora)

        switch course {

        switch course {

 

 

        case “math”:

        case “math”:

//Int *p

//Int *p

            return math

            return math

//NSLog(“%d”, *p)   Error!

//NSLog(“%d”, *p)   Error!

        case “chinese”:

        case “chinese”:

 

 

            return chinese

            return chinese

//由于日常变量唯有壹种情景, 有局限性, 所以Swift设计了可选类型

//由于一般变量唯有壹种状态, 有局限性, 所以斯维夫特设计了可选类型

        case “english”:

        case “english”:

print(opb as Any)

print(opb as Any)

            return english

            return english

 

 

        default:

        default:

//可选类型安全啊? 安全! 能够经过可选绑定推断后再利用;

//可选类型安全吗? 安全! 能够透过可选绑定决断后再选取;

            return math + chinese + english //
此处待斟酌为啥重返nil就会爆红

            return math + chinese + english //
此处待探讨为啥重返nil就会爆红

//Swift的发明者出于安全的勘查, 当大家运用基本项目时完全不用思虑是还是不是有值;

//斯威夫特的发明者出于安全的勘查, 当大家运用基本项目时完全不用思量是否有值;

        }

        }

//当大家运用可选类型时, 总会记得先判别再选拔,
让程序时刻通晓如何有值怎么未有值.

//当大家接纳可选类型时, 总会记得先判别再利用,
让程序时刻了然哪些有值什么未有值.

    }

    }

opb = 55

opb = 55

    

    

if let b = opb{

if let b = opb{

    //1.要想达成下标访问, 必须达成subscript方法;

    //一.要想实现下标访问, 必须落成subscript方法;

    print(b)

    print(b)

    //二.要想透过下标访问, 必须实现get方法;

    //二.要想透过下标访问, 必须实现get方法;

}

}

    //三.要想透过下标赋值, 必须实现set方法.

    //叁.要想透过下标赋值, 必须达成set方法.

 

 

    subscript(course: String) -> Double?{

    subscript(course: String) -> Double?{

 

 

        get{

        get{

//斯威夫特中的可选类型变量更接近于OC中的普通变量

//Swift中的可选类型变量更接近于OC中的普通变量

            switch course {

            switch course {

//NSData *data = [NSData
.dataWithContentsOfMappedFile:@”/Users/hanjunqiang/Desktop/Study伊夫ryDay/H5/第三阶段/随笔.html”];

//NSData *data = [NSData
.dataWithContentsOfMappedFile:@”/Users/hanjunqiang/Desktop/Study伊夫ryDay/H5/第一阶段/小说.html”];

            case “math”:

            case “math”:

//NSLog(“%@”, data);

//NSLog(“%@”, data);

                return math

                return math

 

 

            case “chinese”:

            case “chinese”:

var data:NSData? = NSData(contentsOfFile:
“/Users/hanjunqiang/Desktop/StudyEveryDay/H5/第一阶段/小说.html”)
//测试地址, 换来你协调路线地址文件就能够

var data:NSData? = NSData(contentsOfFile:
“/Users/hanjunqiang/Desktop/Study伊芙ryDay/H5/第2阶段/随笔.html”)
//测试地址, 换来你协调路线地址文件就能够

                return chinese

                return chinese

//print(data as Any)

//print(data as Any)

            case “english”:

            case “english”:

 

 

                return english

                return english

 

 

            default:

            default:

/*

/*

                return math + chinese + english

可选类型。                return math + chinese + english

 可选链: 通过可选类型的变量来调用相应的品质和格局;

 可选链: 通过可选类型的变量来调用相应的个性和措施;

            }

            }

 可选链的再次回到值是三个可选值

 可选链的重临值是1个可选值

        }

        }

 格式:

 格式:

        set{

        set{

 可选值?.属性

 可选值?.属性

            switch course{

            switch course{

 可选值?.方法

 可选值?.方法

                case “math”:

                case “math”:

 */

 */

                //以为再次回到的是可选类型

                //认为再次来到的是可选类型

 

 

                math = newValue!

                math = newValue!

class Person {

class Person {

                case “chinese”:

                case “chinese”:

    var name:String

    var name:String

                chinese = newValue!

                chinese = newValue!

    init(name:String) {

    init(name:String) {

                case “english”:

                case “english”:

        self.name = name

        self.name = name

                english = newValue!

                english = newValue!

    }

    }

            default:

            default:

    func whoMan() -> String {

    func whoMan() -> String {

                print(“not found”)

                print(“not found”)

        print(“my name is \(self.name)”)

        print(“my name is \(self.name)”)

            }

            }

        return name

        return name

        }

        }

    }

    }

    }

    }

    func show() {

    func show() {

}

}

        print(“\(self.name)”)

        print(“\(self.name)”)

var stu = Student(name: “han”, math: 99.0, chinese: 98.0, english: 57.0)

var stu = Student(name: “han”, math: 99.0, chinese: 98.0, english: 57.0)

    }

    }

print(stu.score(course: “english”))

print(stu.score(course: “english”))

}

}

stu[“math”] = 100.0

stu[“math”] = 100.0

var p0:Person?

var p0:Person?

print(stu[“math”]!)

print(stu[“math”]!)

var p1:Person = Person(name: “hjq”)

var p1:Person = Person(name: “hjq”)

 

 

p1.name = “han”

p1.name = “han”

 

 

p1.show()

p1.show()

/** Swift中是同意多索引的下标的 **/

/** 斯维夫特中是同意多索引的下标的 **/

 

 

struct Mul {

struct Mul {

/** 怎样通过可选类型来调用对应的方法和本性? **/

/** 怎么着通过可选类型来调用对应的主意和天性? **/

    subscript(a: Int, b: Int) -> Int

    subscript(a: Int, b: Int) -> Int

 

 

    {

    {

// 壹:通过强制解包;  不过强制解包生命垂危, 倘诺可选类型未有值,
会引发运营时不当

// 一:通过强制解包;  可是强制解包快要灭亡, 即便可选类型未有值,
会引发运维时不当

        return a + b

        return a + b

//p0!.name = “xiaohange”

//p0!.name = “xiaohange”

    }

    }

//p0!.whoMan()

//p0!.whoMan()

}

}

 

 

var m = Mul()

var m = Mul()

// 二:通过可选绑定, 代码繁琐, 但安全

// 2:通过可选绑定, 代码繁琐, 但安全

print(m[10,20])

print(m[10,20])

if let b = p0{

if let b = p0{

 

 

    b.name = “hello Han”

    b.name = “hello Han”

    b.whoMan()

    b.whoMan()

}

}

 

 

// 叁.由此可选链, 如若?号前方变量未有值, 整个可选链会失效

// 三.透过可选链, 假使?号前方变量未有值, 整个可选链会失效

// 尤其简洁高效, 有利于使用可选类型

// 特别简洁高效, 有利于使用可选类型

p0 = p1

p0 = p1

p0?.name = “hi, HaRi”

p0?.name = “hi, HaRi”

var str:String? = p0?.whoMan()

var str:String? = p0?.whoMan()

 

 

//可选链的回到值会自动包装成三个可选值

//可选链的回来值会自动包装成三个可选值

//因为可选链大概失效, 所以再次来到值大概有值也说不定没值,
想要表达有值或然未有纸只好用可选值, 所以再次回到值会自动包装成贰个可选值

//因为可选链大概失效, 所以重回值只怕有值也大概没值,
想要表明有值只怕尚未纸只好用可选值, 所以重临值会自动包装成一个可选值

print(p0?.name as Any)

print(p0?.name as Any)

print(p0?.whoMan() as Any)

print(p0?.whoMan() as Any)

print(p1.name)

print(p1.name)

var a:String? = p0?.name

var a:String? = p0?.name

p0?.name = “haha”

p0?.name = “haha”

var b:String? = p1.name

var b:String? = p1.name

 

 

 

 

/*

/*

 可选链调用下标引索:

 可选链调用下标引索:

 格式: 可选值?[]

 格式: 可选值?[]

 */

 */

struct Student {

struct Student {

    var name:String = “han”

    var name:String = “han”

    var math:Double = 99.0

    var math:Double = 99.0

    var chinese:Double = 100.0

    var chinese:Double = 100.0

    var english:Double = 99.0

    var english:Double = 99.0

    //想要通过下标访问, 必须兑现subscript方法;

    //想要通过下标访问, 必须贯彻subscript方法;

    //借使想要通过下标访问, 必须兑现get方法;

    //假使想要通过下标访问, 必须兑现get方法;

    //假使想要通过下标赋值, 必须兑现set方法.

    //要是想要通过下标赋值, 必须兑现set方法.

    subscript(course:String) ->Double?{

    subscript(course:String) ->Double?{

        get{

        get{

            switch course{

            switch course{

                case “math”:

                case “math”:

                return math

                return math

                case “chinese”:

                case “chinese”:

                return chinese

                return chinese

                case “english”:

                case “english”:

                return english

                return english

            default:

            default:

                return nil

                return nil

            }

            }

        }

        }

        set{

        set{

            switch course{

            switch course{

            case “math”:

            case “math”:

                math = newValue!   //再次来到值可选类型!

                math = newValue!   //重临值可选类型!

            case “chinese”:

            case “chinese”:

                chinese = newValue!

                chinese = newValue!

            case “english”:

            case “english”:

                english = newValue!

                english = newValue!

            default:

            default:

                print(“not found”)

                print(“not found”)

            }

            }

        }

        }

    }

    }

}

}

var stu:Student? = Student()

var stu:Student? = Student()

//可选链调用下标引索不供给”.”直接在?号后边加上[]即可

//可选链调用下标引索不要求”.”直接在?号前边加上[]即可

print(stu?[“math”] as Any)

print(stu?[“math”] as Any)

 

 

var arr:Array? = [1,2,3,4]

var arr:Array? = [1,2,3,4]

print(arr?[1] as Any)

print(arr?[1] as Any)

 

 

//利用可选链赋值时, 要小心: 早些版本中无法选拔可选链赋值

//利用可选链赋值时, 要留意: 早些版本中不可能选用可选链赋值

stu?.name = “hanjunqiang”

stu?.name = “hanjunqiang”

print(stu?.name as Any)

print(stu?.name as Any)

 

 

//利用可选链给下标赋值

//利用可选链给下标赋值

stu?[“chinese”] = 200.0

stu?[“chinese”] = 200.0

print(stu?[“chinese”] as Any)

print(stu?[“chinese”] as Any)

 

 

//判定赋值操作是或不是中标, 可选链的赋值操作也有再次回到值

//推断赋值操作是不是成功, 可选链的赋值操作也有再次回到值

//要是赋值成功会重回三个可选类型, 再次回到()?也正是Void? 代表成功,
重返nil代表战败

//要是赋值成功会回来二个可选类型, 重返()?也正是Void? 代表成功,
再次回到nil代表退步

//let res1: = stu?.name = “xiaohange”

//let res1: = stu?.name = “xiaohange”

//let res1: ()? = stu?.name = “xiaohange”

//let res1: ()? = stu?.name = “xiaohange”

//let res1: Void? = stu?.name = “xiaohange”

//let res1: Void? = stu?.name = “xiaohange”

//print(res1)

//print(res1)

 

 

stu = nil

stu = nil

let res: Void? = stu?.name = “HaRi”

let res: Void? = stu?.name = “HaRi”

print(res as Any)

print(res as Any)

 

 

 

 

 

 

/*

/*

 多层可选链:

 多层可选链:

 单层: 可选值?.属性

 单层: 可选值?.属性

 多层: 可选值?.属性.属性   或者    可选值?.属性.属性?.属性

 多层: 可选值?.属性.属性   或者    可选值?.属性.属性?.属性

 */

 */

class A {

class A {

    var name:String = “han”

    var name:String = “han”

}

}

class B {

class B {

    var a1:A?

    var a1:A?

}

}

class C {

class C {

    var b1:B?

    var b1:B?

}

}

class D {

class D {

    var c1:C?

    var c1:C?

}

}

var a1 = A()

var a1 = A()

var b1 = B()

var b1 = B()

var c1 = C()

var c1 = C()

var d1 = D()

var d1 = D()

 

 

d1.c1 = c1

d1.c1 = c1

// 通过d直接给b赋值

// 通过d直接给b赋值

// 由于D中的C是可选值, 所以要求在C后边加上?号

// 由于D中的C是可选值, 所以供给在C前边加上?号

d1.c1?.b1?.a1 = a1

d1.c1?.b1?.a1 = a1

 

 

// 通过d直接拿走a中的name

// 通过d直接获得a中的name

// 其实只必要在可选值前边加上?号就可以, 假若可选值不设有,
那么前面包车型客车链接失效

// 其实只供给在可选值后边加上?号就可以, 如果可选值不设有,
那么前面包车型客车链接失效

print(d1.c1?.b1?.a1?.name as Any)

print(d1.c1?.b1?.a1?.name as Any)

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website