0xD34F

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

const mustStay = arr => arr.some(n => n !== '');

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

const newArr = arr.filter(mustStay);

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

arr.reduceRight((_, n, i, a) => mustStay(n) || a.splice(i, 1), null);

// или

arr.splice(0, arr.length, ...arr.filter(mustStay));

// или

let numDeleted = 0;

for (const [ i, n ] of arr.entries()) {
  arr[i - numDeleted] = n;
  numDeleted += !mustStay(n);
}

arr.length -= numDeleted;

Есть вариант воспользоваться методом keys для получения итератора, отдающего индексы (доступен как для NodeList, так и для массивов), который затем можно развернуть в массив с помощью spread или Array.from или просто перебрать через for of:

[...divs.keys()].forEach(i => console.log(i));

// или

console.log(Array.from(divs.keys(), i => i * 100));

// или

for (const i of divs.keys()) {
  console.log(i);
}

О каких атрибуте и классе идёт речь:

const attrName = 'data-i';
const attrValues = [ 'qwe', 'asd', 'zxc' ];
const className = 'класс';

Просто добавляем класс:

document
  .querySelectorAll(attrValues.map(n => `[${attrName}="${n}"]`))
  .forEach(n => n.classList.add(className));

Или, также у неподходящих элементов, имеющих атрибут, класс удаляем:

for (const n of document.querySelectorAll(`[${attrName}]`)) {
  n.classList.toggle(className, attrValues.includes(n.getAttribute(attrName)));
}

на JS...

Хватаем текстовое содержимое элемента, с помощью регулярного выражения находим тот кусок, который надо обернуть в span, выполняем замену, записываем результат обратно в элемент, но уже не как текст, а как разметку:

document.querySelectorAll('.scroll_list li').forEach(n => {
  n.innerHTML = n.textContent.replace(/\d+ шт./, '<span>$&</span>');
});

// или

for (const n of document.querySelector('.scroll_list').children) {
  n.innerHTML = n.innerText.replace(/\S+ \S+$/, m => `<span>${m}</span>`);
}

...или PHP

Вот здесь точно никаких "обернуть" не надо. Разберитесь, где у вас формируется разметка страницы, и измените этот код так, чтобы нужный вам span создавался сразу.

nums1 = nums1.slice(0, m).concat(nums2).sort((a, b) => a - b);

Так вы меняете значение ссылки, но не сам массив. Правильно будет так:

nums1.splice(0, nums1.length, ...[ ...nums1.slice(0, m), ...nums2 ].sort((a, b) => a - b));

// или

nums1.slice(0, m).concat(nums2).sort((a, b) => a - b).forEach((n, i) => nums1[i] = n);

Но вообще, решение тут другое предполагается, без использования метода sort.

https://jsfiddle.net/oh9Lfdmu/

const ceil = (value, precision) => Math.ceil(value / precision) * precision;


const values = [ 1, 2, 3, 163, 200.001, 99.999 ];
values.map(n => ceil(n, 1)); // [ 1, 2, 3, 163, 201, 100 ]
values.map(n => ceil(n, 10)); // [ 10, 10, 10, 170, 210, 100 ]
values.map(n => ceil(n, 5)); // [ 5, 5, 5, 165, 205, 100 ]

url.match(/(\d+)\?/)[1]

или

/\d+(?=\?)/.exec(url).pop()

или

url.split('?', 1).shift().split('/').pop()

или

url.replace(/\?.+/, '').replace(/.+\D/, '')

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

function chunked(arr, numChunks) {
  const chunks = [];
  const chunkSize = arr.length / numChunks | 0;
  const numLooseItems = arr.length % numChunks;

  for (let i = 0, j = 0; j < numChunks; j++) {
    chunks.push(arr.slice(i, i += chunkSize + (j < numLooseItems)));
  }

  return chunks;
}


const [ head, tail ] = chunked(arr, 2);

const wait = time => new Promise(r => setTimeout(r, time));

wait(1000)
  .then(() => { console.log(1); return wait(1000); })
  .then(() => { console.log(2); return wait(1000); })
  .then(() => { console.log(3); });

const itemSelector = '.parent';
const className = 'xxx';

document.querySelectorAll(itemSelector).forEach(n => {
  n.addEventListener('mouseenter', onHover);
  n.addEventListener('mouseleave', onHover);
});

function onHover(e) {
  const state = e.type === 'mouseenter';
  for (
    let el = this;
    (el = el.nextElementSibling) && !el.matches(itemSelector);
    el.classList.toggle(className, state)
  ) ;
}

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

.parent:hover ~ .child {
  ...
}

.parent:hover ~ .parent ~ .child {
  ...
}

document.querySelectorAll('.selectit > input').forEach(n => {
  n.checked = genres.includes(n.parentNode.innerText.trim());
});

или

for (const n of document.getElementsByClassName('selectit')) {
  n.children[0].checked = genres.indexOf(n.textContent.trim()) > -1;
}

Object.values([ ...arr1, ...arr2 ].reduce((acc, n) => {
  acc[n.code] = n.id ? n : (acc[n.code] || n);
  return acc;
}, {}))

ind.map(((data, n) => data[n]).bind(null, arr.reduce((acc, row) => {
  const d = acc[row[0]];
  row.forEach((n, i) => i && (d[i] = d[i] || []).push(n));
  return acc;
}, ind.reduce((acc, n) => (acc[n] = [ n ], acc), {}))))

array.reduce((acc, el) => {
  el.forEach((n, i) => {
    acc[i] = acc[i] || [];
    n.forEach((m, j) => (acc[i][j] = acc[i][j] || []).push(...[].concat(m)));
  });

  return acc;
}, [])

const result = ind.reduce((acc, col) => {
  arr.forEach((n, i) => {
    acc[i].push(i ? n.filter((m, j) => arr[0][j] === col) : col);
  });
  
  return acc;
}, arr.map(() => []));

или

const indObj = Object.fromEntries(ind.map((n, i) => [ n, i ]));
const result = arr.reduce((acc, n, i) => (
  i && n.forEach((m, j) => acc[i][indObj[arr[0][j]]].push(m)),
  acc
), arr.map((_, i) => ind.map(n => i ? [] : n)));

О чём идёт речь - значение, инпут и кнопка:

const min = 666;
const inputSelector = 'input';
const buttonSelector = 'button';

Слушаем событие input, смотрим, как значение инпута соотносится с минимально допустимым:

const input = document.querySelector(inputSelector);
const button = document.querySelector(buttonSelector);

input.addEventListener('input', e => button.disabled = e.target.value < min);
input.dispatchEvent(new Event('input'));

// или

const $input = $(inputSelector);
const $button = $(buttonSelector);

$input.on('input', () => $button.prop('disabled', $input.val() < min)).trigger('input');

Math.max(1, Math.min(100, новое значение счётчика))