0xD34F

const processNonEmptyObjectOnly = (f, defaultResult) =>
  data => (
    data = data instanceof Object ? Object.entries(data) : [],
    data.length ? f(data) : defaultResult
  );

const createTreeHTML = processNonEmptyObjectOnly(data => `
  <ul>${data.map(n => `
    <li>
      ${n[0]}
      ${createTreeHTML(n[1])}
    </li>`).join('')}
  </ul>`
, '');

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

const createTreeElement = processNonEmptyObjectOnly(data =>
  data.reduce((ul, [ k, v ]) => (
    ul.append(document.createElement('li')),
    ul.lastChild.append(k),
    (v = createTreeElement(v)) && ul.lastChild.append(v),
    ul
  ), document.createElement('ul'))
, null);

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

computed: {
  range() {
    const prices = this.filterData.map(n => n.price);
    return {
      min: Math.min(...prices),
      max: Math.max(...prices),
    };
  },

  // или

  range() {
    return this.filterData.reduce(({ min, max }, { price: n }) => ({
      min: min < n ? min : n,
      max: max > n ? max : n,
    }), { min: Infinity, max: -Infinity });
  },

  // или

  range() {
    const prices = this.filterData.map(n => n.price).sort((a, b) => a - b);
    return {
      min: prices[0] ?? Infinity,
      max: prices[prices.length - 1] ?? -Infinity,
    };
  },
},

Note: This API has been removed in jQuery 3.0; please use .on( "load", handler ) instead of .load( handler ) and .trigger( "load" ) instead of .load()

const result = str.split('\n').reduce((acc, n) => (
  n && (n = n.split(' '), acc.push([ n[0], n[~-n.length] ])),
  acc
), []);

const result = Array.from(
  str.matchAll(/(?=.*(^\S+))(?=.*?(\S+$))/gm),
  n => n.slice(1)
);

const grouped = Object.entries(arr.reduce((acc, n) => (
  (acc[n.id] ??= []).push(n.name),
  acc
), {}));

document.body.insertAdjacentHTML('beforeend', grouped
  .map(([ k, v ]) => `
    <ul id="list-${k}">${v.map(n => `
      <li>${n}</li>`).join('')}
    </ul>`)
  .join('')
);

document.body.append(...grouped.map(([ id, names ]) => {
  const ul = document.createElement('ul');
  ul.id = `list-${id}`;

  ul.append(...names.map(n => {
    const li = document.createElement('li');
    li.textContent = n;
    return li;
  }));

  return ul;
}));

str.replace(/\d{3}-\d{2}/, '***-**')
// или
str.slice(0, 9) + '***-**' + str.slice(15)
// или
str.replace(/\d(?=\d*-)/g, '*')
// или
str.replace(/\d+(?=-)/g, m => '*'.repeat(m.length))
// или
str.replace(/(?<=\) ).{6}/, '***-**')
// или
str.match(/^.{9}|.{3}$/g).join('***-**')

• ...как работают условные операторы:
  
  

  if (sortArray[i]) {

  
  Что если там 0? Тогда этот элемент обработан не будет - не попадёт в результирующий массив. О чём, кстати, и говорится в сообщении об ошибке, в возвращаемом вами отсортированном массиве элементов меньше, чем в исходном:
  
  

  expected [ Array(14980) ] to deeply equal [ Array(15000) ]

  
  
• ...когда условные операторы следует применять - первый не нужен, элемент с индексом i всегда существует, так что засовывать в firstArray его следует без проверок.
  
• ...как, имея индекс, проверить наличие соответствующего элемента в массиве.
  

function pendulum(arr) {
  arr.sort((a, b) => a - b);

  const head = [];
  const tail = [];

  for (let i = 0; i < arr.length; i += 2) {
    head.push(arr[i]);

    if (i + 1 < arr.length) { // или if (arr.hasOwnProperty(i + 1)) {
      tail.push(arr[i + 1]);
    }
  }

  return [ ...head.reverse(), ...tail ];
}

const pendulum = arr => arr
  .sort((a, b) => a - b)
  .reduce((acc, n, i) => (acc[i & 1].push(n), acc), [ [], [] ])
  .flatMap((n, i) => i ? n : n.reverse());

href="javascript:deleteRow(this);"

document.querySelector('table').addEventListener('click', e => {
  e.target.closest('.btn')?.closest('tr').remove();
});

нашел другой вариант

$('body').on('click', 'btn btn-warning', function() {
        $(this).parents('tr').remove();
    });

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

$('table').on('click', '.btn.btn-warning', function(e) {
  e.preventDefault();
  $(this).closest('tr').remove();
});

span.btn {
  text-decoration: underline;
  color: blue;
  cursor: pointer;
}

const getStr = length => Array
  .from({ length }, n => (
    n = Array(length).fill('.'),
    n[Math.random() * length | 0] = 'Q',
    n.join('')
  ))
  .join('\n');

{"value":"[\"2b2df5f4-256d-402e-b074-c460ee394a2e

document.querySelector('tbody').addEventListener('input', function() {
  const data = Array.from(
    this.children,
    tr => Array.from(tr.querySelectorAll('input'), input => input.value)
  );

  console.log(data);
});

document.querySelector('table').addEventListener('input', e => {
  const { map, flatMap } = Array.prototype;
  const data = flatMap.call(
    e.currentTarget.tBodies,
    tbody => map.call(
      tbody.rows,
      tr => map.call(tr.cells, td => td.lastElementChild.value)
    )
  );

  console.log(data);
});

// или

document.querySelector('table').addEventListener('input', function() {
  const numHeadRows = this.querySelectorAll('thead tr').length;
  const data = [];

  for (const input of this.querySelectorAll('tbody input')) {
    const td = input.parentNode;
    const iCol = td.cellIndex;
    const iRow = td.parentNode.rowIndex - numHeadRows;
    (data[iRow] ??= [])[iCol] = input.value;
  }

  console.log(data);
});

data: () => ({
  closing: false,
}),

<template>
  <div
    @mousedown="closing = $event.target === $el"
    @mouseup.self="closing && close()"
  >
    ...

const parent = document.querySelector('.top');
const elements = parent.children;

parent.replaceChildren(...Array.prototype.filter.call(
  elements,
  function({ textContent: n }) {
    return !this.has(n) && this.add(n);
  },
  new Set
));

const { size: numUnique } = Array.prototype.reduce.call(
  elements,
  (acc, n) => acc.add(elements[acc.size].innerText = n.innerText),
  new Set
);

for (; elements[numUnique]; parent.lastElementChild.remove()) ;

parent.innerHTML = Array
  .from(new Set(Array.from(elements, n => n.outerHTML)))
  .join('');

Object
  .values(Array
    .from(elements)
    .reduce((acc, n) => ((acc[n.innerText] ??= []).push(n), acc), {}))
  .forEach(n => n.forEach((m, i) => i && parent.removeChild(m)));

[...elements]
  .filter((n, i, a) => n !== a.find(m => m.innerText === n.innerText))
  .forEach(n => n.replaceWith());

const keys = [...new Set(arr.flatMap(Object.keys))];

const keys = arr.reduce((acc, n) => {
  for (const k in n) {
    if (n.hasOwnProperty(k) && !acc.includes(k)) {
      acc.push(k);
    }
  }

  return acc;
}, []);

const [users, setUsers] = useState({user:['user1', 'user2', 'user3']});

setUsers(users.user.filter((item,i) => i !== index));

const list = users.user.map(...

class DoublyLinkedList {
  constructor() {
    this.size = 0;
    this.head = null;
    this.tail = null;
  }

  add(value, index) {
    index ??= this.size;

    const next = this.searchByIndex(index);
    const prev = next ? next.prev : this.tail;
    const node = { value, next, prev };

    prev || (this.head = node);
    next || (this.tail = node);

    prev && (prev.next = node);
    next && (next.prev = node);

    this.size++;
  }

  _remove(node) {
    if (node) {
      node.prev || (this.head = node.next);
      node.next || (this.tail = node.prev);

      node.prev && (node.prev.next = node.next);
      node.next && (node.next.prev = node.prev);

      this.size--;
    }
  }

  removeByValue(value) {
    this._remove(this.searchByValue(value));
  }

  removeByIndex(index) {
    this._remove(this.searchByIndex(index, true));
  }

  searchByIndex(index, strict) {
    if (!(index >= 0 && index <= this.size - !!strict)) {
      throw 'invalid index';
    }

    let node = this.head;

    while (index--) {
      node = node.next;
    }

    return node;
  }

  searchByValue(value, startIndex = 0) {
    let node = this.searchByIndex(startIndex, true);

    while (node && node.value !== value) {
      node = node.next;
    }

    return node;
  }
}