枚举

By admin in 4858.com on 2019年4月20日

/*

/*

//: Playground – noun: a place where people can play

1).枚举的定义及应用

 Swift枚举:

 Swift枚举:

importUIKit

 定义语法:

 Swift中的枚举比OC中的枚举庞大, 因为斯维夫特中的枚举是一等类型,
它能够像类和结构体同样扩大品质和章程

 Swift中的枚举比OC中的枚举强大, 因为Swift中的枚举是一等类型,
它能够像类和结构体同样扩展质量和办法

/*

枚举类型  枚举名 : 枚举值类型 {

     case 类型名1   

     case 类型名2

     …

}   //枚举值类型可省略 暗许Int

 格式:

 格式:

Swift枚举:

如:

 enum Method{

 enum Method{

斯维夫特中的枚举比OC中的枚举强大,因为斯维夫特中的枚举是一等类型,它可以像类和结构体同样扩展属性和艺术

enum Method {

      case add

      case sub

      case Mul

      case Dlv

}

 case 枚举值

 case 枚举值

格式:

调用:(可整合斯威夫特的花色估计机制

 }

 }

enum Method{

let case1 = Method.add

let case2 : Method = .sub

 */

 */

case枚举值

组成switch case使用枚举:

 

 

}

func chooseMethod(method : Method) {

     switch method {

        case .add: break

         default : break

    }

}

enum Method {

enum Method {

*/


    case Add

    case Add

enumMethod{

二).枚举关联值和值绑定

    case Sub

    case Sub

//case Add

enum Method {

    case add (start : Double , end : Double)

    case sub (start : Double , end : Double)

}

let case1 = Method.add(start: 11, end: 10)

func chooseMethod(method : Method) {

    switch method {

        case let .add(start: e, end: _) :

             print(e)

       default : break

   }

}

    case Mul

    case Mul

//case Sub

    case Div

    case Div

//case Mul

    //能够连在一齐写

    //能够连在一齐写

//case Div

//    case Add, Sub, Mul, Div

//    case Add, Sub, Mul, Div

//能够连在一齐写

}

}

caseAdd, Sub, Mul, Div

 

 

}

// 能够行使枚举类型变量只怕常量接收枚举值

// 能够接纳枚举类型变量或许常量接收枚举值

//能够利用枚举类型变量或常量接收枚举值

var m:Method = .Add

var m:Method = .Add

varm:Method= .Add

print(m)

print(m)

//注意:借使变量或常量未有点名项目,那么后面必须抬高该值属于哪个枚举类型

 

 

varm1 =Method.Add

// 注意: 假设变量只怕常量没有点名项目,
那么前边必须抬高该值属于哪个枚举类型

// 注意: 假诺变量恐怕常量未有点名项目,
那么后边必须抬高该值属于哪个枚举类型

//利用Switch匹配

var m1 = Method.Add

var m1 = Method.Add

//注意:假诺case中蕴藏了有着的值,能够不写default.如若case中从未包涵枚举中有着的值,必须写default

print(m1)

print(m1)

funcmakeChoiceMethod(op:Method)->(Double,Double)->Double{

 

 

switch(op){

// 利用Switch匹配

// 利用Switch匹配

case.Add:

// 注意: 借使case中带有了富有的值, 能够不写default;
即使case未有包括枚举中保有的值, 必须写default

// 注意: 假如case中包涵了具备的值, 能够不写default;
若是case未有包罗枚举中持有的值, 必须写default

print(“加法”)

 

 

枚举。funcadd(a:Double,b:Double)->Double{

switch (Method.Add){

switch (Method.Add){

returna+b

case Method.Add:

case Method.Add:

}

    print(“加法”)

    print(“加法”)

returnadd

case Method.Sub:

case Method.Sub:

case.Sub:

    print(“减法”)

    print(“减法”)

print(“减法”)

case Method.Mul:

case Method.Mul:

return{(a:Double,b:Double)->Doubleinreturna-b}

    print(“除法”)

    print(“除法”)

case.Mul:

case Method.Div:

case Method.Div:

print(“除法”)

    print(“乘法”)

    print(“乘法”)

return{return$0 * $一}//利用项目推测,使用$符号,省略写成$0 * $1

//default:

//default:

case.Div:

//    print(“都不是”)

//    print(“都不是”)

print(“乘法”)

}

}

return{ $0 / $1 }

 

 

//default:

/*

/*

//print(“都不是”)

 原始值:

 原始值:

}

 OC中枚举的真相便是整数,所以OC中的枚举是有原始值的,暗中同意是从0初始

 OC中枚举的本来面目正是整数,所以OC中的枚举是有原始值的,私下认可是从0先河

}

 而斯维夫特中的枚举默许是未曾原始值的,
然则足以在概念时报告系统让枚举有原始值

 而Swift中的枚举暗许是尚未原始值的,
但是足以在概念时告知系统让枚举有原始值

makeChoiceMethod(op: .Add)(5,4)

 enum Method: 枚举值原始值类型{

 enum Method: 枚举值原始值类型{

makeChoiceMethod(op: .Mul)

 case 枚举值

 case 枚举值

/*

 }

 }

原始值:

 */

 */

OC中枚举的真相便是整数,所以OC中的枚举是有原始值的,暗中同意是从0初始

 

 

而斯维夫特中的枚举私下认可是未曾原始值的,可是足以在概念时告诉系统让枚举有原始值

enum Method2: Int {

enum Method2: Int {

enum Method:枚举值原始值类型{

    case Add, Sub, Mul, Div

    case Add, Sub, Mul, Div

case枚举值

}

}

}

 

 

*/

// 和OC中的枚举同样, 也能够钦定原始值, 前面包车型大巴值暗中认可 +1

// 和OC中的枚举一样, 也能够内定原始值, 后边的值私下认可 +一

//和OC中的枚举同样,也得以钦定原始值,后边的值暗中同意+一

enum Method3: Int {

enum Method3: Int {

enumMethod3:Int{

    case Add = 5, Sub, Mul, Div

    case Add = 5, Sub, Mul, Div

caseAdd =5, Sub, Mul, Div

}

}

}

 

 

Method3.Add.rawValue

// Swift中的枚举除了可以钦点整型以外还是能够钦赐其余类别,
不过只要钦点别的连串, 必须给全部枚举值赋值, 因为无法自动递增

// Swift中的枚举除了可以内定整型以外还足以钦赐别的系列,
可是要是钦命其余种类, 必须给全部枚举值赋值, 因为无法自动递增

Method3.Sub.rawValue

enum Method4: Double {

enum Method4: Double {

Method3.init(rawValue:6)

    case Add = 5.0, Sub = 6.0, Mul = 7.0, Div = 8.0

    case Add = 5.0, Sub = 6.0, Mul = 7.0, Div = 8.0

//
Swift中的枚举除了能够钦点整形以外还足以内定其余种类,不过就算内定别的品类,必须给持有枚举值赋值,因为不能够自动递增

}

}

enumMethod4:Double{

 

 

//能够连在一同写

// rawValue代表将枚举值转变为原始值,
注意老版本中改变为原始值的点子名称叫toRaw

// rawValue代表将枚举值调换为原始值,
注意老版本中退换为原始值的艺术名称叫toRaw

caseAdd =5.0, Sub =6.0, Mul =6.1, Div =8.0

//
最新的斯维夫特版本不再支持toRaw和fromRaw了,唯有rawValue属性和hashValue属性了!

//
最新的Swift版本不再帮忙toRaw和fromRaw了,唯有rawValue属性和hashValue属性了!

}

print(Method4.Sub.rawValue)

print(Method4.Sub.rawValue)

//
rawValue代表将枚举值调换为原始值,注意老版本中改换为原始值的不二等秘书诀名称为toRaw

 

 

print(Method4.Sub.rawValue)

//
hashValue来访问成员值所对应的哈希值,那个哈希值是不可能改换的,由编译器自动生成,之后不可改变,斯威夫特在私自实际上选拔哈希值来识别枚举符号的(即成员)

//
hashValue来访问成员值所对应的哈希值,那些哈希值是不能够改换的,由编写翻译器自动生成,之后不可改动,Swift在骨子里其实利用哈希值来识别枚举符号的(即成员)

//原始值转变为枚举值

print(Method4.Mul.hashValue)

print(Method4.Mul.hashValue)

enumMethod5:String{

 

 

caseAdd =”add”, Sub =”sub”, Mul =”mul”, Div =”div”

// 原始值调换为枚举值

// 原始值调换为枚举值

}

enum Method5: String {

enum Method5: String {

//通过原始值成立枚举值

    case Add = “add”, Sub = “sub”, Mul = “mul”, Div = “div”

    case Add = “add”, Sub = “sub”, Mul = “mul”, Div = “div”

/*

}

}

注意:

 

 

一.原始值区分轻重缓急写

// 通过原始值创制枚举值

// 通过原始值成立枚举值

二.回到的是二个可选值,因为原始值对应的枚举值不必然存在

/*

/*

三.老版本中为fromRaw(“add”)

 注意:

 注意:

*/

 一.原始值区分轻重缓急写

 一.原始值区分轻重缓急写

letm2 =Method5(rawValue:”add”)

 2.回到的是贰个可选值,因为原始值对应的枚举值不必然存在

 二.赶回的是二个可选值,因为原始值对应的枚举值不自然存在

print(“\(String(describing:m2))”)

 3.老版本中为fromRaw(“add”)

 3.老版本中为fromRaw(“add”)

//func chooseMethod(op:Method2)

 */

 */

funcchooseMethod(op:String)

let m2:Method5 = Method5(rawValue: “add”)!

let m2:Method5 = Method5(rawValue: “add”)!

{

print(m2)

print(m2)

//由于重回是可选类型,所以有望为nil,最佳使用可选绑定

 

 

ifletopE =Method5(rawValue: op){

//func chooseMethod(op:Method2)

//func chooseMethod(op:Method2)

switch(opE){

 

 

case.Add:

func chooseMethod5(rawString: String) {

func chooseMethod5(rawString: String) {

print(“加法”)

    // 由于重临值是可选类型, 所以有十分的大概率为nil, 最棒应用可选绑定

    // 由于再次回到值是可选类型, 所以有望为nil, 最棒应用可选绑定

case.Sub:

    if let opE = Method5(rawValue: rawString) {

    if let opE = Method5(rawValue: rawString) {

print(“减法”)

        switch (opE) {

        switch (opE) {

case.Mul:

        case .Add:

        case .Add:

print(“除法”)

            print(“加法”)

            print(“加法”)

case.Div:

        case .Sub:

        case .Sub:

print(“乘法”)

            print(“减法”)

            print(“减法”)

}

        case .Mul:

        case .Mul:

}

            print(“除法”)

            print(“除法”)

}

        case .Div:

        case .Div:

chooseMethod(op:”div”)

            print(“乘法”)

            print(“乘法”)

/*

        }

        }

枚举相关值:

    }

    }

能够让枚举值对应的原始值不是绝无仅有的,而是3个变量.

}

}

每1个枚举能够是在某种格局下的片段特定值

print(chooseMethod5(rawString: “add”))

print(chooseMethod5(rawString: “add”))

*/

 

 

enumlineSegmentDescriptor{

/*

/*

caseStartAndEndPattern(start:Double, end:Double)

 枚举相关值:

 枚举相关值:

caseStartAndLengthPattern(start:Double, length:Double)

 能够让枚举值对应的原始值不是绝无仅有的, 而是3个变量.

 能够让枚举值对应的原始值不是唯一的, 而是四个变量.

}

 每二个枚举能够是在某种形式下的部分特定值

 每3个枚举可以是在某种情势下的局地特定值

varlsd =lineSegmentDescriptor.StartAndLengthPattern(start:0.0,
length:100.0)

 */

 */

lsd=lineSegmentDescriptor.StartAndEndPattern(start:0.0, end:50.0)

 

 

//利用switch提取枚举关联值

enum lineSegmentDescriptor {

enum lineSegmentDescriptor {

/*

    case StartAndEndPattern(start: Double, end: Double)

    case StartAndEndPattern(start: Double, end: Double)

switch lsd

    case StartAndLengthPattern(start: Double, length: Double)

    case StartAndLengthPattern(start: Double, length: Double)

{

}

}

case .StartAndEndPattern(let s, let e):

 

 

print(“start = \(s) end = \(e)”)

var lsd = lineSegmentDescriptor.StartAndLengthPattern(start: 0.0,
length: 100.0)

var lsd = lineSegmentDescriptor.StartAndLengthPattern(start: 0.0,
length: 100.0)

case .StartAndLengthPattern(let s, let l):

lsd = lineSegmentDescriptor.StartAndEndPattern(start: 0.0, end: 50.0)

lsd = lineSegmentDescriptor.StartAndEndPattern(start: 0.0, end: 50.0)

print(“start = \(s) lenght = \(l)”)

print(lsd)

print(lsd)

}

 

 

*/

// 利用switch提取枚举关联值

// 利用switch提取枚举关联值

//提取关联值优化写法

/*

/*

switchlsd

 switch lsd

 switch lsd

{

 {

 {

caselet.StartAndEndPattern(s, e):

 case .StartAndEndPattern(let s, let e):

 case .StartAndEndPattern(let s, let e):

print(“start =\(s) end =\(e)”)

 print(“start = \(s) end = \(e)”)

 print(“start = \(s) end = \(e)”)

case.StartAndLengthPattern(lets,letl):

 case .StartAndLengthPattern(let s, let l):

 case .StartAndLengthPattern(let s, let l):

print(“start =\(s) lenght =\(l)”)

 print(“start = \(s) lenght = \(l)”)

 print(“start = \(s) lenght = \4858.com,(l)”)

}

 }

 }

 */

 */

 

 

// 提取关联值优化写法

// 提取关联值优化写法

switch lsd

switch lsd

{

{

case let .StartAndEndPattern(s, e):

case let .StartAndEndPattern(s, e):

    print(“start = \(s) end = \(e)”)

    print(“start = \(s) end = \(e)”)

case .StartAndLengthPattern(let s, let l):

case .StartAndLengthPattern(let s, let l):

    print(“start = \(s) l = \(l)”)

    print(“start = \(s) l = \(l)”)

}

}

 

 

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有