A1sAR — Массивы

🚀 Быстрый старт

Два подхода

A1sAR поддерживает и классические статические функции, и мощный Fluent интерфейс для цепочек.

FluentPipeline.bsl

                        // ✨ Fluent API — читается как предложение

// Базовая цепочка: Фильтр -> Сортировка -> Выборка
Топ5 = A1sAR.On(СписокЦен)
    .Filter("v > 1000")    // Дороже 1000
    .Sort()                 // По возрастанию
    .Reverse()              // По убыванию
    .Take(5)                // Первые 5
    .Value();               // ↩ Массив

// Map и Reduce (Функциональное программирование)
// Увеличить каждый элемент на 10%
СНадбавкой = A1sAR.On(БазовыеЗначения)
    .Map("v * 1.1")
    .Value();

// Произведение всех элементов (Custom Reduce)
Произведение = A1sAR.On(A1sAR.Of(2, 3, 4))
    .Reduce("acc * v", 1); 
// 1 * 2 * 3 * 4 = 24
                    

StaticAPI.bsl

                        // 📦 Static API — Утилиты и Set-операции

// Создание и Генерация
Массив = A1sAR.Of(1, 2, 3);
Нули = A1sAR.OfN(10, 0); // [0, 0, ...]

// Set-операции (до 8 массивов)
Группа1 = A1sAR.Of("Иван", "Мария");
Группа2 = A1sAR.Of("Мария", "Петр");

// Объединение (уникальные значения)
Все = A1sAR.Union(Группа1, Группа2); 
// ["Иван", "Мария", "Петр"]

// Пересечение (кто есть в обоих)
Общие = A1sAR.Intersection(Группа1, Группа2);
// ["Мария"]

// Разность (кто есть только в первом)
Разные = A1sAR.Difference(Группа1, Группа2);
// ["Иван"]
                    

Задача	❌ Было (Классика)	✅ Стало (A1sAR)
Фильтрация	`НовыйМассив = Новый Массив; Для Каждого Эл Из Массив Цикл Если Эл > 0 Тогда НовыйМассив.Добавить(Эл); КонецЕсли; КонецЦикла;`	`Результат = A1sAR.On(Массив) .Filter("v > 0") .Value();`
Сортировка	`Список = Новый СписокЗначений; Список.ЗагрузитьЗначения(Массив); Список.СортироватьПоЗначению(); Массив = Список.ВыгрузитьЗначения();`	`Результат = A1sAR.Sort(Массив);`
Дубликаты	`// O(N^2) вложенные циклы`	`Результат = A1sAR.RemoveDuplicates(Массив); // O(N) через Соответствие`

✨ Возможности

Почему A1sAR?

🔗

Fluent Chains

Цепочки вызовов. Map, Filter, Sort, Reduce — всё в одной строке через точку.

🧮

Set Operations

Мощные операции над множествами: Union, Intersection, Difference без циклов.

⚡

Performance O(N)

Уникализация использует Map внутри, что делает её мгновенной даже на 100к элементов.

🎩

Type Magic

Методы PickByType и GroupByType мгновенно разделяют смешанные данные.

✂️

Slice & Split

Take, Skip, Slice, SplitByIndex — удобная работа с окнами данных.

🏗️

Generators

Метод OfN(Size, Value) позволяет создать массивы любого размера с одним значением.

🧠 Deep Dive

Продвинутые сценарии

Разбор уникальных функций модуля.

                        TypeMagic.bsl
                    

                    // ═══════════════════════════════════════════════════════════
// СЦЕНАРИЙ 1: Работа с смешанными данными (Type Magic)
// ═══════════════════════════════════════════════════════════

// Допустим, мы получили коллекцию разных типов
Смесь = A1sAR.Of(
    100, 
    "Оплата", 
    Справочники.Номенклатура.НайтиПоНаименованию("Товар"),
    ТекущаяДата()
);

// ✅ Выбрать только числа (например, для суммы)
Цифры = A1sAR.PickNumbers(Смесь); 
// Результат: [100]

// ✅ Группировать по типам (возвращает Соответствие)
// Это очень удобно для разбора JSON или универсальных коллекций
ПоТипам = A1sAR.GroupByType(Смесь);

// ПоТипам[Тип("Число")]      -> [100]
// ПоТипам[Тип("Строка")]     -> ["Оплата"]
// ПоТипам[Тип("СправочникСсылка")] -> [Номенклатура]
                

                        SliceAndSplit.bsl
                    

                    // ═══════════════════════════════════════════════════════════
// СЦЕНАРИЙ 2: Разделение массивов
// ═══════════════════════════════════════════════════════════

// 1. Разделить по маркеру (например, "---")
Массив = A1sAR.Of("A", "B", "---", "C", "D");

Части = A1sAR.Split(Массив, "---");

// Части.Before -> ["A", "B"]
// Части.After  -> ["C", "D"]

// 2. Разделить по индексу (SplitAt)
Части = A1sAR.SplitAt(Массив, 2);

// Части.Before -> ["A", "B"]
// Части.After  -> ["---", "C", "D"]
                

🔗 Fluent API

A1sDP_AR — Методы цепочек

Точка входа: A1sAR.On(Массив)

🔧 Трансформаторы (возвращают ЭтотОбъект)

Метод	Описание
`.Filter("expr")`	Фильтрация. В выражении доступна переменная `v` (элемент).
`.Map("expr")`	Преобразование каждого элемента.
`.Reduce("expr", Init)`	Свертка. Доступны `acc` (аккумулятор) и `v`.
`.Sort() / Reverse()`	Сортировка и реверс.
`.Take(N) / Skip(N) / Slice(Start, End)`	Работа с окном данных.
`.Flatten()`	Разворачивание вложенных массивов (1 уровень).
`.Union(...)`	Объединение множеств (только уникальные).
`.Add(val) / AddAll(arr)`	Добавление элементов.

✅ Терминаторы (возвращают результат)

Метод	Возвращает	Описание
`.Value()`	Array	Результирующий массив.
`.ToFixed()`	FixedArray	Фиксированный массив (требует A1sFixed).
`.Count()`	Number	Количество элементов.
`.Total()`	Number	Сумма числовых элементов.
`.Avg() / Min() / Max()`	Number	Агрегация.
`.First() / Last()`	Variant	Элемент начала/конца.
`.Contains(Value)`	Boolean	Проверка наличия.

📦 Static API

A1sAR — Статические функции

🔹 Создание и Утилиты

Функция	Описание
`Of(...values)`	Создает массив из аргументов (до 40 шт).
`OfN(Size, Value)`	Создает массив N элементов с одним значением.
`OfFixed(...)`	Создает ФиксированныйМассив (требует A1sFixed).
`Sort(Array) / Reverse(Array)`	Сортировка и реверс массива.
`RemoveDuplicates(Array)`	O(N) удаление дубликатов.
`Join(Array, Sep)`	Объединение в строку.
`Contains(Array, Val)`	Проверка наличия.

🔹 Type Magic

Функция	Описание
`PickByType(Array, Type)`	Выбирает элементы указанного типа (или массива типов).
`OmitByType(Array, Type)`	Исключает элементы указанного типа.
`PickNumbers/Strings/Dates(Array)`	Шорткаты для базовых типов.
`PickRefs(Array)`	Только ссылки (справочники, документы).
`GroupByType(Array)`	Группирует элементы по типу → Соответствие.

🔹 Set Operations

Функция	Описание
`Union(...arrays)`	Объединение множеств (уникальные).
`Intersection(...arrays)`	Пересечение (элементы во всех массивах).
`Difference(Array1, ...others)`	Разность (первый минус остальные).
`Concatenate(...)`	Простое соединение (дубликаты сохраняются).