0xD34F

if ( typeof arr[i] === 'number' ) {
 		x*= arr[i];

А что если arr[i + 1] окажется строкой? Сначала надо проверить всё, а уже потом вычислять (если потребуется) объединённое значение:

function bullshit(arr) {
  if (arr.every(n => typeof n === 'number')) {
    return arr.reduce((acc, n) => acc * n, 1);
  }

  if (arr.every(n => typeof n === 'string')) {
    return arr.join('');
  }

  return null;
}


bullshit([ 1, 2, 3 ]) // 6
bullshit([ 'a', 'b', 'c' ]) // 'abc'
bullshit([ 1, '!' ]) // null

или

function bullshit(arr) {
  const count = arr.reduce((acc, n) => {
    const type = typeof n;
    acc[type] = (acc[type] || 0) + 1;
    return acc;
  }, {});

  switch (arr.length) {
    case count.number: return arr.reduce((acc, n) => acc * n, 1);
    case count.string: return arr.join('');
    default: return null;
  }
}

Object.fromEntries(Object
  .entries(obj)
  .sort((a, b) => a[0] - b[0])
  .reduce((acc, [ k, v ], i, a) => (
    i && k - a[~-i][0] === 1 || acc.push([ k, 0 ]),
    acc[~-acc.length][1] += v,
    acc
  ), [])
)

const result = obj.people.filter(function(n) {
  return n.data && this.some(m => m.every(([ k, v ]) => n.data[k] === v));
}, arr.map(Object.entries));

Получаем один класс:

const className = Array
  .from(element.classList)
  .find(n => n.startsWith(classNamePrefix));

Получаем все, что есть:

const classNames = Array.prototype.filter.call(
  element.classList,
  n => !n.indexOf(classNamePrefix)
);

$('.wrap').on('input', function(e) {
  const valid = $(this).find('.valid').get().map(el => {
    if (el === e.target) {
      $(el).toggleClass('empty', !el.value);
    }

    return el.value;
  }).every(Boolean);

  $('.btn')
    .toggleClass('btn--isvalid', valid)
    .toggleClass('btn--novalid', !valid);
});

После подключения обработчиков событий, генерируйте само событие, типа $('.form-group').trigger('input').

https://jsfiddle.net/4Lg53bs8/

https://codepen.io/anon/pen/drPKJK?editors=1010

const classes = [
  { maxLen: 15, name: 'length-15' },
  { maxLen: 30, name: 'length-30' },
  { maxLen: 45, name: 'length-45' },
];

document.querySelectorAll('.container').forEach(n => {
  const len = n.textContent.length;
  const cls = classes.find(m => m.maxLen >= len);

  if (cls) {
    n.classList.add(cls.name);
  }
});

$('.data-item').on('input', 'input', function() {
  $(this).closest('.data-item').find('.ui-slider').slider('value', $(this).val());
});

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

document.querySelector('input').addEventListener('input', e => {
  const
    val = e.target.value,
    reg = RegExp(val, 'gi'),
    keys = [ 'firstName', 'lastName' ];

  document.querySelector('.autocomplete-suggestions__list').innerHTML = val && people
    .map(n => keys.map(k => n[k]).join(' '))
    .filter(n => (reg.lastIndex = 0, reg.test(n)))
    .map(n => `<div>${n.replace(reg, '<strong>$&</strong>')}</div>`)
    .join('');
});

Где, кто и что:

const containerSelector = '.field';
const textSelector = '.name';
const text = 'some name 1';

Скрываем:

document.querySelectorAll(`${containerSelector} ${textSelector}`).forEach(n => {
  if (n.innerText.indexOf(text) !== -1) {
    n.closest(containerSelector).style.visibility = 'hidden';
  }
});

или

.hidden {
  visibility: hidden;
}

for (const n of document.querySelectorAll(containerSelector)) {
  n.classList.toggle('hidden', n.querySelector(textSelector).textContent.includes(text));
}

Не удаляет, а переносит. Вставляйте копию элемента - замените

.html($(this).find('img'))

на

.html($(this).find('img').clone())

Переносите элементы .items-left, а проверяете количество .items-right. Думали, что класс сам собой заменится? Нет, так не будет.

https://jsfiddle.net/z7egafLc/

const getImg = url => fetch(url)
  .then(r => r.blob())
  .then(blob => new Promise(resolve => {
    const reader = new FileReader();
    reader.addEventListener('loadend', () => resolve({ image: reader.result }));
    reader.readAsDataURL(blob);
  }));


document.querySelector('button').addEventListener('click', async () => {
  const arrImg = await Promise.all(arr.map(n => getImg(`./images/${n}`)));
  console.log(arrImg);
});

const $items = $('.card');
const openedClass = 'card--opened';
const closedClass = 'card--closed';
const delay = 500;
const flip = $item => $item.removeClass(closedClass).addClass(openedClass);

Вариант раз - назначаем таймауты на переключение классов сразу всем элементам, с временем задержки, зависящим от индекса элемента:

$items.each((i, n) => setTimeout(flip, (i + 1) * delay, $(n)));

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

(function next(i) {
  if (i < $items.length) {
    setTimeout(() => {
      flip($items.eq(i));
      next(-~i);
    }, delay);
  }
})(0);

Вариант три - вместо таймаутов назначаем интервал:

let i = -1;
const intervalID = setInterval(() => {
  if (++i >= $items.length) {
    clearInterval(intervalID);
  } else {
    flip($items.eq(i));
  }
}, delay);

const obj = array.reduce((acc, n, i) => (
  acc[`filter${i + 1}`] = { ...baseFilter, prop: n },
  acc
), {});

или

const obj = {};
for (const [ i, n ] of array.entries()) {
  (obj['filter' + (-~i)] = Object.assign({}, baseFilter)).prop = n;
}

или

const obj = {};
for (let i = 0; i < array.length;) {
  const subobj = { prop: array[i] };
  for (const k in baseFilter) {
    subobj[k] = baseFilter[k];
  }
  obj['filter'.concat(++i)] = subobj;
}

MutationObserver