Swift: ตัวเลือกการทดสอบสำหรับศูนย์

ฉันใช้ Xcode 6 Beta 4 ฉันมีสถานการณ์แปลก ๆ นี้ซึ่งฉันไม่สามารถหาวิธีทดสอบตัวเลือกได้อย่างเหมาะสม

หากฉันมี xyz ที่เป็นทางเลือกคือวิธีทดสอบที่ถูกต้อง:

if (xyz) // Do something

หรือ

if (xyz != nil) // Do something

เอกสารบอกว่าให้ทำวิธีแรก แต่ฉันพบว่าบางครั้งต้องใช้วิธีที่สองและไม่สร้างข้อผิดพลาดของคอมไพเลอร์ แต่ในบางครั้งวิธีที่สองจะสร้างข้อผิดพลาดของคอมไพเลอร์

ตัวอย่างเฉพาะของฉันคือการใช้ตัวแยกวิเคราะห์ GData XML เชื่อมต่ออย่างรวดเร็ว:

let xml = GDataXMLDocument(
    XMLString: responseBody,
    options: 0,
    error: &xmlError);

if (xmlError != nil)

ที่นี่ถ้าฉันเพิ่งทำ:

if xmlError

มันจะกลับมาเป็นจริงเสมอ อย่างไรก็ตามถ้าฉันทำ:

if (xmlError != nil)

จากนั้นก็ใช้งานได้ (ตามวิธีการทำงานใน Objective-C)

มีบางอย่างกับ GData XML และวิธีที่ใช้กับตัวเลือกที่ฉันขาดหายไปหรือไม่?

ใน Xcode Beta 5 พวกเขาไม่อนุญาตให้คุณทำ:

var xyz : NSString?

if xyz {
  // Do something using `xyz`.
}

สิ่งนี้ก่อให้เกิดข้อผิดพลาด:

ไม่เป็นไปตามโปรโตคอล 'BooleanType.Protocol'

คุณต้องใช้หนึ่งในรูปแบบเหล่านี้:

if xyz != nil {
   // Do something using `xyz`.
}

if let xy = xyz {
   // Do something using `xy`.
}

หากต้องการเพิ่มคำตอบอื่น ๆ แทนที่จะกำหนดให้กับตัวแปรที่มีชื่อแตกต่างกันภายในifเงื่อนไข:

var a: Int? = 5

if let b = a {
   // do something
}

คุณสามารถใช้ชื่อตัวแปรเดียวกันซ้ำได้เช่นนี้:

var a: Int? = 5

if let a = a {
    // do something
}

วิธีนี้อาจช่วยให้คุณหลีกเลี่ยงการใช้ชื่อตัวแปรโฆษณาจนหมด ...

สิ่งนี้ใช้ประโยชน์จากการสร้างเงาตัวแปรที่รองรับใน Swift

หนึ่งในวิธีที่ตรงที่สุดในการใช้ตัวเลือกมีดังต่อไปนี้:

สมมติว่าxyzเป็นประเภททางเลือกเช่นInt?ตัวอย่าง

if let possXYZ = xyz {
    // do something with possXYZ (the unwrapped value of xyz)
} else {
    // do something now that we know xyz is .None
}

ด้วยวิธีนี้คุณสามารถทดสอบว่าxyzมีค่าหรือไม่และถ้าเป็นเช่นนั้นให้ใช้ค่านั้นทันที

เกี่ยวกับข้อผิดพลาดของคอมไพเลอร์ของคุณประเภทUInt8นี้ไม่ใช่ทางเลือก (หมายเหตุไม่ใช่ '?') ดังนั้นจึงไม่สามารถแปลงเป็นnil. ตรวจสอบให้แน่ใจว่าตัวแปรที่คุณกำลังทำงานอยู่นั้นเป็นทางเลือกก่อนที่คุณจะปฏิบัติเหมือนตัวแปรเดียว

สวิฟต์ 3.0, 4.0

ส่วนใหญ่มีสองวิธีในการตรวจสอบทางเลือกสำหรับศูนย์ นี่คือตัวอย่างพร้อมการเปรียบเทียบระหว่างพวกเขา

1. ถ้าปล่อยให้

if letเป็นวิธีพื้นฐานที่สุดในการตรวจสอบทางเลือกสำหรับศูนย์ เงื่อนไขอื่น ๆ สามารถผนวกเข้ากับการตรวจสอบศูนย์นี้โดยคั่นด้วยเครื่องหมายจุลภาค ตัวแปรต้องไม่เป็นศูนย์เพื่อย้ายสำหรับเงื่อนไขถัดไป หากต้องการเพียงการตรวจสอบศูนย์ให้ลบเงื่อนไขพิเศษในรหัสต่อไปนี้

นอกเหนือจากนั้นถ้าxไม่ใช่ศูนย์การปิด if จะถูกดำเนินการและx_valจะสามารถใช้ได้ภายใน มิฉะนั้นการปิดอื่นจะถูกเรียก

if let x_val = x, x_val > 5 {
    //x_val available on this scope
} else {

}

2. ยามให้

guard letสามารถทำสิ่งที่คล้ายกันได้ จุดประสงค์หลักคือทำให้สมเหตุสมผลมากขึ้น เหมือนกับการพูดว่าMake sure the variable is not nil, or stop the function . guard letยังสามารถตรวจสอบเงื่อนไขเพิ่มเติมได้อีกif letด้วย

ความแตกต่างคือค่าที่ยังไม่ได้ห่อจะมีอยู่ในขอบเขตเดียวกันดังguard letที่แสดงในความคิดเห็นด้านล่าง นอกจากนี้ยังนำไปสู่จุดนั้นในที่อื่นปิดโปรแกรมที่มีเพื่อออกจากขอบเขตปัจจุบันโดยreturn, breakฯลฯ

guard let x_val = x, x_val > 5 else {
    return
}
//x_val available on this scope

จากคู่มือการเขียนโปรแกรมที่รวดเร็ว

หากคำสั่งและบังคับให้ยกเลิกการห่อ

คุณสามารถใช้คำสั่ง if เพื่อค้นหาว่าทางเลือกมีค่าหรือไม่ หากตัวเลือกมีค่าจะประเมินเป็นจริง หากไม่มีค่าเลยจะประเมินเป็นเท็จ

ดังนั้นวิธีที่ดีที่สุดคือ

// swift > 3
if xyz != nil {}

และถ้าคุณกำลังใช้xyzคำสั่ง in if คุณสามารถแกะxyzคำสั่ง if ในตัวแปรค่าคงที่ได้ดังนั้นคุณไม่จำเป็นต้องแกะทุกที่ในคำสั่ง if ที่xyzจะใช้

if let yourConstant = xyz{
      //use youtConstant you do not need to unwrap `xyz`
}

อนุสัญญานี้เสนอแนะโดยappleและจะตามด้วย devlopers

แม้ว่าคุณจะยังคงต้องเปรียบเทียบทางเลือกอย่างชัดเจนกับnilหรือใช้การเชื่อมโยงที่เป็นทางเลือกเพื่อแยกค่าเพิ่มเติม (เช่นตัวเลือกไม่ได้ถูกแปลงเป็นค่าบูลีนโดยปริยาย) แต่ก็น่าสังเกตว่า Swift 2 ได้เพิ่มguardคำสั่งเพื่อช่วยหลีกเลี่ยงปิรามิดแห่งการลงโทษเมื่อทำงาน ด้วยค่าทางเลือกหลายค่า

กล่าวอีกนัยหนึ่งตอนนี้ตัวเลือกของคุณรวมถึงการตรวจสอบอย่างชัดเจนสำหรับnil:

if xyz != nil {
    // Do something with xyz
}

การผูกเพิ่มเติม:

if let xyz = xyz {
    // Do something with xyz
    // (Note that we can reuse the same variable name)
}

และguardงบ:

guard let xyz = xyz else {
    // Handle failure and then exit this code block
    // e.g. by calling return, break, continue, or throw
    return
}

// Do something with xyz, which is now guaranteed to be non-nil

สังเกตว่าการเชื่อมโยงทางเลือกธรรมดาสามารถนำไปสู่การเยื้องมากขึ้นได้อย่างไรเมื่อมีค่าทางเลือกมากกว่าหนึ่งค่า:

if let abc = abc {
    if let xyz = xyz {
        // Do something with abc and xyz
    }        
}

คุณสามารถหลีกเลี่ยงการซ้อนกันได้ด้วยguardคำสั่ง:

guard let abc = abc else {
    // Handle failure and then exit this code block
    return
}

guard let xyz = xyz else {
    // Handle failure and then exit this code block
    return
}

// Do something with abc and xyz

ส่วนขยายโปรโตคอล Swift 5

นี่คือแนวทางในการใช้ส่วนขยายโปรโตคอลเพื่อให้คุณสามารถอินไลน์การตรวจสอบศูนย์เสริมได้อย่างง่ายดาย

import Foundation

public extension Optional {

    var isNil: Bool {

        guard case Optional.none = self else {
            return false
        }

        return true

    }

    var isSome: Bool {

        return !self.isNil

    }

}

การใช้งาน

var myValue: String?

if myValue.isNil {
    // do something
}

if myValue.isSome {
    // do something
}

ตอนนี้คุณสามารถทำสิ่งต่อไปนี้ได้อย่างรวดเร็วซึ่งจะช่วยให้คุณได้รับวัตถุประสงค์ -c เล็กน้อย if nil else

if textfieldDate.text?.isEmpty ?? true {

}

แทนที่จะเป็นเช่นifนั้นตัวดำเนินการ ternary อาจมีประโยชน์เมื่อคุณต้องการรับค่าโดยพิจารณาจากสิ่งที่เป็นศูนย์:

func f(x: String?) -> String {
    return x == nil ? "empty" : "non-empty"
}

อีกวิธีหนึ่งนอกเหนือจากการใช้ifหรือguardคำสั่งในการทำการผูกทางเลือกคือการขยายOptionalด้วย:

extension Optional {

    func ifValue(_ valueHandler: (Wrapped) -> Void) {
        switch self {
        case .some(let wrapped): valueHandler(wrapped)
        default: break
        }
    }

}

ifValueได้รับการปิดและเรียกมันด้วยค่าเป็นอาร์กิวเมนต์เมื่อทางเลือกไม่ใช่ศูนย์ ใช้วิธีนี้:

var helloString: String? = "Hello, World!"

helloString.ifValue {
    print($0) // prints "Hello, World!"
}

helloString = nil

helloString.ifValue {
    print($0) // This code never runs
}

คุณควรใช้ifหรือguardอย่างไรก็ตามวิธีการเหล่านี้เป็นวิธีการธรรมดาที่สุด (ที่คุ้นเคย) ที่โปรแกรมเมอร์ Swift ใช้

ตัวเลือกหนึ่งที่ไม่ได้กล่าวถึงโดยเฉพาะคือการใช้ไวยากรณ์ค่าที่ถูกละเว้นของ Swift:

if let _ = xyz {
    // something that should only happen if xyz is not nil
}

ฉันชอบสิ่งนี้ตั้งแต่การตรวจสอบnilความรู้สึกผิดปกติในภาษาสมัยใหม่เช่น Swift ฉันคิดว่าเหตุผลที่มันรู้สึกผิดnilปกตินั้นเป็นค่านิยมของแมวมอง เราเลิกใช้ทหารรักษาการณ์ไปแล้วแทบทุกที่ในการเขียนโปรแกรมสมัยใหม่ดังนั้นnilรู้สึกว่ามันควรจะไปด้วย

นอกจากนี้คุณสามารถใช้ Nil-Coalescing Operator

nil-coalescing operator(a ?? b ) unwraps ตัวเลือกaถ้ามันมีaค่าหรือผลตอบแทนที่aคุ้มค่าเริ่มต้นbถ้ามีa nilนิพจน์ a เป็นประเภททางเลือกเสมอ การแสดงออกต้องตรงกับชนิดที่เก็บไว้ภายในba

let value = optionalValue ?? defaultValue

หากoptionalValueเป็นnilเช่นนั้นระบบจะกำหนดค่าให้โดยอัตโนมัติdefaultValue

var xyz : NSDictionary?

// case 1:
xyz = ["1":"one"]
// case 2: (empty dictionary)
xyz = NSDictionary() 
// case 3: do nothing

if xyz { NSLog("xyz is not nil.") }
else   { NSLog("xyz is nil.")     }

การทดสอบนี้ได้ผลตามที่คาดไว้ในทุกกรณี BTW, ()คุณไม่จำเป็นต้องวงเล็บ

หากคุณมีเงื่อนไขและต้องการแกะและเปรียบเทียบวิธีการใช้ประโยชน์จากการประเมินการลัดวงจรของนิพจน์บูลีนสารประกอบใน

if xyz != nil && xyz! == "some non-nil value" {

}

จริงอยู่สิ่งนี้ไม่สามารถอ่านได้เหมือนกับโพสต์แนะนำอื่น ๆ แต่ทำให้งานลุล่วงและค่อนข้างรวบรัดกว่าวิธีแก้ไขปัญหาอื่น ๆ ที่แนะนำ