Сергей Соколов

async function Func() {
  console.log('START');

  await new Promise(r => {
    $('div').one('click', () => (console.log('CLICK'), r()));
  });

  console.log('END');
}

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

const find = (data, test, key) =>
  test(key, data)
    ? data
    : data === Object(data)
      ? Object.entries(data).reduce((found, n) =>
          found !== null ? found : find(n[1], test, n[0])
        , null)
      : null;

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

function find(data, test) {
  for (const stack = [ [ , data ] ]; stack.length;) {
    const [ k, v ] = stack.pop();
    if (test(k, v)) {
      return v;
    } else if (v instanceof Object) {
      stack.push(...Object.entries(v).reverse());
    }
  }

  return null;
}

Ищем:

const value = find(вложенный_объект, k => k === 'ключ');

С каждым "неудачным" вызовом функции 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 result = Object.entries(obj).reduce((acc, [key, nums]) => {
    if (Array.isArray(nums)) {
      acc[key] = nums.reduce((acc, num) => acc + num, 0) / nums.length;
    }
    return acc;
  }, {});

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() ]);

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

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

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

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

const closest = distances.reduce((acc, val) => {
  if (acc.distance === 0) return val;
  if (val.distance === 0) return acc;
  return acc.distance < val.distance ? acc : val;
});

У нуля знака нет, он не является ни положительным, ни отрицательным числом.

Знак у нуля появляется в некоторых реализациях машинной арифметики, но никакого отношения к настоящему нулю из математики он не имеет

https://learn.javascript.ru/string#dostup-k-simvolam