Дмитрий Беляев

Вот народ ушел в спор о производительности, но никто даже не попытался разобраться, а что под капотом... Производительность ведь искусственными бенчмарками меряют, ага...

Говорить о том, что некие фичи устарели - крайне глупо, если знать, что они ведут себя иначе, чем более модные альтернативы. Предлагаю немного разобраться и начать с того что на поверхности:
- getElementById и querySelector возвращают конкретную ноду в единственном экземпляре
- querySelectorAll и getElementsByName возвращает статичную коллекцию NodeList
- getElementsByClassName, getElementsByTagName и getElementsByTagNameNS возвращают динамическую коллекцию HTMLCollection
Как видим результат у разного апи различен, а значит и говорить, что некоторые из них устарели - глупо.
С устареванием вроде разобрались, но в вопросе еще есть часть "чем лучше". И тут есть теория, что getElementsBy* быстрее querySelector*. Чисто теоретически звучит логично, querySelector* должен делать полный поиск по дереву со сложностью O(n), а getElementsBy* могут использовать индексы на базе HashMap и получать данные со сложностью O(1), тут и особенности HTMLCollection будут кстати, так как можно не копировать коллекцию, а отдавать одну и ту же (и браузеры действительно так делают). Но без пруфов теория так и останется теорией.Гораздо лучше тут выглядят исходники. И я выбрал исходники chromium, как самого распространенного:
- getElementsBy* методы все как один обращаются к некой шаблонной функции EnsureCachedCollection, которая в свою очередь обращается к некоему NodeLists кэшу, устроенному внутри действительно как HashMap или что-то наподобие. Никакого поиска тут нет, просто берутся готовые значения, сложность у всего этого действительно константная O(1).
- querySelector* используют абстракцию SelectorQuery, которая и в самом деле делает поиск по DOM. Но данный поиск неплохо оптимизирован и обвешан кэшами. Притом CSSOM использует абсолютно тот же алгоритм поиска DOM нод для каждого селектора в css.

На этом спор думаю можно закрыть. querySelector* методы действительно могут быть медленнее, но чтоб убить ими производительность, нужно очень постараться. На фоне того, что пишут кривые ручки среднестатистического дешевого js-кодера это будет незначительной потерей измеряемой в наносекундах. Используйте то что удобнее в каждой конкретной ситуации.

Данная задача в принципе не решается сортировкой, так как сортировка это про отношение больше/меньше/равно, которого в данном случае нет.
Самое простое здесь, это построить из этих элементов двусвязный список, а затем преобразовать его в результирующий массив:

function orderArray(arr) {
  // для начала построим ноды списка и соберем их в 2 HashMap по обоим строкам
  const maps = arr.reduce((acc, item) => {
    const node = {item, next: null, prev: null};
    acc[0][item[0]] = node;
    acc[1][item[1]] = node;
    return acc;
  }, [{}, {}]);

  // после пройдемся по обоим HashMap и соединим связи
  for(const key of Object.keys(maps[0])) {
    maps[0][key].next = maps[0][maps[0][key].item[1]] || null;
  }
  for(const key of Object.keys(maps[1])) {
    maps[1][key].prev = maps[1][maps[1][key].item[0]] || null;
  }

  // найдем начальную ноду списка (ноду без предыдущей ноды)
  let cur = Object.values(maps[0]).find(({prev}) => prev === null);

  // и начиная с нее соберем список в массив
  const result = [];
  while(cur) {
    result.push(cur.item);
    cur = cur.next;
  }

  return result;
}

console.log(orderArray([['butter', 'jelly'], ['bananas', 'apples'], ['peanuts', 'butter'], ['jelly', 'bananas']]));

Первое что нужно понимать, что async/await - это всего лишь синтаксический сахар над промисами, а значит имеет все особенности работы с ними:
Во-первых, промис может разрешится (или отклонится, но в этой задаче reject не нужен) только единожды. Это сильно отличает их от событий, которые могут происходить многократно.
Во-вторых, промисы обрабатываются на особой фазе event loop называемой microtasks, что опять же отличается от событий, которые выполняются на другой фазе (tasks). Это означает, что обработка промиса (колбэк метода then, или сахар над ним в виде await оператора) всегда произойдет асинхронно от возникновения события. Это накладывает ряд ограничений, например не получится сделать preventDefault у объекта или не получится запустить действия требующие синхронной работы из trusted события (play не muted video/audio, вход в фулскрин и тд).

В простом варианте можно слушать событие разово, для чего можно использовать параметр once. Так же для оптимизации можно использовать параметр passive, так как нам все равно поздно вызывать preventDefault, а в некоторых случаях это может дать нам оптимизацию. Ну и управлять параметром capture попросту бесполезно, так как обработка будет в любом случае после обеих фаз. В итоге для этого можно пользоваться такой функцией хелпером:

function listenOnce(target, event) {
    return new Promise(resolve => {
        target.addEventListener(event, resolve, {
            once: true,
            passive: true
        });
    });
}

// использование
const event = await listenOnce(document, 'DOMContentLoaded');
console.log(event);

Если же нужно слушать событие многократно, то разумно обернуть прослушивание события в асинхронный итератор. Здесь так же присутствуют все ограничения связанные с промисами, но за счет того, что у нас будет итератор по множеству промисов, мы сможем слушать событие многократно. так же тут нужно предусмотреть возможность отписаться от события. Хелпер для данного случая получится такой:

function listen(target, event) {
    let currentResolve = () => {};
    const handler = event => currentResolve({value: event, done: false});
    return {
        [Symbol.asyncIterator]() {
            target.addEventListener(event, handler, {passive: true});
            return {next: () => new Promise(resolve => {
                currentResolve = resolve;
            })};
        },
        stop() {
            target.removeEventListener(event, handler);
            currentResolve({done: true});
        }
    };
}

// использование
for await(const event = listenOnce(window, 'scroll')) {
    console.log(event);
}

// с отпиской
const eventIterator = listenOnce(window, 'scroll');
let count = 10;
for await(const event = eventIterator) {
    console.log(event);
    if(--i === 0) {
        eventIterator.stop();
    }
}

Проц пробросить не получится, хостовая ОС монопольно владеет им. Но в современном x86 есть технологии Intel VT и AMD-V (в зависимости от производителя проца), которые позволяют предоставлять прямой доступ к ресурсам процессора в гостевую ОС. Данные технологии доступны в большинстве виртуальных машин с x86 на хосте и x86 в госте. Однако эмулировать так ARM на x86 или наоборот не выйдет, все таки разные архитектуры.

Насчет видюхи и других PCIe устройств. Их можно только полностью передать в гостевую ОС, и они станут недоступны в хостовой ОС (если так же нужно изображение на хосте, то понадобится 2 видяхи, и 2 монитора, ну или VNC/RDP сервер вместо монитора). Еще одно ограничение, что сделать это могут только гипервизоры работающие в пространстве ядра хостовой ОС (VirtualBox работает в пользовательском пространстве, а вот KVM может, так как работает как модуль ядра Linux, Hyper-V (если нужна винда на хосте) тоже вроде может, но я не уверен)

// небольшая функция хелпер, чтоб писать меньше кода:
const appendNewDiv = parent => parent.appendChild(document.createElement('div'));

// создадим основные эллементы
const wrap = appendNewDiv(albumTrack);
const title = appendNewDiv(wrap);
const itemAlbumWrap = appendNewDiv(wrap);
const itemAlbum = appendNewDiv(itemAlbumWrap);

wrap.classList.add('album__item');
title.classList.add('album_title');
itemAlbumWrap.classList.add('album__item__wrap');
itemAlbum.classList.add('album__photo');

// сюда будем складывать элементы, которые должны удалятся при смене number
let elements = [];

// функция, через которую меняем отображаемые данные по number
const renderByNumber = number => {
    const {albumId, albums} = arr2[number];
    elements.forEach(e => wrap.removeChild(e));
    title.textContent = `Альбом ${albumId}`;
    elements = albums.map(album => {
        const e = appendNewDiv(wrap);
        e.textContent = album.title;
        return e;
    });
};

// при изменении number теперь просто вызываем
renderByNumber(number);

Все прекрасно работает:
https://www.typescriptlang.org/play?#code/MYGwhgzh...

Вероятно дело в том, что скобки в вызове метода забыли

https://developer.mozilla.org/ru/docs/Web/JavaScri...

У HTMLCollection нет метода every, и метода includes тоже нет, как и метода some у DOMElement

Является.
Все что можно присвоить в переменную, вернуть из функции, передать в другую функцию - выражение.

Если набор возможных команд небольшой, то расстояние левенштейна Вам подойдет, с какой командой расстояние минимально - ту и подразумевал пользователь, ну и стоит вести некое пороговое значение, если все команды "дальше" этого значения, то введена бессмыслица

https://marketplace.visualstudio.com/items?itemNam...

https://developer.mozilla.org/ru/docs/Web/JavaScri...
https://habr.com/ru/post/261723/