Який ідіоматичний Go еквівалент потрійного оператора С?

У 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)

Компілятор вбудує такі прості функції, тому він швидший, зрозуміліший і коротший.

No Go не має потрійного оператора, використовуючи синтаксис if / else - ідіоматичний спосіб.

Чому Go не має оператора ?:

У Гоу не проводиться потрійне тестування. Ви можете використовувати наступне, щоб досягти того ж результату:

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

Причина ?: Go відсутня в тому, що дизайнери мови бачили, що операція використовується занадто часто для створення непрохідно складних виразів. if-elseФорми, хоча більше, безперечно ясніше. Мові потрібна лише одна конструкція потоку умовного керування.

- Часті питання (FAQ) - Мова програмування Go

Припустимо, у вас є такий потрійний вираз (в С):

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)
}

Це не буде перевершувати, якщо / else і вимагає акторського складу, але працює. FYI:

BenchmarkAbsTernary-8 100000000 18,8 нс / оп

BenchmarkAbsIfElse-8 2000000000 0,27 нс / оп

Якщо всі ваші гілки роблять побічні ефекти або обчислюють обчислювальною чисельністю, таке рефакторинг, що зберігає семантичний характер, буде наступним :

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

як правило, без накладних витрат (накреслених) і, що найголовніше, не захаращуючи свій простір імен допоміжними функціями, які використовуються лише один раз (що перешкоджає читанню та обслуговуванню). Живий приклад

Зауважте, якби ви наївно застосовували підхід Густаво :

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

ви отримаєте програму з іншою поведінкою ; у випадку, якщо val <= 0програма надрукує непозитивне значення, тоді як вона не повинна! (Аналогічно, якщо ви перевернули гілки, ви введете накладні витрати, викликаючи повільну функцію без потреби.)

Передмова: Не сперечаючись, що if elseце шлях, ми все ще можемо грати і знаходити задоволення в мовних конструкціях.

Наступна Ifконструкція доступна в моїй github.com/icza/goxбібліотеці з багатьма іншими методами, як builtinx.Ifтип.

Go дозволяє приєднувати методи до будь -яких визначених користувачем типів , включаючи примітивні типи, такі як 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) },
)

Спробуйте ці приклади на майданчику Go .

Відповідь eold цікава та творча, можливо, навіть розумна.

Однак рекомендується замість цього зробити:

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

Так, вони обоє складаються до однієї і тієї ж збірки, однак цей код набагато розбірливіший, ніж викликати анонімну функцію просто для повернення значення, яке могло б бути записане в змінну в першу чергу.

В основному, простий і зрозумілий код краще, ніж творчий код.

Окрім того, будь-який код, що використовує літеральну карту, не є гарною ідеєю, оскільки в Go Go карти зовсім не легкі. Починаючи з Go 1.3, порядок ітерації для випадкових малих карт гарантується, і для забезпечення цього він стає досить менш ефективним для пам'яті для малих карт.

Як результат, виготовлення та вилучення численних малих карт є трудомістким та трудомістким. У мене був фрагмент коду, який використовував невелику карту (два-три ключі, ймовірно, але звичайний випадок використання був лише одним записом) Але код був собачим повільним. Ми говоримо щонайменше на 3 порядки повільніше, ніж той самий код, переписаний для використання подвійного ключа зрізу [index] => data [index] map. І, ймовірно, було більше. Оскільки деякі операції, які раніше займали пару хвилин, почали завершуватися через мілісекунди. \

Однокласники, хоч і уникають творців, мають своє місце.

Цей вирішує проблему з ледачим оцінкою, дозволяючи вам, при необхідності, передавати функції для оцінки, якщо це необхідно:

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

• Функції, що передаються, повинні повернути a, interface{}щоб задовольнити внутрішню операцію кастингу.
• Залежно від контексту, ви можете обрати вихід на певний тип.
• Якщо ви хочете повернути функцію з цього, вам потрібно буде обернути її, як показано c.

Окреме рішення тут також приємне, але може бути менш зрозумілим для деяких застосувань.