ระบุค่าเริ่มต้นสำหรับตัวเลือกใน Swift หรือไม่

สำนวนสำหรับการจัดการกับตัวเลือกใน Swift ดูเหมือนจะละเอียดเกินไปหากสิ่งที่คุณต้องการทำคือให้ค่าเริ่มต้นในกรณีที่ไม่มีค่า:

if let value = optionalValue {
    // do something with 'value'
} else {
    // do the same thing with your default value
}

ซึ่งเกี่ยวข้องกับการทำซ้ำรหัสโดยไม่จำเป็นหรือ

var unwrappedValue
if let value = optionalValue {
    unwrappedValue = value
} else {
    unwrappedValue = defaultValue
}

ซึ่งต้องunwrappedValueไม่คงที่

ตัวเลือกของ Scala monad (ซึ่งโดยพื้นฐานแล้วเป็นความคิดเดียวกันกับทางเลือกของ Swift) มีวิธีการgetOrElseสำหรับจุดประสงค์นี้:

val myValue = optionalValue.getOrElse(defaultValue)

ฉันพลาดอะไรไปรึเปล่า? Swift มีวิธีการที่กะทัดรัดในการทำเช่นนั้นหรือไม่? หรือล้มเหลวนั้นเป็นไปได้ที่จะกำหนดgetOrElseในส่วนขยายสำหรับตัวเลือกหรือไม่

ปรับปรุง

Apple ได้เพิ่มผู้ดำเนินการรวมตัวกัน:

var unwrappedValue = optionalValue ?? defaultValue

ผู้ประกอบการที่ประกอบไปด้วยคือเพื่อนของคุณในกรณีนี้

var unwrappedValue = optionalValue ? optionalValue! : defaultValue

คุณสามารถให้ส่วนขยายของคุณเองสำหรับ enum เพิ่มเติม:

extension Optional {
    func or(defaultValue: T) -> T {
        switch(self) {
            case .None:
                return defaultValue
            case .Some(let value):
                return value
        }
    }
}

จากนั้นคุณสามารถทำได้:

optionalValue.or(defaultValue)

อย่างไรก็ตามฉันขอแนะนำให้ติดกับผู้ประกอบการที่ประกอบไปด้วยนักพัฒนาคนอื่นจะเข้าใจได้เร็วกว่าโดยไม่ต้องตรวจสอบorวิธีการ

หมายเหตุ : ผมเริ่มโมดูลที่จะเพิ่มผู้ช่วยเหมือนกันเช่นนี้orในOptionalการที่รวดเร็ว

ตั้งแต่เดือนสิงหาคม 2014 Swift มีผู้ดำเนินการรวมตัวกัน (??) ที่อนุญาตสิ่งนั้น ตัวอย่างเช่นสำหรับ String myOptional ที่เป็นตัวเลือกคุณสามารถเขียน:

result = myOptional ?? "n/a"

ถ้าคุณเขียนว่า:

let result = optionalValue ?? 50

และ optionalValue != nilจากนั้นก็resultจะมีoptionalมากเกินไปและคุณจะต้องแกะมันในอนาคต

แต่คุณสามารถเขียนโอเปอเรเตอร์ได้

infix operator ??? { associativity left precedence 140 }

func ???<T>(optLeft:T?, right:T!) -> T!
{
    if let left = optLeft
    {
        return left
    }
    else { return right}
}

ตอนนี้คุณสามารถ:

 let result = optionalValue ??? 50

และเมื่อ optionalValue != nilนั้น resultจะเป็นอย่างไรunwraped

ดูเหมือนว่าจะทำงานต่อไปนี้

extension Optional {
    func getOrElse<T>(defaultValue: T) -> T {
        if let value = self? {
            return value as T
        } else {
            return defaultValue
        }
    }
}

อย่างไรก็ตามความจำเป็นในการร่ายvalue as Tเป็นแฮ็คที่น่าเกลียด เป็นการดีที่ควรมีวิธีการยืนยันว่าTเป็นประเภทเดียวกับที่มีอยู่ในตัวเลือก ในขณะที่มันอยู่ให้พิมพ์ชุดการอนุมานTโดยอิงตามพารามิเตอร์ที่กำหนดให้กับ getOrElse แล้วล้มเหลวขณะรันไทม์หากสิ่งนี้ไม่ตรงกับทางเลือกและตัวเลือกไม่เป็นศูนย์:

let x: Int?

let y = x.getOrElse(1.414) // y inferred as Double, assigned 1.414

let a: Int? = 5

let b: Double = a.getOrElse(3.14) // Runtime failure casting 5 to Double