# Новые типы данных

# Empty

Тип данных Empty обозначает отсутствие значения у выражения. Он появляется, например, при обращении к неинициализированной переменной или возвращаемому значению функции, в теле которой нет инструкции Вернуть:

перем п              # п имеет тип Empty

Функция Фн() {}
Фн()                 # возвращаемое значение - Empty

Empty является аналогом undefined в JavaScript (opens new window), однако любая операция с участием Empty вызывает исключение:

перем п
п + 1                # исключение, нельзя складывать Empty с числом

Функция Фн() {}
Фн() + 1             # аналогично

перем к = Фн()       # нельзя присваивать Empty переменной

# Методы и свойства примитивных типов данных

У некоторых примитивных типов данных, а именно

появились методы и свойства. Ниже перечислены некоторые из них.

# Строка.Подстрока(номерПервогоСимвола, длина = 0)

"абвгд".Подстрока(3, 2)                               # "вг"

# Строка.Найти(подстрока, начинатьПоискОтСимволаНомер = 1)

"абвгд".Найти("вг")                          # 3
"абвгд".Найти("12")                          # 0

# Строка.НачинаетсяС(префикс)

"абв".НачинаетсяС("аб")                      # true
"абв".НачинаетсяС("12")                      # false

# Строка.ЗаканчиваетсяНа(префикс)

"абв".ЗаканчиваетсяНа("бв")                  # true
"абв".ЗаканчиваетсяНа("12")                  # false

# Строка.СравнитьБезРегистра(другаяСтрока)

Возвращает

  • 0, если строки равны без учета регистра

  • -1, если сравниваемая строка меньше, чем другая строка

  • +1, если больше

"АБВ".СравнитьБезРегистра("абв")             # 0

# Строка.Разбить(разделитель)

Разбивает строку по разделителю и возвращает полученные части в виде массива. Если строка пустая, то в массиве будет одна пустая строка.

"а б в".Разбить(" ")                         # массив @["а", "б", "в"]

# Строка.Форматировать(...аргументы)

Заменяет в строке все заполнители {} на значения аргументов и возвращает полученную строку. В заполнителе может быть указан номер аргумента (с нуля) и его формат.

# возвращает строку "Сумма = 25 руб."
"{} = {}".Форматировать(
   "Сумма",
   "25 руб."
)

# аргументы форматируются по умолчанию,
# нулевой аргумент подставляется два раза;
# возвращает строку "2 * 2 = 4"
"{0} * {0} = {1}".Форматировать(
   2, 4
)

# первый аргумент форматируется как дробное
# число с общей длиной минимум 5 символов (при
# необходимости заполняется пробелами) и двумя
# знаками после запятой; возвращает строку
# "Сумма =  1.26"
"Сумма = {0:5.2f}".Форматировать(1.125)

# Строка.КоличествоСимволов

"абв".КоличествоСимволов                     # 3

# Время.Час, Время.Минута, Время.Секунда

перем в = 21:05:30
в.час                                        # 21
в.минута                                     # 5
в.секунда                                    # 30

# Дата.Год, Дата.Месяц, Дата.День

перем д = 01.09.2020
д.Год                                        # 2020
д.Месяц                                      # 9
д.День                                       # 1

# ДатаВремя

Содержит все свойства даты и времени (а также свойство Миллисекунда), позволяет добавлять (и вычитать) произвольное количество лет, месяцев и т.д.

перем дв = 01.09.2020 + 21:05:30             # создает дату-время
                                             # 01.09.2020 21:05:30

дв.добавитьДни(-100)                         # вычитает из значения дв 100 дней;
                                             # возвращает новую дату-время
                                             # 24.05.2020 21:05:30

Кроме того, имеет метод Форматировать, который превращает дату-время в строку по заданному формату.

(01.09.2020 + 21:05:30).
   .Форматировать(`yyyy/MM/dd'T'HH:mm:ss`)   # возвращает строку "2020/09/01T21:05:30"

# Тип данных Массив (Array)

Массив является нумерованным списком значений, индексы в котором начинаются с единицы. Похож на Array в JavaScript (opens new window), но не допускает строковые индексы. Позволяет получать, добавлять и удалять элементы по индексу; при модификации массива элементы автоматически сдвигаются.

перем п = @[]           # создает пустой массив без элементов

перем м = @["x", "y"]   # создает массив с двумя элементами
                        # 1 - строка "x"
                        # 2 - строка "y"

м[2]                    # возвращает строку "y"
м.2                     # аналогично

м.Добавить("z")         # добавляет строку "z" в конец массива
                        # т.е. она становится его третьим элементом:
                        # @["x", "y", "z"]

м.ДобавитьВНачало("v")  # вставляет строку "v" в начало массива;
                        # остальные элементы автоматически сдвигаются
                        # вправо, т.е. "x" становится вторым, "y" -
                        # третьим и т.д.:
                        # @["v", "x", "y", "z"]

м.Вставить(2, "w")      # вставляет строку "w" на вторую позицию в
                        # массиве, сдвигая последующие элементы вправо:
                        # @["v", "w", "x", "y", "z"]

м.Убрать(4)             # удаляет из массива четвертый элемент "y",
                        # сдвигая последующие элементы влево:
                        # @["v", "w", "x", "z"]

м.Размер                # возвращает количество элементов в массиве,
                        # т.е. 4

Синтаксис @[...] называется литералом массива.

# Литералы объектов

Объекты, как и массивы, имеют собственный литерал. Литералы позволяют сократить количество кода для инициализации объектов и сделать его более читабельным. Синтаксис объектных литералов похож на JavaScript (opens new window), за исключением символа @ перед фигурными скобками.

перем о = @{x: 1, y: 2}
# создает объект с ключами "x" и "y" и значениями 1 и 2;
# это выражение полностью аналогично следующему коду:
#
# Очистить(o)
# o.x = 1
# o.y = 2


перем о = @{
   x: @[1, 2],
   y: @{z: 3, w: 4}
}
# внутри объектного литерала могут находиться другие литералы
#
# Очистить(o)
# o.x = @[1, 2]
# o.y.z = 2
# o.y.w = 3


@{"ключ с пробелом": "значение"}
# если ключ содержит символы, которые недопустимы в имени
# переменной, его нужно заключать в кавычки


перем x = 1
перем у = 2
перем о = @{x, y}
# если опустить значение ключа, то оно будет
# взято из одноименной переменной
#
# Очистить(o)
# o.x = x
# o.y = y

# Методы объектов

Несмотря на то, что в документации описаны методы и свойства объектов, в десктопной и веб-версиях эти методы отключены для сохранения обратной совместимости:

@{x: 1}.Размер          # исключение, нет свойства Размер

# Функция ТипЗначения

Принимает один аргумент - любое значение, и возвращает название его типа данных.

ТипЗначения(1)          # "Real"
ТипЗначения("1")        # "String"
ТипЗначение(п)          # "Empty" - переменная п не существует

Ссылка на документацию.