hatealleverything

отрисовывать пунктирной линией, меняя смещение штриха. Длина штриха сравнима с длиной всей кривой.

• setLineDash() – установить паттерн штриха с длиной штриха достаточно длинной, чтобы закрыть 1 штрихом всю длину кривой.
  
• lineDashOffset – установить смещение этого штриха вдоль линии. Сначала на минус_длину_штриха, чтобы ничего не было отрисовано. Затем чуть увеличивать с каждым кадром: кривая станет появляться.
  

Вам нужен не множитель, а тайминг функция. Множитель дает линейное изменение скорости - быстрее или медленее на всем промежутке. С помощью тайминг функций можно задавать нелинейное поведение (плавное ускорение, замедление и пр.)

Пример функций:
https://gist.github.com/gre/1650294

Если на пальцах: то у вас есть какой-то таймер t и функция которая определяет сдвиг картинок f(t). Сейчас эта функция выглядит как f(t) = a*t, где a - это какой-то постоянный коэффициент. Изменяя функцию f(t) вы и получите нужный результат, например f(t) = t*t создаст эффект ускорения, f(t) = 1/t - плавное замедление

Используй easing функции
https://easings.net/ru
https://gist.github.com/gre/1650294

Необходимо настроить Nginx на отдачу только /index.html - 1, 2, 3.

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

const getName = n => n.name.split(' ').pop();
// или
const getName = n => n.name.replace(/.+ /, '');
// или
const getName = n => n.name.match(/\S*$/)[0];
// или
const getName = n => n.name.slice(-~n.name.lastIndexOf(' '));

Дальше можно сделать просто:

const result = Object.values(arr.reduce((min, n) => {
  const name = getName(n);
  min[name] = +min[name]?.price < +n.price ? min[name] : n;
  return min;
}, {}));

Или сложно:

function group(data, key, val = n => n) {
  const getKey = key instanceof Function ? key : n => n[key];
  const getVal = val instanceof Function ? val : n => n[val];
  const result = new Map;

  for (const n of data) {
    const k = getKey(n);
    result.set(k, result.get(k) ?? []).get(k).push(getVal(n));
  }

  return result;
}

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

  for (const n of data) {
    const val = getVal(n);
    result = result?.[1] >= val ? result : [ n, val ];
  }

  return result?.[0];
}

const result = Array.from(
  group(arr, getName).values(),
  n => max(n, m => -m.price)
);

Задача определения подобных имен не очень понятна.
На приведенных данных, если бы существовала запись с name = "Demon Eater Whalehook", ее в какую группу относить?

const prefixes = ['Inscribed', 'Autographed', 'Exalted', 'Corrupted'];
const prefixExpression = new RegExp(`^(${prefixes.join('|')})`, 'gi');

const items = [
  { name: 'Corrupted Demon Eater', price: '3215.00', inStock: 1 },
  { name: 'Exalted Demon Eater', price: '1530.00', inStock: 1 },
  { name: 'Demon Eater', price: '2900.00', inStock: 1 },

  { name: 'Whalehook', price: '1000.00', inStock: 1 },
  { name: 'Whalehook', price: '590.00', inStock: 1 },
  { name: 'Whalehook', price: '259.20', inStock: 1 },
  { name: 'Whalehook', price: '259.15', inStock: 1 },
  { name: 'Autographed Whalehook', price: '243.00', inStock: 1 },
  { name: 'Autographed Whalehook', price: '344.00', inStock: 1 },
  { name: 'Autographed Whalehook', price: '199.00', inStock: 1 },
  { name: 'Inscribed Whalehook', price: '355.00', inStock: 1 },
  { name: 'Inscribed Whalehook', price: '655.00', inStock: 1 },
  { name: 'Inscribed Whalehook', price: '5555.00', inStock: 1 },

  { name: 'Inscribed Sylvan Cascade', price: '345.00', inStock: 1 },
  { name: 'Inscribed Sylvan Cascade', price: '96.18', inStock: 1 },
  { name: 'Inscribed Sylvan Cascade', price: '95.00', inStock: 1 },
  { name: 'Inscribed Sylvan Cascade', price: '266.71', inStock: 1 },
  { name: 'Inscribed Sylvan Cascade', price: '85.00', inStock: 1 }
];

const getCheapest = items => {
  const store = items.reduce((accumulator, item) => {
    const type = item.name.replace(prefixExpression, '').trim();
    if (!accumulator.has(type)) {
      accumulator.set(type, []);
    }
    accumulator.get(type).push(item);
    
    return accumulator;
  }, new Map());
  const cheapest = store.values().reduce((accumulator, items) => {
    const minPrice = Math.min(...items.map(item => parseFloat(item.price)));
    const item = items.find(item => parseFloat(item.price) === minPrice);
    accumulator.push(item);
    
    return accumulator;
  }, []);
  
  return cheapest;
};

getCheapest(items);
/*
[
  { name: 'Exalted Demon Eater', price: '1530.00', inStock: 1 },
  { name: 'Autographed Whalehook', price: '199.00', inStock: 1 },
  { name: 'Inscribed Sylvan Cascade', price: '85.00', inStock: 1 }
]
*/

[...].filter(({name}, i, arr) => !i || name !== arr[i-1].name)

const newArr = [...arr]
  .sort((a, b) => a.name.localeCompare(b.name) || (a.price - b.price))
  .filter((n, i, a) => n.name === a[i - 1]?.name);

если какое-то значение name встречается лишь единожды, и такие объекты удалять не надо:

const newArr = [...arr]
  .sort((a, b) => a.name.localeCompare(b.name) || (a.price - b.price))
  .filter((n, i, a) => n.name === a[~-i]?.name || n.name !== a[-~i]?.name);

если сортировка по именам не нужна:

const newArr = [...arr]
  .sort((a, b) => a.price - b.price)
  .filter((n, i, a) => n !== a.find(m => m.name === n.name));

если сортировка по именам не нужна и единственные экземпляры надо сохранять:

const newArr = [...arr].sort((a, b) => a.price - b.price);

Object
  .values(newArr.reduce((acc, n) => ((acc[n.name] ??= []).push(n), acc), {}))
  .forEach(n => n.length !== 1 && newArr.splice(newArr.indexOf(n[0]), 1));

Распарсить объект. Отфильтровать данные. Запаковать обратно.

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

https://www.w3resource.com/javascript-exercises/ja...
а ведь надо погуглить

Да вот-вот, только без спама