สำนวนที่เป็นไปได้ของผู้ประกอบการที่ประกอบไปด้วยไตรภาคของ C คืออะไร?

ใน C / C ++ (และหลายภาษาของตระกูลนั้น) สำนวนทั่วไปในการประกาศและเริ่มต้นตัวแปรขึ้นอยู่กับเงื่อนไขใช้ตัวดำเนินการเงื่อนไขแบบไตรภาค

int index = val > 0 ? val : -val

Go ไม่มีตัวดำเนินการตามเงื่อนไข เป็นวิธีสำนวนที่สุดในการใช้ชิ้นส่วนของรหัสเดียวกันข้างต้นคืออะไร? ฉันมาถึงวิธีแก้ปัญหาต่อไปนี้ แต่ดูเหมือนว่าค่อนข้างละเอียด

var index int

if val > 0 {
    index = val
} else {
    index = -val
}

มีอะไรที่ดีกว่านี้ไหม?

ตามที่ระบุไว้ (และหวังว่าจะแปลกใจ) การใช้if+elseนั้นเป็นวิธีที่ใช้สำนวนในการทำเงื่อนไขใน Go

นอกเหนือจากการvar+if+elseบล็อกรหัสเต็มเป่าการสะกดนี้ยังใช้บ่อย:

index := val
if val <= 0 {
    index = -val
}

และหากคุณมีบล็อกของรหัสที่ซ้ำซากพอเช่นเทียบเท่าint value = a <= b ? a : bคุณสามารถสร้างฟังก์ชั่นที่จะเก็บมัน:

func min(a, b int) int {
    if a <= b {
        return a
    }
    return b
}

...

value := min(a, b)

คอมไพเลอร์จะอินไลน์ฟังก์ชั่นที่เรียบง่ายเช่นนั้นมันเร็วขึ้นชัดเจนขึ้นและสั้นลง

ไม่ต้องไปไม่มีโอเปอเรเตอร์ประกอบการใช้ if / else ไวยากรณ์เป็นวิธีการใช้สำนวน

ทำไม Go จึงไม่มีโอเปอเรเตอร์?:

ไม่มีการดำเนินการทดสอบแบบไตรภาคใน Go คุณอาจใช้สิ่งต่อไปนี้เพื่อให้ได้ผลลัพธ์เดียวกัน:

if expr {
    n = trueVal
} else {
    n = falseVal
}

เหตุผลที่?:ไม่ได้มาจาก Go คือนักออกแบบของภาษาได้เห็นการดำเนินการที่ใช้บ่อยเกินไปในการสร้างการแสดงออกที่ซับซ้อนอย่างไม่อาจปฏิเสธได้ if-elseรูปแบบแม้จะนานเด็ดชัดเจน ภาษาต้องการเพียงหนึ่งโฟลว์การควบคุมตามเงื่อนไขสร้าง

- คำถามที่พบบ่อย (FAQ) - ภาษาโปรแกรม Go

สมมติว่าคุณมีนิพจน์ประกอบไปด้วย (ใน C):

int a = test ? 1 : 2;

วิธีการใช้สำนวนใน Go เป็นเพียงแค่ใช้ifบล็อก:

var a int

if test {
  a = 1
} else {
  a = 2
}

อย่างไรก็ตามนั่นอาจไม่ตรงกับความต้องการของคุณ ในกรณีของฉันฉันต้องการการแสดงออกแบบอินไลน์สำหรับแม่แบบการสร้างรหัส

ฉันใช้ฟังก์ชั่นนิรนามที่ประเมินโดยทันที:

a := func() int { if test { return 1 } else { return 2 } }()

สิ่งนี้ทำให้มั่นใจได้ว่าทั้งสองสาขาจะไม่ได้รับการประเมินเช่นกัน

ประกอบไปด้วยแผนที่ง่ายต่อการอ่านโดยไม่ต้องใส่วงเล็บ:

c := map[bool]int{true: 1, false: 0} [5 > 4]

func Ternary(statement bool, a, b interface{}) interface{} {
    if statement {
        return a
    }
    return b
}

func Abs(n int) int {
    return Ternary(n >= 0, n, -n).(int)
}

สิ่งนี้จะไม่ดีกว่าหาก / และต้องใช้การส่ง แต่ใช้งานได้ FYI:

BenchmarkAbsTernary-8 100000000 18.8 ns / op

BenchmarkAbsIfElse-8 2000000000 0.27 ns / op

หากทุกสาขาของคุณให้ผลข้างเคียงหรือคอมพิวเตอร์ที่มีราคาแพงต่อไปนี้จะความหมายรักษา refactoring:

index := func() int {
    if val > 0 {
        return printPositiveAndReturn(val)
    } else {
        return slowlyReturn(-val)  // or slowlyNegate(val)
    }
}();  # exactly one branch will be evaluated

โดยปกติแล้วจะไม่มีค่าใช้จ่าย (inlined) และที่สำคัญที่สุดคือโดยไม่ต้องยุ่งกับ namespace ของคุณด้วยฟังก์ชั่นตัวช่วยที่ใช้เพียงครั้งเดียวเท่านั้น ตัวอย่างสด

หมายเหตุหากคุณต้องใช้แนวทางของกุสตาโวอย่างไร้เดียงสา:

    index := printPositiveAndReturn(val);
    if val <= 0 {
        index = slowlyReturn(-val);  // or slowlyNegate(val)
    }

คุณจะได้รับโปรแกรมที่มีลักษณะการทำงานที่แตกต่างกัน ; ในกรณีที่val <= 0โปรแกรมจะพิมพ์ค่าที่ไม่เป็นบวกในขณะที่มันไม่ควร! (เหมือนกันถ้าคุณกลับสาขาคุณจะแนะนำค่าใช้จ่ายโดยการเรียกฟังก์ชั่นช้าโดยไม่จำเป็น)

คำนำ:หากปราศจากการโต้เถียงนั่นif elseคือหนทางที่จะไปเรายังคงสามารถเล่นและสนุกไปกับโครงสร้างที่ใช้ภาษาได้

โครงสร้างต่อไปนี้Ifมีอยู่ในgithub.com/icza/goxห้องสมุดของฉันพร้อมด้วยวิธีการอื่นbuiltinx.Ifมากมาย

ไปช่วยให้การแนบวิธีการใด ๆที่ผู้ใช้กำหนดชนิดboolรวมทั้งรูปแบบดั้งเดิมเช่น เราสามารถสร้างประเภทที่กำหนดเองที่มีประเภทพื้นฐานboolของมันแล้วด้วยการแปลงประเภทที่เรียบง่ายกับเงื่อนไขเราสามารถเข้าถึงวิธีการของมัน วิธีการที่รับและเลือกจากตัวถูกดำเนินการ

บางสิ่งเช่นนี้

type If bool

func (c If) Int(a, b int) int {
    if c {
        return a
    }
    return b
}

เราจะใช้มันอย่างไร?

i := If(condition).Int(val1, val2)  // Short variable declaration, i is of type int
     |-----------|  \
   type conversion   \---method call

ตัวอย่างประกอบไปด้วยmax():

i := If(a > b).Int(a, b)

ประกอบไปด้วยabs():

i := If(a >= 0).Int(a, -a)

สิ่งนี้ดูเท่ห์เรียบง่ายสง่างามและมีประสิทธิภาพ (นอกจากนี้ยังมีสิทธิ์ได้รับการอินไลน์ )

ข้อเสียหนึ่งเมื่อเทียบกับผู้ประกอบการที่ "จริง": มันจะประเมินตัวถูกดำเนินการทั้งหมด

เพื่อให้บรรลุถึงการประเมินผลที่เลื่อนออกไปและจำเป็นเพียงอย่างเดียวตัวเลือกเดียวคือการใช้ฟังก์ชั่น ( ฟังก์ชั่นที่ประกาศไว้หรือวิธีการหรือตัวอักษรฟังก์ชั่น ) ซึ่งจะเรียกว่าเมื่อ / หากต้องการ:

func (c If) Fint(fa, fb func() int) int {
    if c {
        return fa()
    }
    return fb()
}

ใช้มัน: สมมติว่าเรามีฟังก์ชั่นเหล่านี้ในการคำนวณaและb:

func calca() int { return 3 }
func calcb() int { return 4 }

แล้ว:

i := If(someCondition).Fint(calca, calcb)

ตัวอย่างเช่นเงื่อนไขเป็นปีปัจจุบัน> 2020:

i := If(time.Now().Year() > 2020).Fint(calca, calcb)

หากเราต้องการใช้ตัวอักษรฟังก์ชั่น:

i := If(time.Now().Year() > 2020).Fint(
    func() int { return 3 },
    func() int { return 4 },
)

หมายเหตุสุดท้าย: หากคุณมีฟังก์ชั่นที่มีลายเซ็นที่แตกต่างกันคุณไม่สามารถใช้งานได้ที่นี่ ในกรณีนี้คุณอาจใช้ฟังก์ชันตามตัวอักษรพร้อมลายเซ็นการจับคู่เพื่อให้ยังคงใช้ได้

ตัวอย่างเช่นหากcalca()และcalcb()จะมีพารามิเตอร์ด้วย (นอกเหนือจากค่าส่งคืน):

func calca2(x int) int { return 3 }
func calcb2(x int) int { return 4 }

นี่คือวิธีที่คุณสามารถใช้:

i := If(time.Now().Year() > 2020).Fint(
    func() int { return calca2(0) },
    func() int { return calcb2(0) },
)

ลองตัวอย่างเหล่านี้บนไปสนามเด็กเล่น

คำตอบของ eold นั้นน่าสนใจและสร้างสรรค์บางทีก็ฉลาด

อย่างไรก็ตามขอแนะนำให้ทำแทน:

var index int
if val > 0 {
    index = printPositiveAndReturn(val)
} else {
    index = slowlyReturn(-val)  // or slowlyNegate(val)
}

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

โดยพื้นฐานแล้วโค้ดที่ง่ายและชัดเจนดีกว่าโค้ดโฆษณา

นอกจากนี้รหัสใด ๆ ที่ใช้ตัวอักษรของแผนที่ไม่ใช่ความคิดที่ดีเพราะแผนที่นั้นไม่เบาเลยใน Go ตั้งแต่ Go 1.3 รับประกันการสุ่มซ้ำสำหรับแผนที่ขนาดเล็กและเพื่อบังคับใช้สิ่งนี้จึงได้รับหน่วยความจำที่มีประสิทธิภาพน้อยกว่าสำหรับแผนที่ขนาดเล็ก

ด้วยเหตุนี้การสร้างและลบแผนที่ขนาดเล็กจำนวนมากจึงใช้พื้นที่และใช้เวลานาน ฉันมีชิ้นส่วนของรหัสที่ใช้แผนที่ขนาดเล็ก (สองหรือสามปุ่มมีแนวโน้ม แต่กรณีการใช้งานทั่วไปเป็นเพียงรายการเดียว) แต่รหัสนั้นช้ามาก เรากำลังพูดถึงคำสั่งอย่างน้อย 3 คำสั่งที่ช้ากว่ารหัสเดิมที่เขียนขึ้นใหม่เพื่อใช้คีย์สไลซ์คู่ [ดัชนี] => ข้อมูล [ดัชนี] แผนที่ และมีโอกาสมากขึ้น เนื่องจากการดำเนินการบางอย่างที่ก่อนหน้านี้ใช้เวลาสองสามนาทีในการทำงานจึงเริ่มทำให้เสร็จในเสี้ยววินาที

หนึ่งตอร์ปิโดแม้รังเกียจโดยผู้สร้างมีสถานที่ของพวกเขา

อันนี้แก้ปัญหาการประเมินผลที่ขี้เกียจโดยให้คุณผ่านการประเมินฟังก์ชั่นถ้าจำเป็น:

func FullTernary(e bool, a, b interface{}) interface{} {
    if e {
        if reflect.TypeOf(a).Kind() == reflect.Func {
            return a.(func() interface{})()
        }
        return a
    }
    if reflect.TypeOf(b).Kind() == reflect.Func {
        return b.(func() interface{})()
    }
    return b
}

func demo() {
    a := "hello"
    b := func() interface{} { return a + " world" }
    c := func() interface{} { return func() string { return "bye" } }
    fmt.Println(FullTernary(true, a, b).(string)) // cast shown, but not required
    fmt.Println(FullTernary(false, a, b))
    fmt.Println(FullTernary(true, b, a))
    fmt.Println(FullTernary(false, b, a))
    fmt.Println(FullTernary(true, c, nil).(func() string)())
}

เอาท์พุต

hello
hello world
hello world
hello
bye

• ฟังก์ชั่นที่ส่งผ่านจะต้องส่งคืนinterface{}เพื่อตอบสนองการดำเนินการร่ายภายใน
• ขึ้นอยู่กับบริบทคุณอาจเลือกที่จะแปลงผลลัพธ์เป็นชนิดเฉพาะ
• cถ้าคุณอยากจะกลับฟังก์ชั่นจากนี้คุณจะต้องห่อมันเป็นแสดงด้วย

โซลูชันแบบสแตนด์อโลนที่นี่ก็ดี แต่อาจมีความชัดเจนน้อยลงสำหรับการใช้งานบางอย่าง