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

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

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

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

Сравнение

Ссылочное

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

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

Примеры​

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

знч Числа = [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]

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

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

Исключения​

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

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

Версия 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}]

Ограничить​

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

Исключения​

ИсключениеНедопустимыйАргумент - если Количество <= 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, Имя: "Вася"}]

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

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

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

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

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

Примеры​

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

Пропустить​

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

Исключения​

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

Примеры​

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

Свернуть​

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

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

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

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

Исключения​

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

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

Примеры​

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

Свернуть​

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

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

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

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

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

Примеры​

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

Соединить​

<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]

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

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

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

Примеры​

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

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

Объект​

ВСтроку

ПолучитьТип

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

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