0xD34F

const arr = Array.from(str.matchAll(/[^\/]+/g), n => n[0]);

// или

const arr = str.match(/[^\/]+/g) ?? [];

// или

const arr = str.split('/').filter(Boolean);

// или

const arr = Array.prototype.reduce.call(str, (acc, n, i) => (
  (n !== '/') && (
    acc[1] !== i - 1 && acc[0].push(''),
    acc[0][acc[0].length - 1] += n,
    acc[1] = i
  ),
  acc
), [ [], -Infinity ])[0];

<button data-step="-1">-</button>
<input value="1">
<button data-step="+1">+</button>

const values = [ 1, 2, 4, 6, 8, 10, 12, 16, 20, 24, 32, 48, 56, 64 ];

for (const n of document.querySelectorAll('[data-step]')) {
  n.addEventListener('click', onClick);
}

function onClick() {
  const input = document.querySelector('input');
  const index = +this.dataset.step + values.indexOf(+input.value);
  input.value = values[Math.max(0, Math.min(values.length - 1, index))];
}

Получаем элементы:

const elements = el.closest('.calc').querySelectorAll('.range__control');

// или

const { elements } = el.form;

Перемножаем их значения:

const price = Array.prototype.reduce.call(
  elements,
  (acc, n) => acc * n.value,
  1
);

// или

let price = 1;
for (const { value } of elements) {
  price *= value;
}

// или

let price = 1;
for (let i = 0; i < elements.length; i++) {
  price = price * elements.item(i).value;
}

// или

const price = (function mul(i, n = elements[i]) {
  return n ? n.value * mul(-~i) : 1;
})(0);

// или

const price = eval(Array.from(elements, n => n.value).join('*')) ?? 1;

После того, как назначили обработчик, просто сгенерируйте соответствующее событие. В данном случае, это будет вызов метода change без параметров:

$('select').change(function() { ... }).change();

Object.values(arr.reduce((acc, { id, value }) => {
  const type = typeof value;
  acc[id] = acc[id] ?? { id };
  acc[id][type] = (acc[id][type] ?? 0) + 1;
  return acc;
}, {}))

Добавьте $(this).remove() в конец обработчика клика.

str.match(/[^.]+(?=\.[^.]+(\/|$))/)[0]

Пусть второй параметр будет массивом индексов, по умолчанию - пустой (соответственно, когда вызываете функцию сами, его передавать не надо). В начале обработки элемента данных кладёте его индекс в массив, после обработки убираете. Ну а текст - собираете из массива какой вам нужен:

const createTreeElement = (data, index = []) =>
  Array.isArray(data) && data.length
    ? data.reduce((ul, n, i) => (
        index.push(i),
        ul.append(document.createElement('li')),
        ul.lastChild.append(index.join('_'), createTreeElement(n.children, index)),
        index.pop(),
        ul
      ), document.createElement('ul'))
    : '';

document.body.append(createTreeElement(data));

Или, делаем второй параметр строкой. Как и массив из предыдущего варианта, по умолчанию пуста, указывать при самостоятельном вызове не надо. При обработке элемента массива собираем новую строку, состоящую из переданной в функцию и индекса:

const createTreeHTML = (data, index = '') =>
  data instanceof Array && data.length
    ? `<ul>${data.map((n, i) => `
         <li>
           ${(i = index + (index && '_') + i)}
           ${createTreeHTML(n.children, i)}
         </li>`).join('')}
       </ul>`
    : '';

document.body.insertAdjacentHTML('beforeend', createTreeHTML(data));

const result = [];
for (const n of arrWithObj) {
  if (!arr.includes(n.id)) {
    result.push(n);
  }
}

или

const result = [];

COLLECT_OBJECTS:
for (let i = 0; i < arrWithObj.length; i++) {
  for (let j = 0; j < arr.length; j++) {
    if (arr[j] === arrWithObj[i].id) {
      continue COLLECT_OBJECTS;
    }
  }
  result[result.length] = arrWithObj[i];
}

или

const result = arrWithObj.filter(function(n) {
  return !this.has(n.id);
}, new Set(arr));

или

const result = (function get(i, n = arrWithObj[i]) {
  return n
    ? [].concat(~arr.indexOf(n.id) ? [] : n, get(-~i))
    : [];
})(0);

или

const result = [...arr.reduce(
  (acc, n) => (acc.delete(n), acc),
  new Map(arrWithObj.map(n => [ n.id, n ]))
).values()];

const ul = document.querySelector('.ul-parent');

const groupedNodes = Array.prototype.reduce.call(
  ul.children,
  (acc, n) => {
    const k = n.textContent[0].toLowerCase();
    (acc[k] = acc[k] ?? []).push(n);
    return acc;
  },
  {}
);

ul.replaceWith(...Object.entries(groupedNodes).map(n => {
  const ul = document.createElement('ul');
  ul.classList.add('ul-parent', n[0] + '-litter');
  ul.append(...n[1]);
  return ul;
}));

или

const ul = document.querySelector('.ul-parent');

const groupedHTML = Array
  .from(ul.querySelectorAll(':scope > li'))
  .reduce((acc, { innerText: [ c ], outerHTML }) => {
    const k = c.toLowerCase();
    (acc[k] = acc[k] ?? []).push(outerHTML);
    return acc;
  }, {});

ul.outerHTML = Object
  .entries(groupedHTML)
  .map(([ k, v ]) => `<ul class="ul-parent ${k}-litter">${v.join('')}</ul>`)
  .join('');

document.addEventListener('click', e => {
  const div = e.target.closest('button')?.closest('div');
  if (div) {
    console.log(div.id);
  }
});

или

document.querySelectorAll('div button').forEach(function(n) {
  n.addEventListener('click', this);
}, e => console.log(e.currentTarget.closest('div').id));

Сортируем существующий массив:

arr.sort((a, b) => (a.rooms - b.rooms) || (a.square - b.square));

// или, в более общем виде

const sort = (arr, ...keys) =>
  arr.sort((a, b) => {
    let diff = 0;
    keys.find(k => diff = a[k] - b[k]);
    return diff;
  });

sort(arr, 'rooms', 'square');

Создаём отсортированный новый:

const sorted = (arr, keys) => arr
  .map(n => [ n ].concat(keys(n)))
  .sort((a, b) => {
    let diff = 0;
    for (let i = 0; ++i < a.length && !(diff = a[i] - b[i]);) ;
    return diff;
  })
  .map(n => n[0]);

const sortedArr = sorted(arr, n => [ n.rooms, n.square ]);

template.replace(/\{(.+?)\}/g, (m, g1) => user[g1] ?? m)

str.replace(/[#&|?:«»]/g, '')

const $table = $('table');
const columnIndex = // здесь должен быть номер столбца с числами

const sum = $table
  .find('tr:visible')
  .get()
  .reduce((acc, n) => acc + +$('td', n).eq(columnIndex).text(), 0);

$table
  .find('th')
  .eq(columnIndex)
  .text(`Вес (${sum})`);

https://jsfiddle.net/xre59sn2/

Где элементы находятся:

const parents = document.querySelectorAll('.news-block-2 tbody tr');

Как их поменять местами, в общем виде:

const swapChildren = function(el, selectorA, selectorB) {
  const a = this(el.children, n => n.matches(selectorA));
  const b = this(el.children, n => n.matches(selectorB));
  el.append(...Array.from(el.children, n => n === a ? b : n === b ? a : n));
}.bind(Function.prototype.call.bind(Array.prototype.find));

parents.forEach(n => swapChildren(n, '.picture-news', '.text-news'));

Но, поскольку кроме интересующих нас элементов никаких других нет (конечно, если верить тому, что вы показали в качестве разметки), есть варианты поступить проще:

const swapChildren = el => el.append(...[...el.childNodes].reverse());
// или
const swapChildren = el => el.appendChild(el.firstElementChild);
// или
const swapChildren = el => el.insertBefore(el.children[0], null);
// или
const swapChildren = el => el.insertAdjacentElement('beforeend', el.children[0]);
// или
const swapChildren = el => el.prepend(el.querySelector(':scope > :last-child'));
// или
const swapChildren = ({ lastElementChild: el }) => el.previousElementSibling.before(el);
// или
const swapChildren = el => el.cells[1].after(el.cells[0]);
// или
const swapChildren = ({ cells: [ a, b ] }) => a.replaceWith(b, a);

parents.forEach(swapChildren);

// или

for (const n of parents) {
  swapChildren(n);
}

// или

for (let i = 0; i < parents.length; i++) {
  swapChildren(parents[i]);
}

// или

(function next(i, n = parents.item(i)) {
  n && (swapChildren(n), next(-~i));
})(0);

В качестве шага рекурсии возьмём не вычитание единицы, а битовый сдвиг на единицу вправо (деление на 2 нацело) - так, при увеличении глубины рекурсии на единицу, будет обрабатываться один двоичный разряд исходного значения. Отсюда максимальная глубина рекурсии - двоичный логарифм исходного значения.

X = n => n ? (n & 1 ? '-chirp' : '') + X(n >> 1) + X(n >> 1) : ''
chirp = n => X(n).slice(1)

Потеряли второй параметр для arrayToDataTable, должно быть

google.visualization.arrayToDataTable(data, true)

data.map(({ city, street, house, floor, ...n }) => (
  n.address = `${city}, ${street}, ${house}/${floor}`,
  n
))

Сделайте объект корзины, куда будут записываться добавленные товары. На основе этого объекта создавайте разметку DOM-элемента корзины. Когда добавляете товар - проверяете его наличие в объекте корзины, если да, тогда плюсуете новое количество к тому, что уже есть. Например.