0xD34F

const getDuplicates = (arr, key) => Array
  .from(arr.reduce((acc, { [key]: n }) => acc.set(n, -~acc.get(n)), new Map))
  .filter(n => n[1] > 1)
  .map(n => n[0]);


const duplicates = getDuplicates(arr, 1);

или

const getDuplicates = (arr, key = n => n) => Array
  .from(arr.reduce((acc, n) => (n = key(n), acc.set(n, acc.has(n))), new Map))
  .reduce((acc, n) => (n[1] && acc.push(n[0]), acc), []);


const duplicates = getDuplicates(arr, n => n[1]);

или

const getDuplicates = arr =>
  [...arr.reduce((acc, n) => (
    acc[+acc[0].has(n)].add(n),
    acc
  ), [ new Set, new Set ])[1]];


const duplicates = getDuplicates(arr.map(n => n[1]));

Не поможет ли lodash?

const duplicates = _(arr)
  .map(n => n[1])
  .groupBy()
  .filter(n => n.length > 1)
  .map(n => n[0])
  .value();

function fib(max) {
  const next = (p1, p2) => p2 <= max ? ',' + p2 + next(p1 + p2, p1) : '';
  return 0 + next(1, 1);
}

fib(0)   // "0"
fib(1)   // "0,1,1"
fib(10)  // "0,1,1,2,3,5,8"
fib(45)  // "0,1,1,2,3,5,8,13,21,34"
fib(100) // "0,1,1,2,3,5,8,13,21,34,55,89"

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

https://jsfiddle.net/0sodx8b7/

UPD. Если копипастить разметку и считывать настройки из атрибутов, то так: https://jsfiddle.net/0sodx8b7/1/

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

async function processData(data) {
  const result = [];

  for (const { id, k } of data) {
    result.push(k ? await api.getData(id) : id);
  }

  return result;
}

Параллельно:

function processData(data) {
  return Promise.all(data.map(({ id, k }) => k ? api.getData(id) : id));
}

{
  in: str.match(/(?<=\[).+?(?=\])/g),
  out: str.match(/(?<=^|\])[^\[]+/g),
}

for (const arr of [ arr1, arr2 /* и т.д., можете искать в любом количестве массивов */ ]) {
  const source = arr.find(n => n.id === target.id);
  if (source) {
    Object.assign(target, source);
    break;
  }
}

Не игнорируется.

Встречный вопрос - как один элемент может находиться сразу в двух местах? Нет-нет, можете не отвечать. Очевидно же, что никак. Чтобы добавлять одинаковые элементы в разные места, делайте копии:

function render(message) {
  const p = document.createElement('p');
  p.textContent = message;
  windowChatUser1.append(p);
  windowChatUser2.append(p.cloneNode(true));
}

Или вместо создания элементов собирайте разметку:

function render(message) {
  const html = `<p>${message}</p>`;
  windowChatUser1.insertAdjacentHTML('beforeend', html);
  windowChatUser2.insertAdjacentHTML('beforeend', html);
}

Работает. Но поскольку в момент инициализации всплывающее окно скрыто, то размеры получаются нулевыми. Плагин слушает изменение размеров окна, чтобы поддерживать размеры контейнера и содержимого в актуальном состоянии, так что добавьте в настройки magnificPopup'а:

callbacks: {
  open() {
    $(window).trigger('resize');
  },
},

Правильное. Ключи - всегда строки. Так что разницы между 0 и '0' нет. Хотите чтобы была - вместо простого объекта используйте Map.

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

Во-вторых, обработчик остаётся висеть потому, что

Удаление перехватывающего обработчика никак не затрагивает не-перехватывающюю версию этого же обработчика, и наоборот.

const mod = (a, b) => ((a % b) + b) % b;
// или
const mod = (a, b) => a - (b * Math.floor(a / b));

console.log([ 12, 367, -54, 789, -567 ].map(n => mod(n, 360)));

вместо arr[index] используйте arr[index % arr.length]

Сравниваем числовые эквиваленты элементов, а запоминаем максимальный как он есть:

const maxStr = arr.length
  ? arr.reduce((max, n) => +n < +max ? max : n)
  : null;

Или, в более общем виде:

function max(data, key = n => n) {
  const getVal = key instanceof Function ? key : n => n[key];
  let result = null;

  for (const n of data) {
    const val = getVal(n);
    result = (!result || result[1] < val) ? [ n, val ] : result;
  }

  return result?.[0];
}


const maxStr = max(arr, Number);

data.flatMap(item => item.events.flatMap(event => event.params.map(param => ({
  name: item.name,
  event_key: event.event_key,
  ...param,
}))))

Где, во что и сколько слов надо обернуть:

const className = 'heading';
const wrapperTag = 'span';
const wrapCount = 3;

Оборачиваем:

document.querySelectorAll(`.${className}`).forEach(n => {
  const words = n.innerText.split(' ');
  const iMin = Math.max(0, Math.floor((words.length - wrapCount) / 2));
  const iMax = Math.min(words.length - 1, iMin + wrapCount - 1);

  words[iMin] = `<${wrapperTag}>${words[iMin]}`;
  words[iMax] = `${words[iMax]}</${wrapperTag}>`;

  n.innerHTML = words.join(' ');
});

или

for (const n of document.getElementsByClassName(className)) {
  const words = n.textContent.split(/(?= )/);
  const wrapper = document.createElement(wrapperTag);

  wrapper.textContent = words
    .splice(Math.max(0, (words.length - wrapCount) >> 1), wrapCount, wrapper)
    .join('');

  n.replaceChildren(...words);
}

function fadeToggle(selector, delay) {
  let index = -1;

  return setInterval($items => {
    $items.eq(index).fadeOut('slow');
    index = (index + 1) % $items.length;
    $items.eq(index).fadeIn('slow');
  }, delay, $(selector));
}


const intervalId = fadeToggle('.sloi', 1000);

for (let i = begin; i <= end; i++) {
  let str = '';
  if (!(i % 3)) {
    str += 'Fizz';
  }
  if (!(i % 5)) {
    str += 'Buzz';
  }
  console.log(str || i);
}

А вообще, давайте лучше сократим до 0 if'ов:

console.log(Array.from({ length: end - begin + 1 }, (_, i) => {
  i += begin;
  return (i % 3 ? '' : 'Fizz') + (i % 5 ? '' : 'Buzz') || i;
}).join('\n'));

// или

for (let i = ~-begin; ++i <= end;) {
  console.log('FizzBuzz'.slice(i % 3 && 4, 4 << !(i % 5)) || i);
}

А почему оно не должно быть undefined? Кто вам обещал, что подобным образом можно достучаться до настроек редактора?

Для этого есть метод getContext: editor.getContext().options.imageUploadUrl.

Если делать ровно то, что спрошено:

const roots = [];

COLLECT_ROOTS:
for (const n of arr) {
  for (const m of arr) {
    if (m.id === n.root_id) {
      continue COLLECT_ROOTS;
    }
  }

  roots.push(n);
}

// или

const roots = arr.filter(function(n) {
  return !this.has(n.root_id);
}, new Set(arr.map(n => n.id)));

// или

const roots = (function get(i, n = arr[i]) {
  return n
    ? [].concat(arr.every(m => m.id !== n.root_id) ? n : [], get(-~i))
    : []
})(0);

Но вообще, дерево-то можно и собрать, результатом как раз будет массив искомых объектов (конечно, не без дополнения в виде вложенных массивов):

function createTree({
  data,
  key = 'id',
  parentKey = 'parentId',
  childrenKey = 'children',
}) {
  const tree = Object.fromEntries(data.map(n => [
    n[key],
    { ...n, [childrenKey]: [] },
  ]));

  return Object.values(tree).filter(n => (
    !tree[n[parentKey]]?.[childrenKey].push(n)
  ));
}

const tree = createTree({
  data: arr,
  parentKey: 'root_id',
});