0xD34F

document.querySelectorAll('.top > .nick').forEach(function(n) {
  const text = n.textContent;
  !this.has(text) && this.add(text) || n.remove();
}, new Set);

[...document.querySelector('.top').children].reduce((acc, n) => {
  const text = n.innerText;
  acc.includes(text) ? n.parentNode.removeChild(n) : acc.push(text);
  return acc;
}, []);

Object
  .values(Array
    .from(document.querySelectorAll('.top > .nick'))
    .reduce((acc, n) => ((acc[n.innerText] ??= []).push(n), acc), {}))
  .forEach(n => n.forEach((m, i) => i && (m.outerHTML = '')));

const el = document.querySelector('.top');
el.innerHTML = [...new Set(el.innerHTML.match(/<span.*?\/span>/g) ?? [])].join(' ');

const el = document.querySelector('.top');
el.innerHTML = Array
  .from(el.getElementsByClassName('nick'), n => n.innerText)
  .filter((n, i, a) => i === a.indexOf(n))
  .reduce((acc, n) => acc + (acc && ' ') + `<span class="nick">${n}</span>`, '');

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

const keys = Array.from(arr.reduce((acc, n) => {
   for (const k in n) if (n.hasOwnProperty(k)) {
     acc.add(k);
   }

   return acc;
 }, new Set));

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;
  }
}

.hidden {
  display: none;
}

document.querySelector('input').addEventListener('input', e => {
  const val = +e.target.value;

  document.querySelectorAll('.word').forEach(n => {
    n.closest('.block').classList.toggle('hidden', +n.innerText < val);
  });
});

try {
  eval('this.#' + name);
  return true;
} catch(e) {
  return false;
}

function max(data, key = n => n) {
  const getVal = key instanceof Function ? key : n => n[key];

  return Array.prototype.reduce.call(data, (max, n) => {
    const val = getVal(n);
    return max[0] > val ? max : [ val, n ];
  }, [ -Infinity, undefined ])[1];
}


const { text } = max(arr, n => n.text.length);
const oldest = max(arr, 'age');

const remove = {
  from: 5,
  exclude: [ 9, 10, 11 ],
};

$('table tr').each(function() {
  $(this)
    .children()
    .filter(i => i >= remove.from && !remove.exclude.includes(i))
    .remove();
});

function getWeekdaysOfMonth(year, month) {
  const date = new Date(year, --month, 1);
  const result = [];

  while (date.getMonth() === month) {
    result.push(date.toLocaleString('ru-RU', {
      month: 'long',
      day: 'numeric',
      weekday: 'long',
    }));
    date.setDate(date.getDate() + 1);
  }

  return result;
}


const weekdaysOfDecember2020 = getWeekdaysOfMonth(2020, 12);

но как поступить если я не хочу забирать дни недели из стандартного объекта. а взять из их своего массива?

const weekdays = [
  'воскресенье',
  'это понедельник',
  'а это вторник',
  'конечно же среда',
  'четверг',
  'пятница - прямо после четверга',
  'суббота, рабочая неделя окончена',
];

const getWeekdaysOfMonth = (year, month) => Array.from(
  { length: new Date(year, month--, 0).getDate() },
  (n, i) => {
    const d = new Date(year, month, i + 1);
    return d.toLocaleString('ru-RU', {
      month: 'long',
      day: 'numeric',
    }) + ', ' + weekdays[d.getDay()];
  });


const weekdaysOfFebruary2021 = getWeekdaysOfMonth(2021, 2);

const result = arr.reduceRight((acc, n) => ({ [n]: acc }), {});

let result = {};
for (let i = arr.length; i--;) {
  result = { [arr[i]]: result };
}

const result = (function createObj(arr, i) {
  return i < arr.length
    ? { [arr[i]]: createObj(arr, -~i) }
    : {};
})(arr, 0);

document.querySelector('.products__body').addEventListener('click', e => {
  const item = e.target.closest('.card-preview__item');
  if (item) {
    e.preventDefault();
    const { srcset } = item.querySelector('source');
    item.closest('.card').querySelector('.card-head__image source').srcset = srcset;
  }
});

• tagName:
  
  

  For DOM trees which represent HTML documents, the returned tag name is always in the canonical upper-case form.

  
  А теперь посмотрите, что вы у себя написали:
  
  

  if(str.tagName == 'ul') {

  
  

  } else if (str.tagName == 'li') {

  
  Кстати, а почему str, что за странный выбор имени? Там же элемент, а не строка.
  
  
• Вместо элемента добавляется строка:
  
  

  elem.append('li');

  
  
• Крайне странное назначение обработчика клика:
  
  

  for (let el of strLi) {
      el.addEventListener('click',func);
  };

  
  Во-первых - зачем каждый раз добавлять всем? Хорошо, что хоть объявление func вынесено за пределы текущей функции, иначе бы при каждом клике всем существующим li добавлялся новый обработчик.
  
  Во-вторых - пока не кликните по li, на свежесозданных li клик обрабатываться не будет (касается и тех, что изначально существуют).
  
  В-третьих - а на хрена оно надо? Вы же уже обрабатываете клик по li - так зачем назначать отдельный обработчик клика? То, что делаете в func, вполне можно делать прямо тут.
  
  

document.querySelector('ul').addEventListener('click', e => {
  const t = e.target;
  const ct = e.currentTarget;
  t.insertAdjacentHTML('beforeend', ct === t ? '<li>text</li>' : '!');
});

function memoize(f, timeout) {
  const memo = {};

  return () => (new Date() < memo.time + timeout)
    ? Promise.resolve(memo.result)
    : f().then(r => (memo.time = +new Date(), memo.result = r));
}

parent.querySelectorAll(':scope > *').forEach(n => parent.prepend(n));

// или

Element.prototype.append.apply(parent, [...parent.children].reverse());

// или

const [ first, ...rest ] = parent.children;
first?.before(...rest.reverse());

// или

for (const n of parent.children) {
  parent.insertBefore(n, parent.firstElementChild);
}

// или

for (let i = parent.children.length; i--;) {
  parent.insertAdjacentElement('beforeend', parent.children[i]);
}

// или

const elems = Array.from(parent.children);
while (elems.length) {
  parent.appendChild(elems.pop());
}

const first = '125';
const startWithFirst = arr.filter(n => first.includes(`${n}`[0]));

console.log(startWithFirst);

const first = [ 1, 2, 5 ];
const startWithFirst = arr.filter(n => first.includes(n / (10 ** (Math.log10(n) | 0)) | 0));

const first = /^[125]/;
const startWithFirst = arr.filter(n => first.test(n));

новая_координата = Math.max(
  минимальное_допустимое_значение,
  Math.min(
    максимальное_допустимое_значение,
    текущая_координата + изменение_координаты
  )
);

const getSrc = img => img.getAttribute('src');
// или
const getSrc = img => img.attributes.src.value;

const relativeOnly = f => img => {
  const src = getSrc(img);
  if (!/^https?:\/\//.test(src)) {
    f(img, src);
  }
};

document.querySelectorAll('img').forEach(relativeOnly((img, src) =>
  img.outerHTML = `
    <picture>
      <source srcset="${src}" type="image/svg+xml">
      ${img.outerHTML}
    </picture>`
));

const wrapImages = relativeOnly((img, src) => {
  const picture = document.createElement('picture');
  const source = document.createElement('source');
  source.srcset = src;
  source.type = 'image/svg+xml';
  img.replaceWith(picture);
  picture.append(source, img);
});

for (const n of document.getElementsByTagName('img')) {
  wrapImages(n);
}

// или

Array.prototype.forEach.call(document.images, wrapImages);

const result = Array
  .from({ length: count }, (n, i) => `"${-~i}"`)
  .join(', ');

// или

const result = [...Array(count).keys()].reduce((acc, n) => {
  return acc.concat(acc && ', ', '"', ++n, '"');
}, '');

// или

const result = (function xxx(n) {
  return n > 0 ? xxx(n - 1) + (n === 1 ? '' : ', ') + '"' + n + '"' : '';
})(count);

// или

const result = Array(count)
  .fill()
  .map((n, i) => JSON.stringify((i + 1).toString()))
  .toString()
  .replace(/,/g, '$& ');

const buttonSelector = '.class2';
const classesToToggle = [ 'class3', 'class4' ];

$(buttonSelector).click(e => {
  $(e.currentTarget).next().toggleClass(classesToToggle.join(' '));
});

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

function onClick() {
  classesToToggle.forEach(n => this.nextElementSibling.classList.toggle(n));
}

document.addEventListener('click', e => {
  const button = e.target.closest(buttonSelector);
  if (button) {
    for (const n of classesToToggle) {
      button.parentNode.lastElementChild.classList.toggle(n);
    }
  }
});

const el = document.querySelector('#box');
const colors = [ 'red', 'green', 'blue' ];
let index = -1;

el.addEventListener('mouseenter', function() {
  index = (index + 1) % colors.length;
  this.style.backgroundColor = colors[index];
});
el.addEventListener('mouseleave', function() {
  this.style.backgroundColor = '';
});