0xD34F

str.replace(/\.? /g, '-')

Делегирование, назначаем обработчик клика один раз:

// при клике по кнопке определяем её индекс и хватаем .photos__like-count с таким же индексом
document.addEventListener('click', ({ target: t }) => {
  if (t.classList.contains('photos__like-icon')) {
    const index = [...document.querySelectorAll('.photos__like-icon')].indexOf(t);
    const counter = document.querySelectorAll('.photos__like-count')[index];
    const count = counter.textContent;
    counter.textContent = t.classList.toggle('active') ? -~count : ~-count;
  }
});

// но если у каждой пары icon-count если отдельный общий предок, то можно и попроще сделать
document.addEventListener('click', ({ target: t }) => {
  if (t.matches('.photos__like-icon')) {
    t
      .closest('селектор общего предка кнопки и элемента с количеством')
      .querySelector('.photos__like-count')
      .textContent -= t.classList.toggle('active') ? -1 : 1;
  }
});

Назначаем обработчик клика каждой кнопке индивидуально:

const toggleLike = function({ target: t }) {
  this[t.dataset.index].innerText -= [ 1, -1 ][+t.classList.toggle('active')];
}.bind(document.querySelectorAll('.photos__like-count'));

document.querySelectorAll('.photos__like-icon').forEach((n, i) => {
  n.dataset.index = i;
  n.addEventListener('click', toggleLike);
});

// или, при наличии отдельных общих предков у каждой пары .photos__like-icon и .photos__like-count
const toggleLike = ({ target: t }) => t
  .closest('селектор общего предка кнопки и элемента с количеством')
  .querySelector('.photos__like-count')
  .innerText -= t.classList.toggle('active') ? -1 : 1;

for (const n of document.querySelectorAll('.photos__like-icon')) {
  n.addEventListener('click', toggleLike);
}

Слушать событие mousemove, в зависимости от event.movementX задавать transform: translateX. Например.

function setAnimation(el) {
  $(el).css('animation', `shadow-pulse ${1 + Math.random() * 3}s`);
}

$('.mr-2').on('animationend', function() {
  $(this).css('animation', '');
  setTimeout(setAnimation, 0, this);
}).get().forEach(setAnimation);

$('.search').on('input', function() {
  const search = $(this).val().trim().toLowerCase();

  $('.metro-line__item')
    .hide()
    .filter((i, n) => $('.metro__name', n).text().toLowerCase().includes(search))
    .show();

  $('.metro-line')
    .show()
    .not(':has(.metro-line__item:visible)')
    .hide();
});

или

.hidden {
  display: none;
}

document.querySelector('.search').addEventListener('input', e => {
  const search = e.target.value.trim().toLowerCase();

  document.querySelectorAll('.metro-line__item').forEach(n => {
    const name = n.querySelector('.metro__name').textContent.toLowerCase();
    n.classList.toggle('hidden', !name.includes(search));
  });

  document.querySelectorAll('.metro-line').forEach(n => {
    n.classList.toggle('hidden', !n.querySelector('.metro-line__item:not(.hidden)'));
  });
});

const className = 'класс, который не надо удалять';


// Если известно, что класс присутствует или должен быть добавлен в случае отсутствия:
element.className = className;

// Если известно, что класс отсутствует и не должен быть добавлен:
element.className = '';

// Если неизвестно, присутствует ли класс и в случае отсутствия он не должен быть добавлен:
element.className = element.classList.contains(className) ? className : '';
// или
element.classList.remove(...[...element.classList].filter(n => n !== className));

function createTree(arr, structure) {
  const tree = Object.fromEntries(arr.map(n => [ n.id, { ...n } ]));
  const nonRootIds = structure.flatMap(n => n.children);

  structure.forEach(n => tree[n.id].elements = n.children.map(m => tree[m]));

  return Object.values(tree).filter(n => !nonRootIds.includes(n.id));
}

str.replace(/(\d)\1+/g, '$1')

// или

''.concat(...str.split(/(\d)\1+/))

// или

Array.from(str).filter((n, i, a) => Number.isNaN(+n) || a[i - 1] !== n).join('')

// или

[...str.matchAll(/(\D+)|(?:(\d)\2*)/g)].reduce((acc, n) => acc + (n[1] ?? n[2]), '')

Как будем определять, надо ли отправить элемент в конец массива:

const checkItem = item => item.status === 'выполнено';

Изменяем существующий массив:

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

// или

arr.reduceRight((_, n, i, a) => checkItem(n) && a.push(a.splice(i, 1)[0]), null);

// или

arr
  .reduce((acc, n, i) => (
    arr[i - acc.length] = n,
    checkItem(n) && acc.push(n),
    acc
  ), [])
  .forEach((n, i, a) => arr[arr.length - a.length + i] = n);

Создаём новый:

const newArr = arr
  .reduce((acc, n) => (
    acc[+checkItem(n)].push(n),
    acc
  ), [ [], [] ])
  .flat();

// или

const newArr = arr.reduce((acc, n) => (
  acc[checkItem(n) ? 'push' : 'unshift'](n),
  acc
), []);

// или

const newArr = [
  ...arr.filter(n => !checkItem(n)),
  ...arr.filter(checkItem),
];

.card.show .text {
  display: block;
}

const containerSelector = '.card';
const buttonSelector = 'button';
const activeClass = 'show';

document.addEventListener('click', e => {
  const button = e.target.closest(buttonSelector);
  const container = button && button.closest(containerSelector);
  container && container.classList.toggle(activeClass);
});

// или

document
  .querySelectorAll(`${containerSelector} ${buttonSelector}`)
  .forEach(n => n.addEventListener('click', onClick));

function onClick() {
  this.closest(containerSelector).classList.toggle(activeClass);
}

Идентификаторы объектов, которые хотим получить, сложим в массив:

const ids = [ 9, 10 ];

Вложенные массивы объектов соберём в один общий:

const items = arr.flatMap(n => n.items);

// или

const items = Array.prototype.concat.apply([], arr.map(n => n.items));

// или

const items = arr.reduce((acc, n) => (acc.push(...n.items), acc), []);

Извлечём объекты:

const result = items.filter(n => ids.includes(n.id));

// или

const result = items.filter(function(n) {
  return this.has(n.id);
}, new Set(ids));

// или

const itemsObj = Object.fromEntries(items.map(n => [ n.id, n ]));
const result = ids.reduce((acc, n) => ((n = itemsObj[n]) && acc.push(n), acc), []);

<button data-step="+1">PREV</button>
<button data-step="-1">NEXT</button>

const sliderSelector = '.slider';
const blockSelector = '.block';
const buttonDataAttr = 'step';
const buttonSelector = `[data-${buttonDataAttr}]`;
const activeClass = 'active';
const getActiveBlockIndex = () => ((-pos % len) + len) % len;
const getSliderRotation = () => 'rotate(' + pos * 360 / len + 'deg)';
let pos = 0;

Вот jquery:

const $slider = $(sliderSelector);
const $blocks = $slider.find(blockSelector);
const len = $blocks.length;

$(buttonSelector).click(function() {
  $blocks.eq(getActiveBlockIndex()).removeClass(activeClass);
  pos += parseInt($(this).data(buttonDataAttr));
  $slider.css('transform', getSliderRotation());
  $blocks.eq(getActiveBlockIndex()).addClass(activeClass);
});

А вот jquery нет:

const slider = document.querySelector(sliderSelector);
const blocks = slider.querySelectorAll(blockSelector);
const len = blocks.length;

document.querySelectorAll(buttonSelector).forEach(function(n) {
  n.addEventListener('click', this);
}, function() {
  blocks[getActiveBlockIndex()].classList.remove(activeClass);
  pos += +this.dataset[buttonDataAttr];
  slider.style.transform = getSliderRotation();
  blocks[getActiveBlockIndex()].classList.add(activeClass);
});

Метод search использует для поиска регулярные выражения, и если аргумент таковым не является, он будет в регулярку преобразован. Круглые скобки в регулярных выражениях являются спецсимволами, так что если хотите, чтобы скобка была просто скобкой, её надо экранировать. Поставьте перед ней два обратных слэша: .search('\\('). Или один, если замените строку на литерал регулярного выражения: .search(/\(/).

Кого, что и как:

const selector = '.test_wr .test_block';
const propName = 'top';
const getVal = i => `${i * 100}px`;

Вот так всё просто получается:

$(selector).css(propName, getVal);

// или

document.querySelectorAll(selector).forEach((n, i) => {
  n.style[propName] = getVal(i);
});

json.results.map(({ lists, volume }) => {
  return lists.map(({ tags, list }) => {
    return tags.map(tag => ({ volume, list, tag }));
  });
}).flat(2)

Сначала превращаем плоский массив во вложенный:

function createTreeData(data, idKey, parentKey) {
  const tree = Object.fromEntries(data.map(n => [ n[idKey], { ...n, children: [] } ]));

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

Затем из вложенного массива можно собрать разметку:

const createTreeHTML = data =>
  Array.isArray(data) && data.length
    ? `<ul>${data.map(n => `
         <li>
           ${n.name}
           ${createTreeHTML(n.children)}
         </li>`).join('')}
       </ul>`
    : '';

Или создавать элементы напрямую:

const createTreeElement = data =>
  data instanceof Array && data.length
    ? data.reduce((ul, n) => (
        ul.append(document.createElement('li')),
        ul.lastChild.append(n.name, createTreeElement(n.children)),
        ul
      ), document.createElement('ul'))
    : '';

Вот так всё просто получается:

const treeData = createTreeData(obj, 'id', 'parent_id');

document.body.insertAdjacentHTML('beforeend', createTreeHTML(treeData));
document.body.append(createTreeElement(treeData));

Но вообще, можно ещё проще - без собирания вложенного массива:

function createTreeElements(arr, idKey, parentKey) {
  const tree = arr.reduce((acc, { [parentKey]: n }) => (
    acc[n] = acc[n] || document.createElement('ul'),
    acc
  ), {});

  arr.forEach(n => (
    tree[n[parentKey]].append(document.createElement('li')),
    tree[n[parentKey]].lastChild.append(n.name, tree[n[idKey]] || '')
  ));

  return Object.values(tree).filter(n => !n.parentNode);
}


document.body.append(...createTreeElements(obj, 'id', 'parent_id'));

const result = Object
  .entries(arr.reduce((acc, [ n ], i) => ((acc[n] = acc[n] || []).push(i), acc), {}))
  .map(n => ({ [n[0]]: n[1] }));

function filterByMinMax(arr, [ min, max ], key = n => n) {
  const getVal = key instanceof Function ? key : n => n[key];
  return arr.filter(n => {
    const val = getVal(n);
    return (min == null || min <= val) && (max == null || val <= max);
  });
}


const d1 = filterByMinMax(chartPoints, [ new Date('2019-02-19') ], n => new Date(n.date));
const d2 = filterByMinMax(chartPoints, [ , '2019-01-23' ], n => n.date);
const d3 = filterByMinMax(chartPoints, [ '2019-02-12', '2019-02-26' ], 'date');

Object.values(arr.reduce((acc, row) => {
  row.forEach((n, i, a) => i && (acc[n] = acc[n] || [n]).push(a[0]));
  return acc;
}, {}))