mirror of
https://github.com/fenom-template/fenom.git
synced 2023-08-10 21:13:07 +03:00
Add operator doc [ru]
This commit is contained in:
bzick
parent
0ff3ffc27f
commit
0b96a02dd9
@ -18,36 +18,61 @@
|
||||
|
||||
### Логические операторы
|
||||
|
||||
* `$a || $b` - логичесое ИЛИ
|
||||
* `$a && $b` - лигическое И
|
||||
* `!$a` - отрицание, унарный оператор
|
||||
* `$a or $b` - логическое ИЛИ
|
||||
* `$a and $b` - логическое И
|
||||
* `$a xor $b` - xor, логическое сложение
|
||||
* `$a || $b` - логичесое ИЛИ, TRUE если или `$a`, или `$b` TRUE.
|
||||
* `$a && $b` - лигическое И, TRUE если и `$a`, и `$b` TRUE.
|
||||
* `!$a` - отрицание, TRUE если `$a` не TRUE.
|
||||
* `$a or $b` - логическое ИЛИ, TRUE если или `$a`, или `$b` TRUE.
|
||||
* `$a and $b` - логическое И, TRUE если и `$a`, и `$b` TRUE.
|
||||
* `$a xor $b` - исключающее или, TRUE если `$a`, или `$b` TRUE, но не оба.
|
||||
|
||||
```smarty
|
||||
{if $b && $c} ... {/if}
|
||||
```
|
||||
|
||||
Смысл двух разных вариантов для операторов `and` и `or` в том, что они работают с различными приоритетами.
|
||||
|
||||
### Операторы сравнения
|
||||
|
||||
* `$a < $b` - строгое неравество, `$a` меньше `$b`
|
||||
* `$a > $b` - строгое неравество, `$a` больше `$b`
|
||||
* `$a <= $b` - не строгое не равество, `$a` меньше или равно `$b`
|
||||
* `$a >= $b` - не строгое не равество, `$a` больше или равно `$b`
|
||||
* `$a == $b` - Равно, `$a` равно `$b`
|
||||
* `$a === $b` - Тождественно равно, `$a` иденично `$b`. Отличается от равества тем что проверяет так же тип значений; если '0' == 0 — истина, то уже '0' === 0 — ложно.
|
||||
* `$a !== $b` - не иденично, `$a` отличается от `$b`
|
||||
* `$a != $b` - неравенство, `$a` отличается от `$b`
|
||||
* `$a <> $b` - неравенство
|
||||
Операторы сравнения, как это видно из их названия, позволяют сравнивать между собой два значения.
|
||||
|
||||
* `$a < $b` - меньше, TRUE если `$a` строго меньше `$b`.
|
||||
* `$a > $b` - больше, TRUE если `$a` строго больше `$b`.
|
||||
* `$a <= $b` - меньше или равно, TRUE если `$a` меньше или равно `$b`.
|
||||
* `$a >= $b` - больше или равно, TRUE если `$a` больше или равно `$b`.
|
||||
* `$a == $b` - равно, TRUE если `$a` равно `$b` после преобразования типов.
|
||||
* `$a === $b` - тождественно равно, TRUE если `$a` равно `$b` и имеет тот же тип.
|
||||
* `$a !== $b` - тождественно не равно, TRUE если `$a` не равно `$b` или они разных типов.
|
||||
* `$a != $b` - не равно, TRUE если `$a` не равно `$b` после преобразования типов.
|
||||
* `$a <> $b` - не равно, TRUE если `$a` не равно `$b` после преобразования типов.
|
||||
|
||||
```smarty
|
||||
{if $b >= 5} ... {/if}
|
||||
```
|
||||
|
||||
В случае, если вы сравниваете число со строкой или две строки, содержащие числа, каждая строка будет преобразована в число, и сравниваться они будут как числа.
|
||||
|
||||
```smarty
|
||||
{if 0 == "a"} {* 0 == 0 -> true *} {/if}
|
||||
{if "1" == "01"} {* 1 == 1 -> true *} {/if}
|
||||
{if "10" == "1e1"} {* 10 == 10 -> true *} {/if}
|
||||
{if 100 == "1e2"} {* 100 == 100 -> true *} {/if}
|
||||
```
|
||||
|
||||
Преобразование типов не происходит при использовании `===` или `!==` так как в этом случае кроме самих значений сравниваются еще и типы.
|
||||
|
||||
**Таблица сравнения различных типов:**
|
||||
|
||||
| Тип операнда 1 | Тип операнда 2 | Результат |
|
||||
|-------------------|-------------------|-----------|
|
||||
| null или string | string | NULL преобразуется в "", числовое или лексическое сравнение |
|
||||
| bool или null | что угодно | Преобразуется в bool, FALSE < TRUE |
|
||||
| object | object | Встроенные классы могут определять свои собственные правила сравнения, объекты разных классов не сравниваются, объекты одного класса - сравниваются свойства тем же способом, что и в массивах |
|
||||
| string или number | string или number | Строки переводятся в числа, обычная математика |
|
||||
| array | array | Массивы с меньшим числом элементов считаются меньше, если ключ из первого операнда не найден во втором операнде - массивы не могут сравниваться, иначе идет сравнение соответствующих значений |
|
||||
| object | что угодно | object всегда больше |
|
||||
| array | что угодно | array всегда больше |
|
||||
|
||||
|
||||
### Побитовые операторы
|
||||
|
||||
Побитовые операторы позволяют считывать и устанавливать конкретные биты целых чисел.
|
||||
@ -63,84 +88,172 @@
|
||||
{if $a & 1} {var $b = 4 | $flags} {/if}
|
||||
```
|
||||
|
||||
### Assignment Operators
|
||||
### Оператор присваивания
|
||||
|
||||
* `$a = $b` - assignment
|
||||
* `$a += $b` - assignment with addition
|
||||
* `$a -= $b` - assignment with subtraction
|
||||
* `$a *= $b` - assignment with multiplication
|
||||
* `$a /= $b` - assignment with division
|
||||
* `$a %= $b` - assignment with modulus
|
||||
* `$a &= $b` - assignment with bitwise And
|
||||
* `$a |= $b` - assignment with bitwise or
|
||||
* `$a ^= $b` - assignment with bitwise xor
|
||||
* `$a <<= $b` - assignment with left shift
|
||||
* `$a >>= $b` - assignment with right shift
|
||||
Базовый оператор присваивания обозначается как `=`. На первый взгляд может показаться, что это оператор "равно".
|
||||
На самом деле это не так. В действительности, оператор присваивания означает, что левый операнд получает значение правого выражения,
|
||||
(т.е. устанавливается значением).
|
||||
|
||||
В дополнение к базовому оператору присваивания имеются "комбинированные операторы" для всех бинарных арифметических операций и строковых операций,
|
||||
которые позволяют использовать некоторое значение в выражении, а затем установить его как результат данного выражения.
|
||||
То есть выражение `$a = $a + 2` может быть записано как `$a += 2`.
|
||||
|
||||
* `$a = $b` - присвоение
|
||||
* `$a += $b` - присвоение с добалением.
|
||||
* `$a -= $b` - присвоение с вычитанием.
|
||||
* `$a *= $b` - присвоение с умножением.
|
||||
* `$a /= $b` - присвоение с делением.
|
||||
* `$a %= $b` - присвоение с делением по модулю.
|
||||
* `$a &= $b` - присвоение с битовыйм И.
|
||||
* `$a |= $b` - присвоение с битовыйм ИЛИ.
|
||||
* `$a ^= $b` - присвоение с битовыйм исключением ИЛИ
|
||||
* `$a <<= $b` - присвоение с битовым сдвигом влево.
|
||||
* `$a >>= $b` - присвоение с битовым сдвигом врпаво.
|
||||
|
||||
|
||||
```smarty
|
||||
{var $b |= $flags}
|
||||
```
|
||||
|
||||
### Incrementing/Decrementing operators
|
||||
### Операторы инкремента и декремента
|
||||
|
||||
* `++$a` - increment the variable and use it
|
||||
* `$a++` - use the variable and increment it
|
||||
* `--$a` - decrement the variable and use it
|
||||
* `$a--` - use the variable and decrement it
|
||||
Fenom поддерживает префиксные и постфиксные операторы инкремента и декремента в стиле PHP или C.
|
||||
|
||||
### String operator
|
||||
**Замечание:**
|
||||
Операторы инкремента/декремента не влияют на булевы значения. Декремент NULL также не даст никакого эффекта, однако инкремент даст значение 1.
|
||||
|
||||
* `$a ~ $b` - return concatenation of variables `$a` and `$b`
|
||||
* `++$a` - префиксный инкремент, увеличивает $a на единицу, затем возвращает значение $a.
|
||||
* `$a++` - постфиксный инкремент, возвращает значение $a, затем увеличивает $a на единицу.
|
||||
* `--$a` - префиксный декремент, уменьшает $a на единицу, затем возвращает значение $a.
|
||||
* `$a--` - постфиксный декремент, возвращает значение $a, затем уменьшает $a на единицу.
|
||||
|
||||
### Ternary operators
|
||||
### Строковый оператор
|
||||
|
||||
* `$a ? $b : $c` - returns `$b` if `$a` is not empty, and `$c` otherwise
|
||||
* `$a ! $b : $c` - returns `$b` if `$a` is set, and `$c` otherwise
|
||||
* `$a ?: $c` - returns `$a` if `$a` is not empty, and `$c` otherwise
|
||||
* `$a !: $c` - returns `$a` if `$a` is set, and `$c` otherwise
|
||||
Оператор конкатенации `~` возвращает строку, представляющую собой соединение левого и правого аргумента.
|
||||
|
||||
`$a ~ $b` - возвращает результат объединения сток `$a` и `$b`
|
||||
|
||||
### Тернарные операторы
|
||||
|
||||
Еще одним условным оператором являются тернарные операторы `?:` и `!:`.
|
||||
Выражения `(expr1) ? (expr2) : (expr3)` и `(expr1) ! (expr2) : (expr3)` интерпретируется как `expr2`, если `expr1` имеет значение TRUE, или как `expr3` если `expr1` имеет значение FALSE.
|
||||
|
||||
Тернарый оператор `?:` проверяет условие `expr1` на не "пустое" значение, то есть `expr1` при конвертирование в булевое значение должен вернуть TRUE.
|
||||
Следующие значения воспринимаются как пустые:
|
||||
|
||||
* "" (пустая строка)
|
||||
* 0 (целое число)
|
||||
* 0.0 (дробное число)
|
||||
* "0" (строка)
|
||||
* NULL
|
||||
* FALSE
|
||||
* array() (пустой массив)
|
||||
* переменная не объявлена
|
||||
* элемента массива не существует
|
||||
* свойство объекта не существует
|
||||
|
||||
```smarty
|
||||
{$request.action ? $request.action : 'default'}
|
||||
```
|
||||
|
||||
Пример выше стоит интерпретировать так: если `$request.action` не пустое то вернуть `$request.action` иначе вернуть `default`.
|
||||
Приведенный пример можно записать в упрощенном формате:
|
||||
```smarty
|
||||
{$request.action ?: 'default'}
|
||||
```
|
||||
|
||||
Тернарый оператор `?:` проверяет условие `expr1` на существование и относится больше к работе с переменными,
|
||||
то есть переменная в выражении `expr1` должна существовать даже если она "пустая", но не NULL.
|
||||
Данный оператор не имеет значения если `expr1` функция или метод, так как в этом случае всегда будет TRUE.
|
||||
|
||||
```smarty
|
||||
{$request.action ! $request.action : 'default'}
|
||||
```
|
||||
Пример выше стоит интерпретировать так: если переменна я `$request` существует, является массивом и существует ключ `$request.action` то вернуть `$request.action` иначе вернуть `default`.
|
||||
Приведенный пример можно записать в упрощенном формате:
|
||||
```smarty
|
||||
{$request.action !: 'default'}
|
||||
```
|
||||
|
||||
Как видно, оператор `:?` более расширенный чем `:!` и включает в себя функциональность опертора `!:`.
|
||||
|
||||
Для упрощения понимания можно подвести итог:
|
||||
|
||||
* `$a ? $b : $c` - вернет `$b` если `$a` не пустое, иначе вернет `$c`.
|
||||
* `$a ! $b : $c` - вернет `$b` если `$a` существует, иначе вернет `$c`.
|
||||
* `$a ?: $c` - вернет `$a` если `$a` не пустое, иначе вернет `$b`.
|
||||
* `$a !: $c` - вернет `$a` если `$a` существует, иначе вернет `$b`.
|
||||
|
||||
```smarty
|
||||
{var $a = true}
|
||||
{$a ? 5 : 10} {* outputs 5 *}
|
||||
{$a ? 5 : 10} {* вернет 5 *}
|
||||
{var $a = false}
|
||||
{$a ? 5 : 10} {* outputs 10 *}
|
||||
{$a ? 5 : 10} {* вернет 10 *}
|
||||
```
|
||||
|
||||
### Check operators
|
||||
### Операторы проверки
|
||||
|
||||
* `$a?` - returns `TRUE` if `$a` is not empty
|
||||
* `$a!` - returns `TRUE` if `$a` is set
|
||||
Оператор проверки это упрощенный тернарный оператор от которого осталась только часть проверки без возвращаемых вариантов.
|
||||
Суть операторов — быстро произвести проверку на не пустое занчение и существование пременной.
|
||||
|
||||
* `$a?` - вернет `TRUE` если `$a` не пустое
|
||||
* `$a!` - вернет `TRUE` если `$a` существует
|
||||
|
||||
```smarty
|
||||
{if $a?} {* instead of {if !empty($a)} *}
|
||||
{if $a!} {* instead of {if isset($a)} *}
|
||||
{$a?:"some text"} {* instead of {if empty($a) ? "some text" : $a} *}
|
||||
{$a!:"some text"} {* instead of {if isset($a) ? $a : "some text"} *}
|
||||
{if $a?} {* вместо {if !empty($a)} *}
|
||||
{if $a!} {* вместо {if isset($a)} *}
|
||||
```
|
||||
|
||||
### Test operator
|
||||
### Оператор тестирования
|
||||
|
||||
Tests can be negated by using the `is not` operator.
|
||||
Оператор `is` производит тесты над перменными или выражением. Левый операнд считается тестируемым, а правый операнд — название теста:
|
||||
|
||||
* `$a is $b` - $a identical $b
|
||||
* `$a is integer` - test variable type. Type may be int/integer, bool/boolean, float/double/decimal, array, object, scalar, string, callback/callable, number/numeric.
|
||||
* `$a is iterable` - test variable for iteration.
|
||||
* `$a is template` - variable `$a` contain existing template name.
|
||||
* `$a is empty` - checks if a variable is empty.
|
||||
* `$a is set` - checks if a variable is set.
|
||||
* `$a is even` - variable `$a` is even.
|
||||
* `$a is odd` - variable `$a` is odd.
|
||||
* `$a is MyClass` or `$a is \MyClass` - variable `$a` instance of `MyClass` class
|
||||
```smarty
|
||||
{* проверка переменной на не четность *}
|
||||
|
||||
### Containment operator
|
||||
{$a is odd}
|
||||
```
|
||||
|
||||
Tests can be negated by using the `not in` operator.
|
||||
Результат тестирования может быть инвертирован с помощью `is not` оператора:
|
||||
|
||||
* `$a in $b` - variable `$a` contains in `$b`, $b may be string, plain or assoc array.
|
||||
* `$a in list $b` - variable `$a` contains in array `$b` as value
|
||||
* `$a in keys $b` - array `$b` contain key `$a`
|
||||
* `$a in string $b` - variable `$a` contains in string `$b` as substring
|
||||
```smarty
|
||||
{* проверяем переменную что ее значение не явдяется числом *}
|
||||
|
||||
{$a is not integer}
|
||||
```
|
||||
|
||||
Список допустимых тестов:
|
||||
|
||||
* `$a is integer` - тестирует перменную на тип. Тестом может быть
|
||||
* `int`, `integer` — целое число
|
||||
* `bool`, `boolean` — булево значение
|
||||
* `float`, `double`, `decimal` - дробное число
|
||||
* `array` — массив
|
||||
* `object` — объект
|
||||
* `scalar` — скалярное значение (не массив и не объект)
|
||||
* `string` — строка
|
||||
* `callback`, `callable` — функция
|
||||
* `number`, `numeric` — число, в общем понимании
|
||||
* `$a is iterable` - тестирует переменную на возможность итеративного обхода.
|
||||
* `$a is template` - переменная `$a` содержит название существующего шаблона.
|
||||
* `$a is empty` - переменная пустая.
|
||||
* `$a is set` - переменная существует.
|
||||
* `$a is even` - переменная `$a` имеет четное значение.
|
||||
* `$a is odd` - переменная `$a` имеет не четное значение.
|
||||
* `$a is MyClass` или `$a is \MyClass` - переменная `$a` является сущностью класса `MyClass`
|
||||
* `$a is $b` - `$a` тождественна `$b`
|
||||
|
||||
### Оператор присутствия
|
||||
|
||||
Оператор `in` проверяет присутвие скалярного значения слева в массиве или строке справа.
|
||||
Результат тестирования может быть инвертирован с помощью `not ni` оператора.
|
||||
|
||||
* `$a in list $b` - значение `$a` содержится в массиве значений `$b`
|
||||
* `$a in keys $b` - массив `$b` имеет ключ `$a`
|
||||
* `$a in string $b` - значение `$a` содержится в `$b` как подстрока.
|
||||
* `$a in $b` - значение `$a` содержится в `$b`, где `$b` может быть строкой, обычным или ассоциативным массивом.
|
||||
Этот вариант долгий так как требуется проверить типы переменной `$b`.
|
||||
Однако если вместо $b явно задан массив иили строка то оператор сам адаптируется для быстрого поиска.
|
||||
|
||||
```smarty
|
||||
{'df' in 'abcdefg'}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user