# Оценка выражений в рабочих процессах и действиях

Поиск сведений о выражениях в GitHub Actions.

## Литералы

В выражении можно использовать типы данных `boolean`, `null`, `number` и `string`.

| Тип данных         | Литеральное значение                                                                                                                                                                                                                                                                                                                      |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `boolean`          |                                                                                                                                                                                                                                                                                                                                           |
| `true` или `false` |                                                                                                                                                                                                                                                                                                                                           |
| `null`             | `null`                                                                                                                                                                                                                                                                                                                                    |
| `number`           | Любой числовой формат, поддерживаемый JSON.                                                                                                                                                                                                                                                                                               |
| `string`           | Заключать строки в скобки `${` и `}` необязательно. Однако если вы решите это сделать, используйте одинарные кавычки (`'`) вокруг строки. Чтобы использовать литерал в виде одинарной кавычки, экранируйте его с помощью дополнительной одинарной кавычки (`''`). Если заключить такой литерал в двойные кавычки (`"`), возникнет ошибка. |

Обратите внимание, что в условных, ложных значениях (`false`, , `0``-0``""`, `''`, ) `null`принудимы к `false` и правде (`true` и другие нефальсийные значения) принудимы к.`true`

### Пример литералы

```yaml
env:
  myNull: ${{ null }}
  myBoolean: ${{ false }}
  myIntegerNumber: ${{ 711 }}
  myFloatNumber: ${{ -9.2 }}
  myHexNumber: ${{ 0xff }}
  myExponentialNumber: ${{ -2.99e-2 }}
  myString: Mona the Octocat
  myStringInBraces: ${{ 'It''s open source!' }}
```

## Операторы

| Operator          | Description              |
| ----------------- | ------------------------ |
| `( )`             | Логическое группирование |
| `[ ]`             | Индекс                   |
| `.`               | Разыменование свойства   |
| `!`               | Not                      |
| `<`               | Меньше                   |
| `<=`              | Меньше или равно         |
| `>`               | Больше                   |
| `>=`              | Больше или равно         |
| `==`              | Equal                    |
| `!=`              | Не равно                 |
| `&&`              | And                      |
| <code>\|\|</code> | Or                       |

> \[!NOTE]
> \*
> GitHub игнорирует регистр при сравнении строк.
> \*
> `steps.<step_id>.outputs.<output_name>` вычисляется как строка.
> Чтобы в GitHub выражение вычислялось, а не считалось строкой, необходимо использовать особый синтаксис. Для получения дополнительной информации см. [Справочник по контекстам](/ru/enterprise-server@3.22/actions/reference/workflows-and-actions/contexts#steps-context).
>
> * Для числового сравнения `fromJSON()` функция может использоваться для преобразования строки в число. Дополнительные сведения о функции см. в `fromJSON()` разделе [fromJSON](#fromjson).

GitHub выполняет свободные сравнения равенства.

* Если типы не совпадают, GitHub принуживает тип к числу.
  GitHub Приводит типы данных к числу, используя следующие преобразования:

  | Тип        | Результат |
  | ---------- | --------- |
  | Null       | `0`       |
  | Логический |           |

`true` возвращает `1` <br />
`false` возвращает `0` |
\| Строка  | Преобразуется в любой допустимый числовой формат JSON, в противном случае дает значение `NaN`. <br /> Примечание. Для пустой строки возвращается `0`. |
\| Массив   | `NaN` |
\| Объект  | `NaN` |

* Если `NaN` один из операндов любого реляционного сравнения (`>`, , `<`, `>=`), `<=`результат всегда `false`. Дополнительные сведения см. в [документации](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN) NaN Mozilla.
* GitHub игнорирует регистр при сравнении строк.
* Объект и массив считаются равными, только если это один экземпляр.

## Функции

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

| Тип                    | Результат                                                    |
| ---------------------- | ------------------------------------------------------------ |
| Null                   | `''`                                                         |
| Логический             |                                                              |
| `'true'` или `'false'` |                                                              |
| Число                  | Десятичный формат, экспоненциальная запись для больших чисел |
| Массив                 | Массивы не преобразуются в строку                            |
| Объект                 | Объекты не преобразуются в строку                            |

### содержит

`contains( search, item )`

Возвращает `true`, если `search` содержит `item`. Если `search` является массивом, эта функция возвращает значение `true`, когда `item` является элементом в массиве. Если `search` является строкой, эта функция возвращает значение `true`, когда `item` является подстрокой `search`. В этой функции регистр не учитывается. Приводит значения к строковому типу.

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

`contains('Hello world', 'llo')` возвращает `true`.

#### Пример использования фильтра объектов

`contains(github.event.issue.labels.*.name, 'bug')` возвращает `true`, если проблема, связанная с событием, имеет метку "bug" (ошибка).

Дополнительные сведения см. в разделе ["Фильтры](#object-filters) объектов".

#### Пример сопоставления массива строк

Вместо записи `github.event_name == "push" || github.event_name == "pull_request"` можно использовать `contains()` с `fromJSON()`, чтобы проверить, содержит ли массив строк `item`.

Например, `contains(fromJSON('["push", "pull_request"]'), github.event_name)` возвращает `true`, если `github.event_name` имеет значение "push" или "pull\_request".

### startsWith

`startsWith( searchString, searchValue )`

Возвращает значение `true`, когда `searchString` начинается с `searchValue`. В этой функции регистр не учитывается. Приводит значения к строковому типу.

#### Пример `startsWith`

`startsWith('Hello world', 'He')` возвращает `true`.

### endsWith

`endsWith( searchString, searchValue )`

Возвращает значение `true`, если `searchString` заканчивается на `searchValue`. В этой функции регистр не учитывается. Приводит значения к строковому типу.

#### Пример `endsWith`

`endsWith('Hello world', 'ld')` возвращает `true`.

### format

`format( string, replaceValue0, replaceValue1, ..., replaceValueN)`

Заменяет значения в строке `string` на значение переменной `replaceValueN`. Переменные в `string` указываются с помощью синтаксиса `{N}`, где `N` является целым числом. Необходимо указать хотя бы одно значение `replaceValue` и `string`. Максимальное количество переменных (`replaceValueN`) не ограничивается. Чтобы указать фигурную скобку, экранируйте ее еще одной фигурной скобкой.

#### Пример `format`

```javascript
format('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat')
```

Возвращает «Hello Mona the Octocat».

#### Пример экранирования фигурных скобок

```javascript
format('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat')
```

Возвращает «{Hello Mona the Octocat!}».

### join

`join( array, optionalSeparator )`

Значением `array` может быть массив или строка. Все значения в `array` сцепляются в строку. Между сцепленными значениями вставляется разделитель `optionalSeparator`. Если он не указан, используется разделитель по умолчанию — `,`. Приводит значения к строковому типу.

#### Пример `join`

`join(github.event.issue.labels.*.name, ', ')` может вернуть «bug, help wanted» (ошибка, требуется помощь)

### toJSON

`toJSON(value)`

Возвращает значение `value` в правильном формате JSON. С помощью этой функции можно отлаживать данные, предоставленные в контекстах.

#### Пример `toJSON`

`toJSON(job)` может вернуть `{ "status": "success" }`

### fromJSON

`fromJSON(value)`

Возвращает объект JSON или тип данных JSON для `value`. Эту функцию можно использовать для предоставления объекта JSON в качестве вычисляемого выражения или преобразования любого типа данных, который может быть представлен в формате JSON или JavaScript, таких как строки, логические значения, значения NULL, массивы и объекты.

#### Пример возврата объекта JSON

Этот рабочий процесс задает матрицу JSON в одном задании и передает ее следующему заданию с помощью выходных данных и функции `fromJSON`.

```yaml copy
name: build
on: push
jobs:
  job1:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      - id: set-matrix
        run: echo "matrix={\"include\":[{\"project\":\"foo\",\"config\":\"Debug\"},{\"project\":\"bar\",\"config\":\"Release\"}]}" >> $GITHUB_OUTPUT
  job2:
    needs: job1
    runs-on: ubuntu-latest
    strategy:
      matrix: ${{ fromJSON(needs.job1.outputs.matrix) }}
    steps:
      - run: echo "Matrix - Project ${{ matrix.project }}, Config ${{ matrix.config }}"
```

#### Пример возврата типа данных JSON

Этот рабочий процесс с помощью функции `fromJSON` преобразует переменные среды из строки в логическое значение или целое число.

```yaml copy
name: print
on: push
env:
  continue: true
  time: 3
jobs:
  job1:
    runs-on: ubuntu-latest
    steps:
      - continue-on-error: ${{ fromJSON(env.continue) }}
        timeout-minutes: ${{ fromJSON(env.time) }}
        run: echo ...
```

Рабочий процесс использует `fromJSON()` функцию для преобразования переменной `continue` среды из строки в логическое значение, что позволяет определить, следует ли продолжить ошибку или нет. Аналогичным образом переменная среды преобразуется `time` из строки в целое число, задав время ожидания задания в минутах.

### hashFiles

`hashFiles(path)`

Возвращает один хэш для набора файлов по шаблону пути `path`. Вы можете указать один шаблон `path` или несколько шаблонов `path`, разделенных запятыми. Путь `path` указывается относительно каталога `GITHUB_WORKSPACE` и может включать только файлы внутри `GITHUB_WORKSPACE`. Эта функция вычисляет отдельный хэш SHA-256 для каждого подходящего файла, а затем с помощью этих хэшей вычисляет окончательный хэш SHA-256 для набора файлов. Если по шаблону `path` файлы отсутствуют, функция возвращает пустую строку. Дополнительные сведения о SHA-256 см. в статье [SHA-2](https://en.wikipedia.org/wiki/SHA-2).

Для сопоставления с именами файлов можно использовать подстановочные знаки. Сопоставление шаблонов для `hashFiles` соответствующих шаблонов глобов и не учитывает регистр в Windows. Дополнительные сведения о поддерживаемых символах сопоставления шаблонов[ см](https://www.npmjs.com/package/@actions/glob#patterns). в разделе "Шаблоны" документации`@actions/glob`.

#### Примеры с одним шаблоном

Соответствует любому файлу `package-lock.json` в репозитории.

`hashFiles('**/package-lock.json')`

Соответствует всем `.js` файлам в каталоге `src` на корневом уровне, но игнорирует все подкаталоги `src`.

`hashFiles('/src/*.js')`

Соответствует всем `.rb` файлам в каталоге на корневом `lib` уровне, включая все подкаталоги `lib`.

`hashFiles('/lib/**/*.rb')`

#### Примеры с несколькими шаблонами

Создает хэш для всех файлов `package-lock.json` и `Gemfile.lock` в репозитории.

`hashFiles('**/package-lock.json', '**/Gemfile.lock')`

Создает хэш для всех `.rb` файлов в каталоге `lib` на корневом уровне, включая все подкаталоги, но исключая `lib` файлы в подкаталоге`.rb``foo`.

`hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')`

## Функции проверки состояния

Следующие функции проверки состояния можно использовать в качестве выражений в условных операторах `if`. Если не включить ни одну из этих функций, применяется проверка состояния по умолчанию `success()`. Дополнительные сведения об условных выражениях см. в `if` разделе AUTOTITLE и \[AUTOTITLE[](/ru/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif).]\(/actions/reference/workflows-and-actions/metadata-syntax#runsstepsif)

Внешние `if` условные условия можно использовать `job.status` для доступа к состоянию задания. Дополнительные сведения см. в разделе [Справочник по контекстам](/ru/enterprise-server@3.22/actions/reference/workflows-and-actions/contexts#job-context).

### успешно

Возвращается `true` при успешном выполнении всех предыдущих шагов.

#### Пример `success`

```yaml
steps:
  ...
  - name: The job has succeeded
    if: ${{ success() }}
```

### всегда

Задает принудительное выполнение шага при любых обстоятельствах и возвращает значение `true` даже при отмене. Выражение `always` лучше всего использовать на уровне шага или в задачах, которые будут выполняться даже при отмене задания. Например, можно использовать `always` для отправки журналов даже при отмене задания.

> \[!WARNING]
> Избегайте использования `always` для любой задачи, которая может страдать от критического сбоя, например получение источников, в противном случае рабочий процесс может зависать до истечения времени ожидания. Если вы хотите запустить задание или шаг независимо от его успешного или неудачного выполнения, используйте рекомендуемую альтернативу: `if: ${{ !cancelled() }}`

#### Пример `always`

```yaml
if: ${{ always() }}
```

### cancelled

Возвращает значение `true`, если рабочий процесс был отменен.

#### Пример `cancelled`

```yaml
if: ${{ cancelled() }}
```

### сбой,

Возвращает значение `true`, если любой предыдущий шаг задания завершается сбоем. При наличии цепочки зависимых заданий, функция `failure()` возвращает значение `true`, если сбоем завершается любое предыдущее задание.

#### Пример `failure`

```yaml
steps:
  ...
  - name: The job has failed
    if: ${{ failure() }}
```

#### сбой с условиями

Вы можете включить дополнительные условия для шага, выполняемого после сбоя, но необходимо по-прежнему включить `failure()` для переопределения проверки состояния по умолчанию для `success()`, которая автоматически применяется к условиям `if`, не содержащим функцию проверки состояния.

##### Пример условий `failure`

```yaml
steps:
  ...
  - name: Failing step
    id: demo
    run: exit 1
  - name: The demo step has failed
    if: ${{ failure() && steps.demo.conclusion == 'failure' }}
```

## Фильтры объектов

С помощью записи `*` можно применить фильтр и подобрать соответствующие элементы из коллекции.

Например, рассмотрим массив объектов с именем `fruits`.

```json
[
  { "name": "apple", "quantity": 1 },
  { "name": "orange", "quantity": 2 },
  { "name": "pear", "quantity": 1 }
]
```

Фильтр `fruits.*.name` возвращает массив `[ "apple", "orange", "pear" ]`.

Синтаксис `*` также можно использовать для объекта. Например, допустим, у вас есть объект с именем `vegetables`.

```json

{
  "scallions":
  {
    "colors": ["green", "white", "red"],
    "ediblePortions": ["roots", "stalks"],
  },
  "beets":
  {
    "colors": ["purple", "red", "gold", "white", "pink"],
    "ediblePortions": ["roots", "stems", "leaves"],
  },
  "artichokes":
  {
    "colors": ["green", "purple", "red", "black"],
    "ediblePortions": ["hearts", "stems", "leaves"],
  },
}
```

Применение фильтра `vegetables.*.ediblePortions` может дать следующий результат:

```json

[
  ["roots", "stalks"],
  ["hearts", "stems", "leaves"],
  ["roots", "stems", "leaves"],
]
```

Так как объекты не сохраняют порядок, порядок выходных данных не может быть гарантирован.