Что такое идиоматический эквивалент Go тернарного оператора 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)

Компилятор встроит такие простые функции, поэтому он быстрее, понятнее и короче.

No Go не имеет троичного оператора, использование синтаксиса 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 нс / оп

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 .

Ответ Эольда интересный и креативный, возможно, даже умный.

Тем не менее, рекомендуется вместо этого сделать:

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

Да, они оба компилируются по существу в одну и ту же сборку, однако этот код гораздо более разборчив, чем вызов анонимной функции только для того, чтобы вернуть значение, которое могло быть записано в переменную в первую очередь.

По сути, простой и понятный код лучше творческого кода.

Кроме того, любой код, использующий литерал карты, не является хорошей идеей, поскольку карты на Go совсем не легки. Начиная с Go 1.3, случайный порядок итераций для маленьких карт гарантирован, и для обеспечения этого он стал немного менее эффективным с точки зрения памяти для маленьких карт.

В результате создание и удаление многочисленных небольших карт занимает много места и времени. У меня был кусок кода, в котором использовалась небольшая карта (скорее всего, два или три ключа, но в общем случае использовалась только одна запись) Но код был слишком медленным. Мы говорим как минимум на 3 порядка медленнее, чем тот же код, переписанный для использования карты двойного ключа [index] => data [index]. И скорее всего было больше. Поскольку некоторые операции, которые раньше выполнялись за пару минут, начали выполняться за миллисекунды. \

Однострочники, хотя создатели избегают их, имеют свое место.

Это решает проблему отложенной оценки, позволяя вам, при необходимости, передавать функции для оценки при необходимости:

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.

Автономное решение здесь также хорошо, но может быть менее понятным для некоторых применений.