0xD34F

Object.values(orders.reduce((acc, n) => {
  const date = n.date.split(' ')[0];

  ((acc[date] ??= {
    date,
    documents: {},
  }).documents[n.docTypesName] ??= {
    date: n.date,
    docId: n.docId,
    docTypesName: n.docTypesName,
    products: [],
  }).products.push({
    name: n.name,
    price: n.price,
    image: n.image,
    qunatity: n.quantity,
  });

  return acc;
}, {})).map(n => (n.documents = Object.values(n.documents), n))

С каждым "неудачным" вызовом функции camel у вас добавляется ещё один промис, ждущий разрешения. 10 "неудачных" вызовов - 10 промисов в режиме ожидания. 1000 попыток - 1000 промисов. И т.д. Каждый съедает немного памяти.

Не нужно вам тут никакого "самовызова". Вместо рекурсии сделайте цикл:

async function test() {
  let result = null;

  do {
    result = await camel() || await new Promise(r => setTimeout(r, 1000));
  } while (!result);

  return result;
}

const days = 46330;
const date = new Date();
date.setDate(date.getDate() + days);
const dateStr = date.toLocaleDateString('ru-RU', {
  day: 'numeric',
  month: 'short',
  year: 'numeric',
});

console.log(dateStr);

Рекурсия есть:

const flatten = arr => [].concat(...arr.map(n => Array.isArray(n) ? flatten(n) : n));

// или

function flatten(arr) {
  const result = [];

  for (const n of arr) {
    if (n?.constructor === Array) {
      [].push.apply(result, flatten(n));
    } else {
      result.push(n);
    }
  }

  return result;
}

Рекурсии нет:

function flatten(arr) {
  const result = [];
  const stack = [];

  for (let i = 0; i < arr.length || stack.length; i++) {
    if (i === arr.length) {
      [ i, arr ] = stack.pop();
    } else if (arr[i] instanceof Array) {
      stack.push([ i, arr ]);
      [ i, arr ] = [ -1, arr[i] ];
    } else {
      result.push(arr[i]);
    }
  }
  
  return result;
}

// или

function flatten([...arr]) {
  for (let i = 0; i < arr.length; i++) {
    const n = arr[i];
    if (n?.[Symbol.iterator] && typeof n !== 'string') {
      arr.splice(i--, 1, ...n);
    }
  }

  return arr;
}

Никак, forEach прервать нельзя. Да и не надо тут никаких forEach'ей, больше подойдёт some. И функция не нужна, код совсем короткий получается:

words.some(n => str.includes(n))

const openSelector = '.block__item';
const closeSelector = '.close';
const itemSelector = '.popup';
const activeClass = 'popup--active';


// делегирование, общий обработчик клика - для открытия и закрытия сразу,
// назначается один раз для всех элементов;
// связь кнопок открытия попапов с попапами через data-атрибут
document.addEventListener('click', ({ target: t }) => {
  let item = t.closest(closeSelector)?.closest(itemSelector);
  if (!item) {
    const open = t.closest(openSelector);
    if (open) {
      item = document.querySelector(`${itemSelector}.${open.dataset.popup}`);
    }
  }

  item?.classList.toggle(activeClass);
});

// или, отдельные обработчики клика для открытия и закрытия,
// назначаются каждому элементу индивидуально;
// связь кнопок открытия попапов с попапами через индексы
const open = [...document.querySelectorAll(openSelector)];
const close = document.querySelectorAll(closeSelector);
const items = document.querySelectorAll(itemSelector);

const onOpenClick = e => items[open.indexOf(e.currentTarget)].classList.add(activeClass);
open.forEach(n => n.addEventListener('click', onOpenClick));

const onCloseClick = e => e.currentTarget.closest(itemSelector).classList.remove(activeClass);
close.forEach(n => n.addEventListener('click', onCloseClick));

Вопрос бессмысленный - код работает. Между "не работает" и "работает не так, как задумано" есть существенная разница. Попытайтесь её осознать.

params = format({

Зачем здесь вызов format? Не нужен.

params_list = Object.values(params)
console.log(params_list)
for (var v in params_list) {s=s+v+'='+params[v]+'&'}

Вот это конечно дичь дикая. Чтобы такое написать, надо не знать, как работает цикл for-in. Разберитесь. Не нужен тут массив значений, перебирать надо было сразу params.

А вообще, всё это делается гораздо проще:

function format(params, method) {
  return `https://api.vk.com/method/${method}?${new URLSearchParams(params)}`;
}

console.log(format({ access_token, version }, method));

const sum = arr.reduceRight((acc, n) => n && acc + n, 0);

или

let sum = 0;
for (let i = 0; arr[i]; sum += arr[i++]) ;

или

let sum = 0;
for (const n of arr) {
  if (!n) {
    break;
  }
  sum += n;
}

или

const sum = (function sum(i, n = arr[i]) {
  return n ? n + sum(i + 1) : 0;
})(0);

Это "сложение" (не сложение) работает только для целых чисел >= 0.

Если передать в Array одно число, будет создан (будет попытка создания - отрицательные и нецелые числа приведут к ошибке) массив указанной длины. Метод push может принимать несколько значений, а возвращает - новую длину массива, после добавления элементов. Т.е., в массив из трёх элементов добавили ещё четыре, и получили длину.

Сортируем существующий массив:

arr.sort((a, b) => {
  return Number.isNaN(+a) || Number.isNaN(+b)
    ? a.localeCompare(b)
    : a - b;
});

// или

arr.sort((a, b) => (a - b) || a.localeCompare(b));

Собираем отсортированный новый:

const sorted = (arr, keys) => arr
  .map(n => [ n ].concat(keys(n)))
  .sort((a, b) => {
    let diff = 0;
    a.find((n, i) => diff = i && ((n < b[i]) ? -1 : +(n > b[i])));
    return diff;
  })
  .map(n => n[0]);

const sortedArr = sorted(arr, n => [ +n, n.toLowerCase() ]);

Давайте напишем функцию, принимающую массив и, опционально, имя свойства, которое должно будет содержать ссылку на следующий элемент списка. Чтобы можно было делать так:

const list = arrToSinglyLinkedList(arr, 'child');

Вариант раз - перебираем массив от конца к началу, на каждом шаге создаём копию текущего элемента массива, к которой будет добавлена ссылка на объект, полученный на предыдущем шаге:

const arrToSinglyLinkedList = (arr, nextKey = 'next') =>
  arr.reduceRight((acc, n) => ({ ...n, [nextKey]: acc }), null);

// или

function arrToSinglyLinkedList(arr, nextKey = 'next') {
  let list = null;

  for (let i = arr.length; i--;) {
    const node = Object.assign({}, arr[i]);
    node[nextKey] = list;
    list = node;
  }

  return list;
}

Вариант два - рекурсия. Понадобится дополнительный параметр - индекс текущего элемента массива, если элемент с таким индексом есть, то создаём элемент списка, а в качестве следующего записываем результат рекурсивного вызова с индексом, увеличенным на единицу:

const arrToSinglyLinkedList = (arr, nextKey = 'next', i = 0) =>
  i < arr.length
    ? Object.fromEntries([
        ...Object.entries(arr[i]),
        [ nextKey, arrToSinglyLinkedList(arr, nextKey, -~i) ]
      ])
    : null;

// или

function arrToSinglyLinkedList(arr, nextKey = 'next', i = 0, n = arr[i]) {
  const node = n ? {} : null;
  if (node) {
    for (const k in n) {
      if (n.hasOwnProperty(k)) {
        node[k] = n[k];
      }
    }
    node[nextKey] = arrToSinglyLinkedList(arr, nextKey, i + 1);
  }

  return node;
}

const items = document.querySelectorAll('.b1');
let toggle = 0;

document.querySelector('button').addEventListener('click', () => {
  toggle ^= 1;
  items.forEach((n, i) => n.classList.toggle('_tog-sw', i & 1 ^ toggle));
});

Используйте currentTarget, если внутри обработчика нужен элемент, к которому обработчик привязан.

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

Ещё бывает так (не ваш случай, но упомянуть стоит), что обработчик висит выше нужного элемента - в этом случае можно подняться до него от target с помощью closest.

Между "не корректно" и "не так, как мной задумано" есть существенная разница.

Всё работает так, как и должно. Обратите внимание на значения атрибута name - они совпадают у разных строк.

А вообще, две радиокнопки тут не нужны - достаточно одного чекбокса.

const word = 'сейчас';

const newStr = str.replace(RegExp(`(?<=(^|\\s)${word})\\s.*`), '');

Правда, подозреваю, что вам надо не совсем это. Может, заменить цифры в конце строки? Это было бы проще:

str.replace(/\d+$/, новое_число)

const sum = arr => arr
  .flatMap(Object.entries)
  .reduce((acc, [ k, v ]) => (
    acc[k] = acc.hasOwnProperty(k) ? acc[k] + v : v,
    acc
  ), {});


const obj = sum(arr);

Кто у элемента родитель, какой класс обозначает активность, и сам элемент:

const parent = document.querySelector('.xlist');
const className = 'active';
const el = parent.querySelector(`:scope > .${className}`);

Какие есть варианты получения индекса:

const index = el ? [...parent.children].indexOf(el) : -1;

или

let index = -1;
for (let n = el; n; n = n.previousElementSibling, index++) ;

или

const index = Array.prototype.findIndex.call(
  parent.children,
  n => n.classList.contains(className)
);

или

const { children } = parent;
let index = children.length;
while (index-- && !children[index].matches(`.${className}`)) ;

- ([a-zA-Z0-9]+)
+ ([\\w-]+\\/)+

- const linkBase = "ozon.ru";
+ const linkBase = "ozon\\.ru";

Работает.

Почему вы этого не видите? Погуглите, что такое всплытие событий. Затем, держа в голове свежеприобретённые знания, присмотритесь к этому коду:

function fb3cont() {

  b3Cont.classList.remove("__active");
}
document.onclick = function() {
  if (b3Cont.classList.contains("__active")) { fb3cont()};
}

orderBy(data, [ n => n.updatedEl ?? n.createdEl, 'desk' ])