---
metadata:
  - name: generator
    content: Diplodoc Platform v5.50.3
alternate:
  - https://divkit.tech/docs/en/concepts/expression-dsl.md
  - https://divkit.tech/docs/ru/concepts/expression-dsl.md
---
> **Documentation Index:** Fetch the complete configuration index at https://divkit.tech/docs/ru/llms.txt

# DivKit Expression DSL

## Основные понятия

* Expression<T> — базовый тип выражения с результатом T.
  * build(): String — строит «внутреннее» выражение DivKit без оболочки "@{…}".
  * compile(): String — оборачивает в "@{…}" для сериализации в JSON.
* Типы выражений:
  * Литералы типов `integer`, `number`, `string` и `boolean`.
  * Переменные `Var<T>`, создаются из строки-имени.
  * Арифметические операции: унарный минус `-`, сложение `+`, вычитание `-`, умножение `*`, деление `/`, остаток от деления `%`
  * Логические операции: отрицание `!`, логическое и `and`, логическое или `or`.
  * Сравнение: равенство `equalTo`, неравенство `notEqualTo`, больше `moreThan`, меньше `lessThan`, больше или равно `moreThanOrEqualTo`, меньше или равно `lessThanOrEqualTo`.
  * Конкатенация строк `+`.
  * Тернарный оператор `ifElse`.
  * Try-оператор `tryExpression`.
  * Вызов функции `functionName(args...)`.
* Скобки и экранирование:
  * Вложенные инфиксные выражения, тернарные и literal-вставки автоматически заключаются в скобки при необходимости.
  * Строковые литералы берутся в одинарные кавычки; апостроф экранируется как '.
  * Для number всегда есть десятичная точка (например, 1 → 1.0).
  * Отрицательные числа печатаются как (-1), (-2.5).

**Важно**: не вызывайте compile() внутри других build’ов — это сломает экранирование строк.

## Литералы

Целые числа
* `val one: Expression<Long> = 1.integer()`
* `val one: Expression<Long> = 1L.integer()`

Числа с плавающей точкой
* `val one: Expression<Double> = 1.number()`
* `val one: Expression<Double> = 1L.number()`
* `val one: Expression<Double> = 1.0f.number()`
* `val one: Expression<Double> = 1.0.number()`

**Важно:** десятичная точка всегда сохраняется (например, 1 → 1.0).

Строки
* `val text: Expression<String> = "text".string()`

**Экранирование:** `"O'Reilly".string()` даст результат `"'O\'Reilly'"`

Логический тип
* `val isTrue: Expression<String> = true.boolean()`
* `val isFalse: Expression<String> = false.boolean()`

Использование готового выражения
* `val expr = "1 + 2".literalExpression<Long>()`

## Переменные

Обращение к переменной:
* `val exprVariable: Var<Boolean> = "variable_name".booleanVariable()`
* `val exprVariable: Var<String> = "variable_name".stringVariable()`
* `val exprVariable: Var<Double> = "variable_name".numberVariable()`
* `val exprVariable: Var<Long> = "variable_name".integerVariable()`
* `val exprVariable: Var<Url> = "variable_name".urlVariable()`
* `val exprVariable>(): Var<Map<String, Any>> = "variable_name".dictVariable<Any>()`
* `val exprVariable: Var<Long> = "variable_name".datetimeVariable()`
* `val exprVariable>(): Var<List<Any>> = "variable_name".arrayVariable<Any>()`
* `val exprVariable: Var<String> = "variable_name".colorVariable()`

## Арифметические операции

Включает префиксный унарный минус, числовые операции и конкатенацию строк.

### Префиксный унарный минус

#### operator fun Expression\<Long\>.unaryMinus\(\): Expression\<Long\>

Пример:
```kotlin
val count = "count".integerVariable()
val result = -count
```

#### operator fun Expression\<Double\>.unaryMinus\(\): Expression\<Double\>

Пример:
```kotlin
val amount = "amount".numberVariable()
val result = -amount
```

### Сложение

#### operator fun Expression\<Long\>.plus\(other: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `operator fun Expression<Long>.plus(other: Int): Expression<Long>`
* `operator fun Expression<Long>.plus(other: Long): Expression<Long>`
* `operator fun Int.plus(other: Expression<Long>): Expression<Long>`
* `operator fun Long.plus(other: Expression<Long>): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a + b
```

#### operator fun Expression\<Double\>.plus\(other: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `operator fun Expression<Double>.plus(other: Double): Expression<Double>`
* `operator fun Expression<Double>.plus(other: Float): Expression<Double>`
* `operator fun Expression<Double>.plus(other: Int): Expression<Double>`
* `operator fun Expression<Double>.plus(other: Long): Expression<Double>`
* `operator fun Double.plus(other: Expression<Double>): Expression<Double>`
* `operator fun Float.plus(other: Expression<Double>): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a + b
```

### Вычитание

#### operator fun Expression\<Long\>.minus\(other: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `operator fun Expression<Long>.minus(other: Int): Expression<Long>`
* `operator fun Expression<Long>.minus(other: Long): Expression<Long>`
* `operator fun Int.minus(other: Expression<Long>): Expression<Long>`
* `operator fun Long.minus(other: Expression<Long>): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a - b
```

#### operator fun Expression\<Double\>.minus\(other: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `operator fun Expression<Double>.minus(other: Double): Expression<Double>`
* `operator fun Expression<Double>.minus(other: Float): Expression<Double>`
* `operator fun Expression<Double>.minus(other: Int): Expression<Double>`
* `operator fun Expression<Double>.minus(other: Long): Expression<Double>`
* `operator fun Double.minus(other: Expression<Double>): Expression<Double>`
* `operator fun Float.minus(other: Expression<Double>): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a - b
```

### Умножение

#### operator fun Expression\<Long\>.times\(other: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `operator fun Expression<Long>.times(other: Int): Expression<Long>`
* `operator fun Expression<Long>.times(other: Long): Expression<Long>`
* `operator fun Int.times(other: Expression<Long>): Expression<Long>`
* `operator fun Long.times(other: Expression<Long>): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a * b
```

#### operator fun Expression\<Double\>.times\(other: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `operator fun Expression<Double>.times(other: Double): Expression<Double>`
* `operator fun Expression<Double>.times(other: Float): Expression<Double>`
* `operator fun Expression<Double>.times(other: Int): Expression<Double>`
* `operator fun Expression<Double>.times(other: Long): Expression<Double>`
* `operator fun Double.times(other: Expression<Double>): Expression<Double>`
* `operator fun Float.times(other: Expression<Double>): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a * b
```

### Деление

#### operator fun Expression\<Long\>.div\(other: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `operator fun Expression<Long>.div(other: Int): Expression<Long>`
* `operator fun Expression<Long>.div(other: Long): Expression<Long>`
* `operator fun Int.div(other: Expression<Long>): Expression<Long>`
* `operator fun Long.div(other: Expression<Long>): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a / b
```

#### operator fun Expression\<Double\>.div\(other: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `operator fun Expression<Double>.div(other: Double): Expression<Double>`
* `operator fun Expression<Double>.div(other: Float): Expression<Double>`
* `operator fun Expression<Double>.div(other: Int): Expression<Double>`
* `operator fun Expression<Double>.div(other: Long): Expression<Double>`
* `operator fun Double.div(other: Expression<Double>): Expression<Double>`
* `operator fun Float.div(other: Expression<Double>): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a / b
```

### Остаток от целочисленного деления

#### operator fun Expression\<Long\>.rem\(other: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `operator fun Expression<Long>.rem(other: Int): Expression<Long>`
* `operator fun Expression<Long>.rem(other: Long): Expression<Long>`
* `operator fun Int.rem(other: Expression<Long>): Expression<Long>`
* `operator fun Long.rem(other: Expression<Long>): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a % b
```

#### operator fun Expression\<Double\>.rem\(other: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `operator fun Expression<Double>.rem(other: Double): Expression<Double>`
* `operator fun Expression<Double>.rem(other: Float): Expression<Double>`
* `operator fun Expression<Double>.rem(other: Int): Expression<Double>`
* `operator fun Expression<Double>.rem(other: Long): Expression<Double>`
* `operator fun Double.rem(other: Expression<Double>): Expression<Double>`
* `operator fun Float.rem(other: Expression<Double>): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a % b
```

### Конкатенация строк

#### operator fun Expression\<String\>.plus\(other: Expression\<String\>\): Expression\<String\>

Пример:
```kotlin
val hello = "Hello, ".string()
val username = "username".stringVariable()

val result = hello + username
```

## Логический операции

### Префиксное отрицание

#### operator fun Expression\<Boolean\>.not\(\): Expression\<Boolean\>

Пример:
```kotlin
val flag = "flag".booleanVariable()
val result = !flag
```

### Логическое И

#### infix fun Expression\<Boolean\>.and\(other: Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Boolean>.and(other: Boolean): Expression<Boolean>`
* `infix fun Boolean.and(other: Expression<Boolean>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a and b
```

### Логическое ИЛИ

#### infix fun Expression\<Boolean\>.or\(other: Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Boolean>.or(other: Boolean): Expression<Boolean>`
* `infix fun Boolean.or(other: Expression<Boolean>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a or b
```

## Операции сравнения

### Равенство

#### infix fun Expression\<Long\>.equalTo\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.equalTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.equalTo(other: Long): Expression<Boolean>`
* `infix fun Int.equalTo(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.equalTo(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a equalTo b
```

#### infix fun Expression\<Double\>.equalTo\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.equalTo(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.equalTo(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.equalTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.equalTo(other: Long): Expression<Boolean>`
* `infix fun Double.equalTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.equalTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.equalTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.equalTo(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a equalTo b
```

#### infix fun Expression\<String\>.equalTo\(other: Expression\<String\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<String>.equalTo(other: String): Expression<Boolean>`
* `infix fun String.equalTo(other: Expression<String>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".stringVariable()
val b = "b".stringVariable()

val result = a equalTo b
```

#### infix fun Expression\<Boolean\>.equalTo\(other: Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Boolean>.equalTo(other: Boolean): Expression<Boolean>`
* `infix fun Boolean.equalTo(other: Expression<Boolean>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a equalTo b
```

### Неравенство

#### infix fun Expression\<Long\>.notEqualTo\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.notEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.notEqualTo(other: Long): Expression<Boolean>`
* `infix fun Int.notEqualTo(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.notEqualTo(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a notEqualTo b
```

#### infix fun Expression\<Double\>.notEqualTo\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.notEqualTo(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.notEqualTo(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.notEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.notEqualTo(other: Long): Expression<Boolean>`
* `infix fun Double.notEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.notEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.notEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.notEqualTo(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a notEqualTo b
```

#### infix fun Expression\<String\>.notEqualTo\(other: Expression\<String\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<String>.notEqualTo(other: String): Expression<Boolean>`
* `infix fun String.notEqualTo(other: Expression<String>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".stringVariable()
val b = "b".stringVariable()

val result = a notEqualTo b
```

#### infix fun Expression\<Boolean\>.notEqualTo\(other: Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Boolean>.notEqualTo(other: Boolean): Expression<Boolean>`
* `infix fun Boolean.notEqualTo(other: Expression<Boolean>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a notEqualTo b
```

### Больше

#### infix fun Expression\<Long\>.moreThan\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.moreThan(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.moreThan(other: Long): Expression<Boolean>`
* `infix fun Int.moreThan(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.moreThan(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a moreThan b
```

#### infix fun Expression\<Double\>.moreThan\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.moreThan(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.moreThan(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.moreThan(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.moreThan(other: Long): Expression<Boolean>`
* `infix fun Double.moreThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.moreThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.moreThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.moreThan(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a moreThan b
```

### Больше или равно

#### infix fun Expression\<Long\>.moreThanOrEqualTo\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.moreThanOrEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.moreThanOrEqualTo(other: Long): Expression<Boolean>`
* `infix fun Int.moreThanOrEqualTo(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.moreThanOrEqualTo(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a moreThanOrEqualTo b
```

#### infix fun Expression\<Double\>.moreThanOrEqualTo\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.moreThanOrEqualTo(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.moreThanOrEqualTo(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.moreThanOrEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.moreThanOrEqualTo(other: Long): Expression<Boolean>`
* `infix fun Double.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a moreThanOrEqualTo b
```

### Меньше

#### infix fun Expression\<Long\>.lessThan\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.lessThan(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.lessThan(other: Long): Expression<Boolean>`
* `infix fun Int.lessThan(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.lessThan(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a lessThan b
```

#### infix fun Expression\<Double\>.lessThan\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.lessThan(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.lessThan(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.lessThan(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.lessThan(other: Long): Expression<Boolean>`
* `infix fun Double.lessThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.lessThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.lessThan(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.lessThan(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a lessThan b
```

### Меньше или равно

#### infix fun Expression\<Long\>.lessThanOrEqualTo\(other: Expression\<Long\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Long>.lessThanOrEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Long>.lessThanOrEqualTo(other: Long): Expression<Boolean>`
* `infix fun Int.lessThanOrEqualTo(other: Expression<Long>): Expression<Boolean>`
* `infix fun Long.lessThanOrEqualTo(other: Expression<Long>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a lessThanOrEqualTo b
```

#### infix fun Expression\<Double\>.lessThanOrEqualTo\(other: Expression\<Double\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Double>.lessThanOrEqualTo(other: Double): Expression<Boolean>`
* `infix fun Expression<Double>.lessThanOrEqualTo(other: Float): Expression<Boolean>`
* `infix fun Expression<Double>.lessThanOrEqualTo(other: Int): Expression<Boolean>`
* `infix fun Expression<Double>.lessThanOrEqualTo(other: Long): Expression<Boolean>`
* `infix fun Double.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Float.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Int.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`
* `infix fun Long.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a lessThanOrEqualTo b
```

## Условные операции

### Тернарный оператор

#### fun Expression\<Boolean\>.ifElse\(onMatch: Expression\<Long\>, onMismatch: Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `fun Expression<Boolean>.ifElse(onMatch: Expression<Long>, onMismatch: Int): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Expression<Long>, onMismatch: Long): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Expression<Long>): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Expression<Long>): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Int): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Long): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Long): Expression<Long>`
* `fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Int): Expression<Long>`

Пример:
```kotlin
val a = "a".integerVariable()
val b = "b".integerVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a + 20, b - a)
```

#### fun Expression\<Boolean\>.ifElse\(onMatch: Expression\<Double\>, onMismatch: Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `fun Expression<Boolean>.ifElse(onMatch: Expression<Double>, onMismatch: Float): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Expression<Double>, onMismatch: Double): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Expression<Double>): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Expression<Double>): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Int): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Long): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Float): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Double): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Int): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Long): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Float): Expression<Double>`
* `fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Double): Expression<Double>`

Пример:
```kotlin
val a = "a".numberVariable()
val b = "b".numberVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a + 20, b - a)
```

#### fun Expression\<Boolean\>.ifElse\(onMatch: Expression\<String\>, onMismatch: Expression\<String\>\): Expression\<String\>

Варианты перегрузки:
* `fun Expression<Boolean>.ifElse(onMatch: String, onMismatch: Expression<String>): Expression<String>`
* `fun Expression<Boolean>.ifElse(onMatch: Expression<String>, onMismatch: String): Expression<String>`
* `fun Expression<Boolean>.ifElse(onMatch: String, onMismatch: String): Expression<String>`

Пример:
```kotlin
val a = "a".booleanVariable()
val b = "b".booleanVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a and b, a or b)
```

#### fun Expression\<Boolean\>.ifElse\(onMatch: Expression\<Boolean\>, onMismatch: Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* ```
  fun Expression<Boolean>.ifElse(
    onMatch: Boolean,
    onMismatch: Expression<Boolean>
  ): Expression<Boolean>
  ```
* ```
  fun Expression<Boolean>.ifElse(
    onMatch: Expression<Boolean>,
    onMismatch: Boolean
  ): Expression<Boolean>
  ```
* `fun Expression<Boolean>.ifElse(onMatch: Boolean, onMismatch: Boolean): Expression<Boolean>`

Пример:
```kotlin
val success_message = "success_message".stringVariable()
val error_message = "error_message".stringVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(success_message, error_message)
```

### Try-оператор

Возвращает значение левого операнда, а при его вычислении произошла ошибка — значение правого операнда

#### infix fun Expression\<Long\>.tryExpression\(Expression\<Long\>\): Expression\<Long\>

Варианты перегрузки:
* `infix fun Expression<Long>.tryExpression(Int): Expression<Long>`
* `infix fun Expression<Long>.tryExpression(Long): Expression<Long>`
* `infix fun Int.tryExpression(Expression<Long>): Expression<Long>`
* `infix fun Long.tryExpression(Expression<Long>): Expression<Long>`
* `infix fun Int.tryExpression(Int): Expression<Long>`
* `infix fun Long.tryExpression(Long): Expression<Long>`

Пример:
```kotlin
val missingInt = "missing_int".integerVariable()
val result = missingInt tryExpression 0
```

#### infix fun Expression\<Double\>.tryExpression\(Expression\<Double\>\): Expression\<Double\>

Варианты перегрузки:
* `infix fun Expression<Double>.tryExpression(Double): Expression<Double>`
* `infix fun Expression<Double>.tryExpression(Float): Expression<Double>`
* `infix fun Double.tryExpression(Expression<Double>): Expression<Double>`
* `infix fun Float.tryExpression(Expression<Double>): Expression<Double>`
* `infix fun Float.tryExpression(Float): Expression<Double>`
* `infix fun Double.tryExpression(Double): Expression<Double>`

Пример:
```kotlin
val missingNumber = "missing_number".numberVariable()
val result = missingNumber tryExpression 0.0
```

#### infix fun Expression\<String\>.tryExpression\(Expression\<String\>\): Expression\<String\>

Варианты перегрузки:
* `infix fun Expression<String>.tryExpression(String): Expression<String>`
* `infix fun String.tryExpression(Expression<String>): Expression<String>`
* `infix fun String.tryExpression(String): Expression<String>`

Пример:
```kotlin
val missingString = "missing_string".stringVariable()
val result = missingString tryExpression "<missing>"
```

#### infix fun Expression\<Boolean\>.tryExpression\(Expression\<Boolean\>\): Expression\<Boolean\>

Варианты перегрузки:
* `infix fun Expression<Boolean>.tryExpression(Boolean): Expression<Boolean>`
* `infix fun Boolean.tryExpression(Expression<Boolean>): Expression<Boolean>`
* `infix fun Boolean.tryExpression(Boolean): Expression<Boolean>`

Пример:
```kotlin
val missingBoolean = "missing_boolean".booleanVariable()
val result = missingBoolean tryExpression false
```

## Вызов функций

Встроенные в DivKit функции описаны на [отдельной странице](https://divkit.tech/docs/ru/concepts/expression-dsl-functions.md).

#### function\<T\>\(functionName: String, vararg args: Expression\<\*\>\): Expression\<T\>

Позволяет использовать произвольную функцию, в том числе объявленную в верстке.

## Примеры использования

### Обращение к переменной

```kotlin
val username = "username".stringVariable()

val card = divan {
    data(
        logId = "variable_test",
        variables = listOf(
            divkitVariable(
                variable = username,
                value = "User"
            )
        ),
        div = text(
            fontSize = 16
        ).evaluate(
            text = ("Hello, ".string() + username).divanExpression()
        )
    )
}
```
Результат сериализации:
```json
{
  "card": {
    "log_id": "variable_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "@{'Hello, ' + greeting}",
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "string",
        "name": "username",
        "value": "User"
      }
    ]
  },
  "templates": {}
}
```

### Поддержка тем

```kotlin
const val THEME_LIGHT = "light"
const val THEME_DARK = "dark"

val theme = "theme".stringVariable()

val card = divan {
    data(
        logId = "theme_test",
        div = text(
            text = "Lorem ipsum",
            fontSize = 16
        ).evaluate(
            textColor = (theme equalTo THEME_LIGHT).ifElse(
                onMatch = "#000000".string(),
                onMismatch = "#FFFFFF".string()
            ).divanExpression()
        )
    )
}
```
Результат сериализации:
```json
{
  "card": {
    "log_id": "theme_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "Lorem ipsum",
          "font_size": 16,
          "text_color": "@{(theme == 'light') ? '#000000' : '#FFFFFF'}"
        }
      }
    ]
  },
  "templates": {}
}
```

### Вызов функции

```kotlin
val priceFormat = "#,###.##".string()
val locale = "ru-RU".string()
val price = "price".integerVariable()

val card = divan {
    data(
        logId = "function_call_test",
        variables = listOf(
            divkitVariable(
                variable = price,
                value = 1000
            )
        ),
        div = text(
            fontSize = 16
        ).evaluate(
            text = (decimalFormat(price, priceFormat, locale) + " ₽".string()).divanExpression()
        )
    )
}
```
Результат сериализации:
```json
{
  "card": {
    "log_id": "function_call_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "@{decimalFormat(price, '#,###.##', 'ru-RU') + ' ₽'}",
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "integer",
        "name": "price",
        "value": 1000
      }
    ]
  },
  "templates": {}
}
```

### Обновление значений переменных

```kotlin
val complexData = "complex_data".dictVariable<Any>()

val card = divan {
  data(
          logId = "variable_change_test",
          variables = listOf(
                  divkitVariable(
                          variable = complexData,
                          value = mapOf(
                                  "integer_param" to 10,
                                  "number_param" to 10.0,
                                  "string_param" to "Lorem ipsum",
                                  "boolean_param" to false
                          )
                  )
          ),
          div = text(
                  text = "Update data",
                  fontSize = 16,
                  actions = listOf(
                          action(
                                  logId = "update_integer_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "integer_param",
                                          value = integerValue(value = 20)
                                  )
                          ),
                          action(
                                  logId = "update_number_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "number_param",
                                          value = numberValue(value = 20.0)
                                  )
                          ),
                          action(
                                  logId = "update_string_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "string_param",
                                          value = stringValue(value = "Dolor sit amet")
                                  )
                          ),
                          action(
                                  logId = "update_boolean_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "boolean_param",
                                          value = booleanValue(value = true)
                                  )
                          )
                  )
          )
  )
}
```
Результат сериализации:
```json
{
  "card": {
    "log_id": "variable_change_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "Update data",
          "actions": [
            {
              "log_id": "update_integer_param",
              "typed": {
                "type": "dict_set_value",
                "key": "integer_param",
                "value": {
                  "type": "integer",
                  "value": 20
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_number_param",
              "typed": {
                "type": "dict_set_value",
                "key": "number_param",
                "value": {
                  "type": "number",
                  "value": 20.0
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_string_param",
              "typed": {
                "type": "dict_set_value",
                "key": "string_param",
                "value": {
                  "type": "string",
                  "value": "Dolor sit amet"
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_boolean_param",
              "typed": {
                "type": "dict_set_value",
                "key": "boolean_param",
                "value": {
                  "type": "boolean",
                  "value": 1
                },
                "variable_name": "complex_data"
              }
            }
          ],
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "dict",
        "name": "complex_data",
        "value": {
          "integer_param": 10,
          "number_param": 10.0,
          "string_param": "Lorem ipsum",
          "boolean_param": false
        }
      }
    ]
  },
  "templates": {}
}
```

***
<!-- source: ru/_includes/index/troubleshooting.md -->
## Узнать больше {#troubleshooting}

Вы можете обсуждать интересующие вас темы в сообществе пользователей DivKit в Telegram: [https://t.me/divkit_community_ru](https://t.me/divkit_community_ru).



[Репозиторий DivKit](https://github.com/divkit/divkit)




<!-- endsource: ru/_includes/index/troubleshooting.md -->