Перейти к основному содержимому

Последовательность

Стд::Последовательность<ТипЭлемента>

Объект предоставляет возможность для потоковой обработки данных. Некоторые методы помечены как терминальные. Это значит что такой метод закрывает последовательность и дальнейшие действия с последовательностью приведут к ошибке.

Сравнение

Ссылочное

Иерархия типа​

Базовые типы: Объект

Примеры​

Общие примеры

знч Числа = [1, 3, 5, 10].КакПоследовательность()
знч Макс = Числа.Максимум()

// Здесь вызов метода "Минимум" приведет к ошибке
// последовательность "Числа" уже закрыта ранее при вызове терминального метода "Максимум"
знч Мин = Числа.Минимум()

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

/* Выполняется на сервере */

знч Числа = [1, 3, 5, 10]

пер ПоследовательностьЧисел = Числа.КакПоследовательность()

// Вызван не терминальный метод "Фильтровать", никаких реальных действий выполнено не будет
ПоследовательностьЧисел = ПоследовательностьЧисел.Фильтровать(А -> А > 4)

Числа.Добавить(-1)
Числа.Добавить(15)

// Вызван терминальный метод "ВМассив", фильтрация элементов будет тут
знч Результат = ПоследовательностьЧисел.ВМассив()
// [5, 10, 15]
 
/* Выполняется на клиенте */

знч Числа = [1, 3, 5, 10]

пер ПоследовательностьЧисел = Числа.КакПоследовательность()

// Фильтрация будет выполнена здесь
ПоследовательностьЧисел = ПоследовательностьЧисел.Фильтровать(А -> А > 4)

// Добавление новых чисел не повлияет на результат, так как фильтрация уже выполнена
Числа.Добавить(-1)
Числа.Добавить(15)

знч Результат = ПоследовательностьЧисел.ВМассив()
// [5, 10]
  • ItemType - Тип элементов в последовательности.

Методы​

ВМассив​

ВМассив(): Массив<ТипЭлемента>
Преобразует Последовательность в Массив. Терминальный метод.

Примеры​

знч Числа: Последовательность<Число> = [1, 2].КакПоследовательность()
знч МассивЧисел = Числа.ВМассив() // [1, 2]

ВСоответствие​

ВСоответствие<ТипКлюча, ТипЗначения>(
  ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча,
  ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения
): Соответствие<ТипКлюча, ТипЗначения>
ТипКлюча: тип ключа.
ТипЗначения: тип значения.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя"}, {Ид: 5, Имя: "Вася"}]
знч ИдИмя: Соответствие<Число, Строка> = Сотрудники.КакПоследовательность().ВСоответствие(Элемент -> Элемент.Ид, Элемент -> Элемент.Имя)
// { 13 : "Петя",
//    5 : "Вася"}

См. также​

ГруппироватьПо

ВСоответствиеСКлючами​

ВСоответствиеСКлючами<ТипКлюча>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча): Соответствие<ТипКлюча, ТипЭлемента>
ТипКлюча: тип ключа.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Возраст: 24},
//  {Ид: 5,  Имя: "Вася", Возраст: 30}]

знч СотрудникПоИд = Сотрудники.КакПоследовательность().ВСоответствиеСКлючами(Элемент -> Элемент.Ид) // Соответствие<Число, Сотрудник>
// {13 : {Ид: 13, Имя: "Петя", Возраст: 24},
//   5 : {Ид: 5,  Имя: "Вася", Возраст: 30}}

См. также​

ГруппироватьПо

ВСоответствиеСоЗначениями​

ВСоответствиеСоЗначениями<ТипЗначения>(ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения): Соответствие<ТипЭлемента, ТипЗначения>
ТипЗначения: тип значения.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Идентификаторы: Последовательность<Число> = [13, 5].КакПоследовательность()

знч СотрудникПоИд = Идентификаторы.ВСоответствиеСоЗначениями(Ид -> ПолучитьСотрудникаПоИд(Ид)) // Соответствие<Число, Сотрудник>
// {13 : {Ид: 13, Имя: "Петя", Возраст: 24},
//   5 : {Ид: 5,  Имя: "Вася", Возраст: 30}}

См. также​

ГруппироватьПо

ВоМножество​

ВоМножество(): Множество<ТипЭлемента>
Преобразует Последовательность во Множество. Терминальный метод.

Примеры​

знч Числа = [1, 3, 5, 10, 12, 1, 3, 5].КакПоследовательность()
знч МножествоЧисел = Числа.ВоМножество() // {1, 3, 5, 10, 12}

ВсеСоответствуют​

ВсеСоответствуют(Предикат: (ТипЭлемента)->Булево): Булево
Возвращает Истина, если все элементы Последовательности удовлетворяют условию в предикате. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//  {Ид: 5, Имя: "Вася", Отдел: "Администрация"},
//  {Ид: 6, Имя: "Иван", Отдел: "Разработка"}]
знч ВсеИзРазработки: Булево = Сотрудники.КакПоследовательность().ВсеСоответствуют(Элемент -> Элемент.Отдел == "Разработка") // Ложь

// пример сокращенного вычисления 
знч Числа = [1, 2, 3, 4, 5]
знч КвадратыЧисел = <Число>[]
знч ВсеЧетные = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ВсеСоответствуют(а -> а % 2 == 0) // Ложь
// КвадратыЧисел = [1]

ГруппироватьПо​

ГруппироватьПо<ТипКлюча>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЭлемента>>>
ТипКлюча: тип ключа.

Группирует элементы в соответствии с заданной функцией вычисления ключа. Элементы с одинаковым ключом объединяются в Массив. Терминальный метод.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ГруппироватьПо<ТипКлюча, ТипЗначения>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча, ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЗначения>>>
ГруппироватьПо<ТипКлюча, ТипЗначения, ТипКоллекции>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча, ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения, КонструкторКоллекции: ()->ТипКоллекции): Последовательность<КлючИЗначение<ТипКлюча, ТипКоллекции>>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//  {Ид: 5,  Имя: "Вася", Отдел: "Администрация"},
//  {Ид: 6,  Имя: "Иван", Отдел: "Разработка"}]

знч ОтделыИСотрудники: Последовательность<КлючИЗначение<Строка, Массив<Сотрудник>>> = Сотрудники.КакПоследовательность().ГруппироватьПо(Элемент -> Элемент.Отдел)
// [ 
//   Администрация: [{Ид: 13, Имя: "Петя", Отдел: "Администрация"}, 
//                   {Ид: 5,  Имя: "Вася", Отдел: "Администрация"}],
//   Разработка:    [{Ид: 6,  Имя: "Иван", Отдел: "Разработка"}]
// ]

ГруппироватьПо​

Версия 8.0 и выше

ГруппироватьПо<ТипКлюча, ТипЗначения>(
  ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча,
  ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения
): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЗначения>>>
ТипКлюча: тип ключа.
ТипЗначения: тип значения.

Группирует элементы в соответствии с заданной функцией вычисления ключа. Для элементов с одинаковым ключом вычисляются значения и объединяются в Массив. Терминальный метод.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ГруппироватьПо<ТипКлюча>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЭлемента>>>
ГруппироватьПо<ТипКлюча, ТипЗначения, ТипКоллекции>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча, ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения, КонструкторКоллекции: ()->ТипКоллекции): Последовательность<КлючИЗначение<ТипКлюча, ТипКоллекции>>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//  {Ид: 5,  Имя: "Вася", Отдел: "Администрация"},
//  {Ид: 6,  Имя: "Иван", Отдел: "Разработка"}]
//  {Ид: 8,  Имя: "Андрей", Отдел: "Бухгалтерия"}]

знч ОтделыИСотрудники: Последовательность<КлючИЗначение<Строка, Массив<Строка>>> = Сотрудники.КакПоследовательность().ГруппироватьПо(Элемент -> Элемент.Отдел, Элемент -> Элемент.Имя)
// [ 
//   "Администрация": ["Петя", "Вася"],
//   "Разработка":    ["Иван"],
//   "Бухгалтерия":   ["Андрей"]
// ]

ГруппироватьПо​

Версия 8.0 и выше

ГруппироватьПо<ТипКлюча, ТипЗначения, ТипКоллекции>(
  ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча,
  ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения,
  КонструкторКоллекции: ()->ТипКоллекции
): Последовательность<КлючИЗначение<ТипКлюча, ТипКоллекции>>
ТипКлюча: тип ключа.
ТипЗначения: тип значения.
ТипКоллекции: тип коллекции. Ограничения параметра типа: Стд::Коллекции::Коллекция<ТипЗначения>.

Группирует элементы в соответствии с заданной функцией вычисления ключа. Для элементов с одинаковым ключом вычисляются значения и объединяются в Коллекцию. Терминальный метод.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ГруппироватьПо<ТипКлюча>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЭлемента>>>
ГруппироватьПо<ТипКлюча, ТипЗначения>(ИзвлекательКлюча: (ТипЭлемента)->ТипКлюча, ИзвлекательЗначения: (ТипЭлемента)->ТипЗначения): Последовательность<КлючИЗначение<ТипКлюча, Массив<ТипЗначения>>>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//  {Ид: 5,  Имя: "Вася", Отдел: "Администрация"},
//  {Ид: 6,  Имя: "Иван", Отдел: "Разработка"}]
//  {Ид: 8,  Имя: "Андрей", Отдел: "Бухгалтерия"}]
//  {Ид: 11,  Имя: "Вася", Отдел: "Администрация"}]
//  {Ид: 3,  Имя: "Иван", Отдел: "Разработка"}]

знч ОтделыИСотрудники: Последовательность<КлючИЗначение<Строка, Множество<Строка>>> = Сотрудники.КакПоследовательность().ГруппироватьПо(Элемент -> Элемент.Отдел, Элемент -> Элемент.Имя, () -> новый Множество<Строка>())
// [ 
//   "Администрация": {"Петя", "Вася"},
//   "Разработка":    {"Иван"},
//   "Бухгалтерия":   {"Андрей"}
// ]

ДляКаждого​

ДляКаждого(Действие: (ТипЭлемента)->ничто): Последовательность<ТипЭлемента>
Выполняет заданное действие для каждого элемента. Не изменяет элементы Последовательности. На сервере в сочетании с операцией сокращенного вычисления может быть вызван не для каждого элемента.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ДляКаждого(Действие: (Число, ТипЭлемента)->ничто): Последовательность<ТипЭлемента>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: Петя}, {Ид: 5, Имя: Вася}]

пер СписокСотрудников: Массив<Строка> = []
Сотрудники.КакПоследовательность().ДляКаждого(Элемент -> СписокСотрудников.Добавить(Элемент.Ид + " - " + Элемент.Имя)).ВМассив()
// Содержимое переменной СписокСотрудников:
// ["13 - Петя", "5 - Вася"]

// В примере ниже действие 'а -> КвадратыЧисел.Добавить(а * а)'
// на сервере будет вызвано только для первого элемента
знч Числа = [1, 3, 5]
знч КвадратыЧисел = <Число>[]
знч Первое = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПервыйИлиНеопределено() // 1
// КвадратыЧисел = [1]

ДляКаждого​

ДляКаждого(Действие: (Число, ТипЭлемента)->ничто): Последовательность<ТипЭлемента>
Выполняет заданное действие для каждого элемента и его индекса. Не изменяет элементы Последовательности. На сервере в сочетании с операцией сокращенного вычисления может быть вызван не для каждого элемента.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ДляКаждого(Действие: (ТипЭлемента)->ничто): Последовательность<ТипЭлемента>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: Петя}, {Ид: 5, Имя: Вася}]

пер СписокСотрудников: Массив<Строка> = []
Сотрудники.КакПоследовательность().ДляКаждого((Индекс, Элемент) -> СписокСотрудников.Добавить(Индекс + ") " + Элемент.Имя)).ВМассив()
// Содержимое переменной СписокСотрудников:
// ["0) Петя", "1) Вася"]


// В примере ниже действие 'а -> КвадратыЧисел.Добавить(а * а)'
// на сервере будет вызвано только для первого элемента
знч Числа = [1, 3, 5]
знч КвадратыЧисел = <Число>[]
знч Первое = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПервыйИлиНеопределено() // 1
// КвадратыЧисел = [1]

Единственный​

Единственный(): ТипЭлемента
Возвращает единственный содержащийся элемент. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов или элементов больше одного.

ЕдинственныйИлиНеопределено​

Версия 7.0 и выше

ЕдинственныйИлиНеопределено(): ТипЭлемента?
Возвращает единственный содержащийся элемент или Неопределено. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если элементов больше одного.

Прошлые имена: ЕдинственныйИлиУмолчание

ЕдинственныйИлиУмолчание​

Версия 7.0 и выше

ЕдинственныйИлиУмолчание(Умолчание: ТипЭлемента): ТипЭлемента
Возвращает единственный содержащийся элемент или значение Умолчание, если элементов нет. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если элементов больше одного.

Перегрузка
ЕдинственныйИлиУмолчание<ТипУмолчания>(ВычислительУмолчания: ()->ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания

ЕдинственныйИлиУмолчание​

Версия 7.0 и выше

ЕдинственныйИлиУмолчание<ТипУмолчания>(ВычислительУмолчания: ()->ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания
ТипУмолчания: Тип умолчания.

Возвращает единственный содержащийся элемент или значение, вычисленное с помощью ВычислительУмолчания, если элементов нет. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Исключения​

ИсключениеНедопустимоеСостояние - если элементов больше одного.

Перегрузка
ЕдинственныйИлиУмолчание(Умолчание: ТипЭлемента): ТипЭлемента

ЕдинственныйИлиУмолчание​

Версия 6.0 и ниже

ЕдинственныйИлиУмолчание(): ТипЭлемента?
Метод переименован в ЕдинственныйИлиНеопределено.

ЕдинственныйИлиУмолчание​

Версия 6.0 и ниже

ЕдинственныйИлиУмолчание<ТипУмолчания>(Умолчание: ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания
Метод заменен на ЕдинственныйИлиУмолчание.

ЕстьСоответствия​

ЕстьСоответствия(Предикат: (ТипЭлемента)->Булево): Булево
Возвращает Истина, если хотя бы один из элементов Последовательности удовлетворяет условию в предикате. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//   {Ид: 5, Имя: "Вася", Отдел: "Администрация"},
//   {Ид: 6, Имя: "Иван", Отдел: "Разработка"}]
знч КтоТоИзАдминистрации: Булево = Сотрудники.КакПоследовательность().ЕстьСоответствия(Элемент -> Элемент.Отдел == "Администрация") // Истина

// пример сокращенного вычисления 
знч Числа = [1, 2, 3, 4, 5]
знч КвадратыЧисел = <Число>[]
знч ЕстьЧетные = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ЕстьСоответствия(а -> а % 2 == 0) // Истина
// КвадратыЧисел = [1, 4]

КакОбходимое​

КакОбходимое(): Обходимое<ТипЭлемента>
Преобразует Последовательность в Обходимое. Терминальный метод.

Максимум​

<ItemType это Сравнимое<ТипЭлемента>> Максимум(): ТипЭлемента
Возвращает максимальный элемент из элементов Последовательности типа Сравнимое. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Примеры​

знч Числа = [1, 3, 5, 10, 12].КакПоследовательность()
знч Максимум: Число = Числа.Максимум() // 12

МаксимумПо​

МаксимумПо(Извлекатель: (ТипЭлемента)->Сравнимое<неизвестно>): ТипЭлемента
Возвращает максимальный по заданному свойству элемент Последовательности. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Имя: "Петя", Возраст: 25},
//  {Имя: "Вася", Возраст: 24},
//  {Имя: "Иван", Возраст: 30}]
 
знч СтаршийСотрудник: Сотрудник = Сотрудники.КакПоследовательность().МаксимумПо(Элемент -> Элемент.Возраст)
// {Имя: "Иван", Возраст: 30}

Минимум​

<ItemType это Сравнимое<ТипЭлемента>> Минимум(): ТипЭлемента
Возвращает минимальный элемент из элементов Последовательности типа Сравнимое. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Примеры​

знч Числа = [1, 3, 5, 10, 12].КакПоследовательность()
знч Минимум: Число = Числа.Минимум() // 1

МинимумПо​

МинимумПо(Извлекатель: (ТипЭлемента)->Сравнимое<неизвестно>): ТипЭлемента
Возвращает минимальный по заданному свойству элемент Последовательности. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Имя: "Петя", Возраст: 25},
//  {Имя: "Вася", Возраст: 24},
//  {Имя: "Иван", Возраст: 30}]
 
знч МладшийСотрудник: Сотрудник = Сотрудники.КакПоследовательность().МинимумПо(Элемент -> Элемент.Возраст)
// {Имя: "Вася", Возраст: 24}

НетСоответствий​

НетСоответствий(Предикат: (ТипЭлемента)->Булево): Булево
Возвращает Истина, если ни один из элементов Последовательности не удовлетворяет условию в предикате. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя", Отдел: "Администрация"},
//  {Ид: 5, Имя: "Вася", Отдел: "Администрация"},
//  {Ид: 6, Имя: "Иван", Отдел: "Разработка"}]
знч НиктоИзБухгалтерии: Булево = Сотрудники.КакПоследовательность().НетСоответствий(Элемент -> Элемент.Отдел == "Бухгалтерия") // Истина

// пример сокращенного вычисления 
знч Числа = [1, 2, 3, 4, 5]
знч КвадратыЧисел = <Число>[]
знч НетЧетных = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).НетСоответствий(а -> а % 2 == 0) // Ложь
// КвадратыЧисел = [1, 4]

Объединить​

@ПроверятьИспользованиеЗначения
Объединить(Последовательность: Последовательность<ТипЭлемента>): Последовательность<ТипЭлемента>
Объединяет элементы текущей последовательности с элементами Последовательность и возвращает новую последовательность.

Перегрузка
Объединить<ТипПоследовательности, ТипРезультата>(Последовательность: Последовательность<ТипПоследовательности>, Преобразователь: (ТипЭлемента, ТипПоследовательности)->ТипРезультата): Последовательность<ТипРезультата>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Имя: "Петя",   Возраст: 25}, 
//  {Имя: "Вася",   Возраст: 24}] 

знч Сотрудники2: Массив<Сотрудник> = []
// [{Имя: "Иван",   Возраст: 26}, 
//  {Имя: "Андрей", Возраст: 27}]

знч ВсеСотрудники: Последовательность<Сотрудник> = Сотрудники.КакПоследовательность().Объединить(Сотрудники2.КакПоследовательность())
// [{Имя: "Петя",   Возраст: 25}, 
//  {Имя: "Вася",   Возраст: 24},
//  {Имя: "Иван",   Возраст: 26}, 
//  {Имя: "Андрей", Возраст: 27}]

Объединить​

@ПроверятьИспользованиеЗначения
Объединить<ТипПоследовательности, ТипРезультата>(
  Последовательность: Последовательность<ТипПоследовательности>,
  Преобразователь: (ТипЭлемента, ТипПоследовательности)->ТипРезультата
): Последовательность<ТипРезультата>
ТипРезультата: тип результата.
ТипПоследовательности: тип объединяемых элементов.

Объединяет текущую последовательность с переданной. Попарно берет элементы из каждой последовательности и применяет к ним функцию преобразователь для получения результирующего элемента. Итоговая последовательность будет иметь длину кратчайшей из исходных. Лишние элементы из более длинной последовательности просто игнорируются.

Перегрузка
Объединить(Последовательность: Последовательность<ТипЭлемента>): Последовательность<ТипЭлемента>

Примеры​

знч Числа: Последовательность<Число> = [1, 2, 4, 8].КакПоследовательность()

знч Строки: Последовательность<Строка> = ["aa", "ab", "ac"].КакПоследовательность()

знч Пары: Последовательность<КлючИЗначение<Число, Строка>> = Числа.Объединить(Строки, (Ч, С) -> новый КлючИЗначение<Число, Строка>(Ч, С))
// [{1: "aa"}, {2: "ab"}, {4: "ac"}]

Ограничить​

Ограничить(Количество: Число): Последовательность<ТипЭлемента>
Ограничивает количество элементов до заданного числа. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента.

Исключения​

ИсключениеНедопустимыйАргумент - если Количество <= 0.

Примеры​

знч Числа = [1, 3, 5, 10, 12, 15, 20]
знч Числа1 = Числа.КакПоследовательность().Ограничить(3).ВМассив() //[1, 3, 5]

// пример сокращенного вычисления 
знч Числа2 = [1, 3, 5, 10, 12, 15, 20]
знч КвадратыЧисел: Массив<Число> = []
знч СокращенныйМассив = Числа2.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).Ограничить(3).ВМассив()
// КвадратыЧисел = [1, 9, 25]

Первый​

Первый(): ТипЭлемента
Возвращает первый элемент. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если элементов нет.

ПервыйИлиНеопределено​

Версия 7.0 и выше

ПервыйИлиНеопределено(): ТипЭлемента?
Возвращает первый элемент или Неопределено, если элементов нет. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

Примеры​

знч Числа = [1, 3, 5, 10, 12, 15, 20]
знч Первый = Числа.КакПоследовательность().ПервыйИлиНеопределено() // 1

// пример сокращенного вычисления 
знч КвадратыЧисел = <Число>[]
знч Первый1 = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПервыйИлиНеопределено() // 1
// КвадратыЧисел = [1]

Прошлые имена: ПервыйИлиУмолчание

ПервыйИлиУмолчание​

Версия 7.0 и выше

ПервыйИлиУмолчание(Умолчание: ТипЭлемента): ТипЭлемента
Возвращает первый элемент или значение Умолчание, если элементов нет. На сервере это операция сокращенного вычисления. Это значит, что вызванные до операции, могут быть вызваны не для каждого элемента. Терминальный метод.

Перегрузка
ПервыйИлиУмолчание<ТипУмолчания>(ВычислительУмолчания: ()->ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания

Примеры​

знч Числа = [1, 3, 5, 10, 12, 15, 20]
знч Первый = Числа.КакПоследовательность().ПервыйИлиУмолчание(0) // 1

// пример сокращенного вычисления 
знч КвадратыЧисел: Массив<Число> = []
знч Первый1 = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПервыйИлиУмолчание(0) // 1
// КвадратыЧисел = [1]

ПервыйИлиУмолчание​

Версия 7.0 и выше

ПервыйИлиУмолчание<ТипУмолчания>(ВычислительУмолчания: ()->ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания
ТипУмолчания: Тип умолчания.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ПервыйИлиУмолчание(Умолчание: ТипЭлемента): ТипЭлемента

Примеры​

знч Числа = [1, 3, 5, 10, 12, 15, 20]
знч Первый = Числа.КакПоследовательность().ПервыйИлиУмолчание(() -> 0) // 1

// пример сокращенного вычисления 
знч КвадратыЧисел: Массив<Число> = []
знч Первый1 = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПервыйИлиУмолчание(() -> 0) // 1
// КвадратыЧисел = [1]

ПервыйИлиУмолчание​

Версия 6.0 и ниже

ПервыйИлиУмолчание(): ТипЭлемента?
Метод переименован в ПервыйИлиНеопределено.

ПервыйИлиУмолчание​

Версия 6.0 и ниже

ПервыйИлиУмолчание<ТипУмолчания>(Умолчание: ТипЭлемента|ТипУмолчания): ТипЭлемента|ТипУмолчания
Метод заменен на ПервыйИлиУмолчание.

ПосчитатьРазмер​

ПосчитатьРазмер(): Число
Возвращает количество элементов в Последовательности. На сервере промежуточные операции могут быть опущены, если посчитать размер можно без них. Терминальный метод.

Примеры​

знч Числа = [1, 3, 5, 10]
знч Размер = Числа.КакПоследовательность().ПосчитатьРазмер() // 4

// вызов ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)) будет опущен
// так как не влияет на количество элементов в последовательности
знч КвадратыЧисел: Массив<Число> = []
знч Размер1 = Числа.КакПоследовательность().ДляКаждого(а -> КвадратыЧисел.Добавить(а * а)).ПосчитатьРазмер() // 4
// КвадратыЧисел = []

ПотомСортироватьПо​

ПотомСортироватьПо(
  Извлекатель: (ТипЭлемента)->Сравнимое<неизвестно>,
  Направление: НаправлениеСортировки = НаправлениеСортировки.ПоВозрастанию
): Последовательность<ТипЭлемента>
Выполняет дополнительную сортировку, используя Извлекатель для сравнения элементов.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Возраст: 31, Имя: "Петя"}, 
//  {Ид: 18, Возраст: 42, Имя: "Иван"}, 
//  {Ид: 5,  Возраст: 42, Имя: "Вася"}]

знч СотрудникиПоИд = Сотрудники.КакПоследовательность().СортироватьПо(Элемент -> Элемент.Возраст).ПотомСортироватьПо(Элемент -> Элемент.Ид)
// [{Ид: 13, Возраст: 31,  Имя: "Петя"}, 
//  {Ид: 5,  Возраст: 42, Имя: "Вася"}, 
//  {Ид: 18, Возраст: 42, Имя: "Иван"}]

Преобразовать​

Преобразовать<ТипРезультата>(Функция: (Число, ТипЭлемента)->ТипРезультата): Последовательность<ТипРезультата>
ТипРезультата: тип результата.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
Преобразовать<ТипРезультата>(Функция: (ТипЭлемента)->ТипРезультата, ПропуститьНеопределено: Булево = Истина): Последовательность<ТипРезультата>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 1, Имя: "Петя"}, {Ид: 2, Имя: "Вася"}]

знч Имена: Последовательность<Строка> = Сотрудники.КакПоследовательность().Преобразовать((Индекс, Сотрудник) -> Индекс + ") " + Сотрудник.Имя) 
//["0) Петя", "1) Вася"]

Преобразовать​

Преобразовать<ТипРезультата>(
  Функция: (ТипЭлемента)->ТипРезультата,
  ПропуститьНеопределено: Булево = Истина
): Последовательность<ТипРезультата>
ТипРезультата: тип результата.

Применяет функцию к каждому элементу и возвращает новую последовательность с результатами. ПропуститьНеопределено - если Истина и результатом функции является Неопределено, элемент не будет включен в результирующую последовательность. Иначе будет.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
Преобразовать<ТипРезультата>(Функция: (Число, ТипЭлемента)->ТипРезультата): Последовательность<ТипРезультата>

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 1, Имя: "Петя"}, {Ид: 2, Имя: "Вася"}]

знч Имена: Последовательность<Строка> = Сотрудники.КакПоследовательность().Преобразовать(Сотрудник -> Сотрудник.Имя) 
// ["Петя", "Вася"]

ПреобразоватьЛинейно​

ПреобразоватьЛинейно<ТипРезультата>(Функция: (ТипЭлемента)->Обходимое<ТипРезультата>): Последовательность<ТипРезультата>
ТипРезультата: тип результата.

Преобразует каждый элемент в Обходимое и объединяет в общую Последовательность.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ПреобразоватьЛинейно<ТипРезультата>(Функция: (Число, ТипЭлемента)->Обходимое<ТипРезультата>): Последовательность<ТипРезультата>

Примеры​

знч Отделы: Массив<Отдел> = []
//[{Ид:1, Сотрудники: ["Петя", "Вася"]}, {Ид: 2, Сотрудники: ["Иван", "Андрей"]}]
знч ВсеСотрудники = Отделы.КакПоследовательность().ПреобразоватьЛинейно(Отдел -> Отдел.Сотрудники) // "Петя", "Вася", "Иван", "Андрей"

ПреобразоватьЛинейно​

ПреобразоватьЛинейно<ТипРезультата>(Функция: (Число, ТипЭлемента)->Обходимое<ТипРезультата>): Последовательность<ТипРезультата>
ТипРезультата: тип результата.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
ПреобразоватьЛинейно<ТипРезультата>(Функция: (ТипЭлемента)->Обходимое<ТипРезультата>): Последовательность<ТипРезультата>

Примеры​

знч Отделы: Массив<Отдел> = []
//[{Ид:1, Сотрудники: ["Петя", "Вася"]}, {Ид: 2, Сотрудники: ["Иван", "Андрей"]}]

знч ВсеСотрудники = Отделы.КакПоследовательность().ПреобразоватьЛинейно(
    (Индекс, Отдел) -> Отдел.Сотрудники.Преобразовать(е -> "Отдел " + (Индекс + 1) + ": " + е)
)
// ["Отдел 1: Петя", "Отдел 1: Вася", "Отдел 2: Иван", "Отдел 2: Андрей"]

Пропустить​

Пропустить(Количество: Число): Последовательность<ТипЭлемента>
Пропускает заданное количество элементов в начале.

Исключения​

ИсключениеНедопустимыйАргумент - если Количество <= 0.

Примеры​

знч Числа = [1, 3, 5, 10, 12, 15, 20]
знч Числа1 = Числа.КакПоследовательность().Пропустить(3).ВМассив() // [10, 12, 15, 20]

ПропуститьНеопределено​

ПропуститьНеопределено(): Последовательность<ТипЭлемента>
Исключает Неопределено из элементов Последовательности. Также изменяет тип элементов последовательности, исключая Неопределено из его состава.

Примеры​

знч Элементы = [1, 2, "Петя", Неопределено].КакПоследовательность()
знч Список = Элементы.ПропуститьНеопределено() // [1, 2, "Петя"]
Список.ПолучитьТип() // Последовательность<Число|Строка>

Свернуть​

Свернуть(Операция: (ТипЭлемента, ТипЭлемента)->ТипЭлемента): ТипЭлемента
Сводит все элементы Последовательности к одному значению с помощью заданной операции. Терминальный метод.

Операция - функция, которая принимает два аргумента, выполняет над ними некоторую операцию и возвращает результат. Затем эта функция опять применяется к результату и следующему элементу.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Перегрузка
Свернуть<ТипРезультата>(НачальноеЗначение: ТипРезультата, Операция: (ТипРезультата, ТипЭлемента)->ТипРезультата): ТипРезультата

Примеры​

знч Числа = [1, 3, 5, 10].КакПоследовательность()
знч Сумма: Число = Числа.Свернуть((а, б) -> а + б)   // 19

Свернуть​

Версия 10.0 и выше

Свернуть<ТипРезультата>(
  НачальноеЗначение: ТипРезультата,
  Операция: (ТипРезультата, ТипЭлемента)->ТипРезультата
): ТипРезультата
ТипРезультата: тип результата.

Сводит все элементы Последовательности к одному значению с помощью заданной операции и начального значения. Терминальный метод.

Операция - функция, которая принимает два аргумента, выполняет над ними некоторую операцию и возвращает результат. Затем эта функция опять применяется к результату и следующему элементу.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
Свернуть(Операция: (ТипЭлемента, ТипЭлемента)->ТипЭлемента): ТипЭлемента

Примеры​

знч Числа = [1, 3, 5, 10].КакПоследовательность()
знч Сумма = Числа.Свернуть(100, (а, б) -> а + б)   // 119

Свернуть​

Версия 9.0 и ниже

Свернуть(
  НачальноеЗначение: ТипЭлемента,
  Операция: (ТипЭлемента, ТипЭлемента)->ТипЭлемента
): ТипЭлемента
Метод заменен на Свернуть.

Соединить​

<ItemType это Строка> Соединить(Разделитель: Строка = ""): Строка
Соединяет элементы в одну строку, с разделителем Разделитель. Терминальный метод.

Примеры​

знч Сотрудники: Массив<Строка> = [] // ["Петя", "Вася", "Иван"]
знч Список: Строка = Сотрудники.КакПоследовательность().Соединить(", ") // "Петя, Вася, Иван"

Сортировать​

@ПроверятьИспользованиеЗначения
Сортировать(Компаратор: (ТипЭлемента, ТипЭлемента)->Число): Последовательность<ТипЭлемента>
Сортирует элементы Последовательности, используя Компаратор для сравнения элементов.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
<ItemType это Сравнимое<ТипЭлемента>> Сортировать(Направление: НаправлениеСортировки = НаправлениеСортировки.ПоВозрастанию): Последовательность<ТипЭлемента>

Примеры​

знч Числа = [10, 12, 1, 3, 5].КакПоследовательность()
знч ПоВозрастанию = Числа.Сортировать((а, б) -> а - б)  // [1, 3, 5, 10, 12]
знч ПоУбыванию = Числа.Сортировать((а, б) -> б - а)     // [12, 10, 5, 3, 1]

Сортировать​

@ПроверятьИспользованиеЗначения
<ItemType это Сравнимое<ТипЭлемента>> Сортировать(Направление: НаправлениеСортировки = НаправлениеСортировки.ПоВозрастанию): Последовательность<ТипЭлемента>
Сортирует элементы Последовательности типа Сравнимое.

Перегрузка
Сортировать(Компаратор: (ТипЭлемента, ТипЭлемента)->Число): Последовательность<ТипЭлемента>

Примеры​

знч Числа = [10, 12, 1, 3, 5].КакПоследовательность()
знч ПоУбыванию = Числа.Сортировать(Направление = НаправлениеСортировки.ПоУбыванию)  // [12, 10, 5, 3, 1]
знч ПоВозрастанию = Числа.Сортировать()                                             // [1, 3, 5, 10, 12]

СортироватьПо​

@ПроверятьИспользованиеЗначения
СортироватьПо(
  Извлекатель: (ТипЭлемента)->Сравнимое<неизвестно>,
  Направление: НаправлениеСортировки = НаправлениеСортировки.ПоВозрастанию
): Последовательность<ТипЭлемента>
Сортирует Последовательность, используя Извлекатель для сравнения элементов.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Ид: 13, Имя: "Петя"}, {Ид: 5, Имя: "Вася"}]

знч СотрудникиПоИд: Последовательность<Сотрудник> = Сотрудники.КакПоследовательность().СортироватьПо(Элемент -> Элемент.Ид) 
// [{Ид: 5, Имя: "Вася"}, {Ид: 13, Имя: "Петя"}]

Среднее​

<ItemType это Число> Среднее(): Число
Возвращает среднее арифметическое элементов Последовательности типа Число. Терминальный метод.

Исключения​

ИсключениеНедопустимоеСостояние - если нет элементов.

Примеры​

знч Среднее = [1, 2, 3, 4, 5].КакПоследовательность().Среднее() // 3

СреднееИлиУмолчание​

<ItemType это Число> СреднееИлиУмолчание(Умолчание: Число = 0): Число
Возвращает среднее арифметическое элементов Последовательности типа Число или Умолчание, если элементов нет.

Примеры​

знч Среднее = [1, 2, 3, 4, 5].КакПоследовательность().СреднееИлиУмолчание() // 3
знч СреднееИлиУмолчание = <Число>[].КакПоследовательность().СреднееИлиУмолчание(5) // 5

Сумма​

<ItemType это Число> Сумма(): Число
Возвращает сумму элементов Последовательности типа Число или 0, если элементов нет. Терминальный метод.

Примеры​

знч Числа = [1, 2, 3, 4, 5].КакПоследовательность()
знч Сумма = Числа.Сумма() // 15

Уникальные​

Уникальные(): Последовательность<ТипЭлемента>
Возвращает Последовательность, в котором содержатся только уникальные элементы Последовательности. В случае с одинаковыми значениями, в результирующую последовательность попадет первое вхождение.

Примеры​

знч Числа = [12, 10, 5, 3, 1, 3, 5, 10].КакПоследовательность()
знч УникальныеЧисла = Числа.Уникальные() // [12, 10, 5, 3, 1]

УникальныеПо​

УникальныеПо<ТипСвойства>(Извлекатель: (ТипЭлемента)->ТипСвойства): Последовательность<ТипЭлемента>
ТипСвойства: тип свойства.

Возвращает Последовательность, в котором содержатся только уникальные по определенному свойству элементы Последовательности. В случае с одинаковыми свойствами, в результирующую последовательность попадет первое вхождение.

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

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Примеры​

знч Сотрудники: Массив<Сотрудник> = []
// [{Имя: "Петя", Возраст: 25},
//  {Имя: "Вася", Возраст: 24},
//  {Имя: "Иван", Возраст: 25}]

знч УникальныеПоВозрасту: Последовательность<Сотрудник> =  Сотрудники.КакПоследовательность().УникальныеПо(Элемент -> Элемент.Возраст)
// [{Имя: "Петя", Возраст: 25},
//  {Имя: "Вася", Возраст: 24}]

Фильтровать​

@ПроверятьИспользованиеЗначения
Фильтровать(Фильтр: (ТипЭлемента)->Булево): Последовательность<ТипЭлемента>
Фильтрует элементы Последовательности по заданному критерию.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
Фильтровать(Фильтр: (Число, ТипЭлемента)->Булево): Последовательность<ТипЭлемента>

Примеры​

знч Числа = [1, 3, 5, 10, 12].КакПоследовательность()
знч Четные = Числа.Фильтровать(Элемент -> Элемент % 2 == 0) // [10, 12]

Фильтровать​

@ПроверятьИспользованиеЗначения
Фильтровать(Фильтр: (Число, ТипЭлемента)->Булево): Последовательность<ТипЭлемента>
Фильтрует элементы Последовательности с индексом по заданному критерию.

важно

На клиенте в методах вычисления нельзя использовать любые асинхронные операции, например вызовы сервера. Это приведет к возникновению ошибки «Попытка выполнить асинхронное действие». Аналогичная ошибка может возникнуть при использовании отладчика для таких методов.

Перегрузка
Фильтровать(Фильтр: (ТипЭлемента)->Булево): Последовательность<ТипЭлемента>

Примеры​

знч Числа = [11, 3, 4, 5, 18, 12]
// Числа, которые стоят на четных позициях и больше 10
знч Числа1 = Числа.КакПоследовательность().Фильтровать((Индекс, Элемент) -> Индекс % 2 == 0 и Элемент > 10) // [11, 18]

ФильтроватьПоТипу​

ФильтроватьПоТипу<ЦелевойТип>(): Последовательность<ЦелевойТип>
ЦелевойТип: тип оставляемых элементов.

Фильтрует обходимое, оставляя только значения типа TargetType и возвращает последовательность из этих элементов.

Примеры​

знч Объекты = [1, 2, "3", "4", True, False].КакПоследовательность()
знч Числа = Объекты.ФильтроватьПоТипу<Число>().ВМассив() // [1, 2]

Список унаследованных методов​

Объект​

ВСтроку

ПолучитьТип

Представление

Последнее обновление