0xD34F

Что, открыть консоль не догадались? Или открыли и тут же закрыли, придя в ужас от количества красного?

$grouped = array_values(array_reduce($arr, function($acc, $n) {
  $acc[$n['api_id']][] = $n;
  return $acc;
}, []));

const newArray = numbers.filter(i => i !== firstMin);

Что, если минимальный элемент представлен в нескольких экземплярах? Вы их все выкинете.

Можно найти индекс минимального элемента и фильтровать по индексу:

function sumTwoSmallestNumbers(nums) {  
  const iMin = nums.indexOf(Math.min(...nums));
  return nums[iMin] + Math.min(...nums.filter((_, i) => i !== iMin));
}

Это если идти вашим путём. Но есть и иные способы решить задачу. Например, можно отсортировать массив и взять два крайних элемента:

const sumTwoSmallestNumbers = ([...nums]) => nums
  .sort((a, b) => b - a)
  .slice(-2)
  .reduce((acc, n) => acc + n, 0);

Или, сосчитать, кто сколько раз повторяется и выбирать второе слагаемое в зависимости от количества повторений первого:

function sumTwoSmallestNumbers(nums) {
  const count = Object.entries(nums.reduce((acc, n) => (acc[n] = -~acc[n], acc), {}));
  return +count[0][0] + +count[+(count[0][1] === 1)][0];
}

Или, пройти по массиву один раз, запоминая встреченные элементы, если они меньше тех, что вам уже попадались (т.е., сделать то, чего от вас тут и ожидается - решить задачу с линейной сложностью по времени и константной по памяти):

function sumTwoSmallestNumbers(nums) {
  let min1 = Infinity;
  let min2 = Infinity;

  for (const n of nums) {
    if (n < min1) {
      [ min1, min2 ] = [ n, min1 ];
    } else if (n < min2) {
      min2 = n;
    }
  }

  return min1 + min2;
}

// или

const sumTwoSmallestNumbers = nums =>
  eval(nums.reduce(([ min1, min2 ], n) => 
    n < min1 ? [    n, min1 ] :
    n < min2 ? [ min1,    n ] :
               [ min1, min2 ]
  , [ Infinity, Infinity ]).join('+'));

Понадобится функция, которая позволит вложенные массивы развернуть в один плоский:

// есть вариант применить рекурсию
const flatTree = (tree, childrenKey) =>
  (tree instanceof Array ? tree : []).reduce((acc, n) => (
    acc.push(n, ...flatTree(n[childrenKey], childrenKey)),
    acc
  ), []);

// а можно обойтись и без неё
const flatTree = function*(tree, childrenKey) {
  const stack = [];

  for (let [ i, arr ] = this(tree); ++i < arr.length || stack.length;) {
    if (i === arr.length) {
      [ i, arr ] = stack.pop();
    } else {
      yield arr[i];
      stack.push([ i, arr ]);
      [ i, arr ] = this(arr[i][childrenKey]);
    }
  }
}.bind(x => [ -1, Array.isArray(x) ? x : [] ]);

Дальше всё просто - вычисляемое свойство, v-for по его значению:

computed: {
  users() {
    // если использовать обычную функцию
    return flatTree(this.elements, 'children');

    // или, генератор
    return [...flatTree(this.elements, 'children')];
  },
},

<option v-for="n in users" :key="n.id">{{ n.name }}</option>

Promise
  .all(urls.map(url => fetch(url).then(r => r.json())))
  .then(results => results.forEach(n => console.log(n.id)));

<gmap-map
  ref="map"
  ...

const bounds = new google.maps.LatLngBounds();
массивКоординатВашихЛокаций.forEach(n => bounds.extend(n));
this.$refs.map.fitBounds(bounds);

https://codesandbox.io/s/for-https-qna-habr-com-q-...

$grouped = array_values(array_reduce($arr, function($acc, $n) {
  $acc[$n[0]] ??= [ $n[0] ];
  array_push($acc[$n[0]], ...array_slice($n, 1));
  return $acc;
}, []));

Как перемножить элементы массива:

const mul = arr =>
  arr.reduce((acc, n) => acc * n, 1);

// или

const mul = arr =>
  eval(arr.join('*')) ?? 1;

// или

function mul(arr) {
  let result = 1;
  for (const n of arr) {
    result *= n;
  }
  return result;
}

// или

function mul(arr) {
  let result = 1;
  for (let i = 0; i < arr.length; i++) {
    result = result * arr[i];
  }
  return result;
}

// или

const mul = (arr, i = 0) =>
  i < arr.length
    ? arr[i] * mul(arr, -~i)
    : 1;

Бежим по массиву с количествами элементов, получаем из массива с данными подмассивы указанной длины, перемножаем их содержимое:

const result = count.map(function(n) {
  return mul(data.slice(this[0], this[0] += n));
}, [ 0 ]);

Или, если массив с данными больше не понадобится, можно всегда вырезать у него из начала указанное количество элементов:

const result = count.map(n => mul(data.splice(0, n)));

function combine(a = {}, b = {}, c = {}) {

Читаю текст задачи сверху вниз, снизу вверх, так, сяк, наперекосяк, и никак не могу найти там место, где говорится, что объектов в функцию будет передаваться не больше трёх.

Как обработать заранее неизвестное количество аргументов?

Можно собрать их в массив:

const combine = (...arr) => arr
  .flatMap(Object.entries)
  .reduce((acc, [ k, v ]) => (acc[k] = (acc[k] ?? 0) + v, acc), {});

Или, воспользоваться уже готовым массивоподобным объектом:

function combine() {
  const result = {};

  for (const n of arguments) {
    for (const k in n) {
      if (n.hasOwnProperty(k)) {
        if (!result.hasOwnProperty(k)) {
          result[k] = 0;
        }

        result[k] += n[k];
      }
    }
  }

  return result;
}

const mostFrequentNum = Array
  .from(arr.reduce((acc, n) => acc.set(n, -~acc.get(n)), new Map))
  .reduce((max, n) => max[1] > n[1] ? max : n, [ , 0 ])
  .at(0);

или

const mostFrequentNum = Object
  .entries(arr.reduce((acc, n) => (acc[n] = (acc[n] ?? 0) + 1, acc), {}))
  .reduce((acc, n) => (acc[n[1]] = +n[0], acc), [])
  .pop();

не хочу дублировать код в v-slot:fastFilters, но как мне сделать так, чтоб по определенному флагу на фильтрах он появлялся и в fastFilters

Дублируйте не снаружи, а внутри - то есть, не контент, передаваемый в слот, а сам слот:

<toolbar>
  <slot name="fastFilters">
  <slot name="filters" v-if="а здесь ваш флаг">
</toolbar>
<div class="filters">
  <slot name="filters">
</div>

https://jsfiddle.net/qphgbv8k/

Не выдумывайте, всё реактивно. Просто вы заменяете массив в хранилище (мутация remove) - после этого в хранилище у вас одни данные, а рендер вы выполняете на основе других.

let [0: [fruit1, fruit2, fruit3]] = arr; //Uncaught SyntaxError: Invalid destructuring assignment target

Скажите, а когда массив создаёте, вы тоже индексы явно прописываете? Ну вот и тут не надо.
А если надо пропустить какие-то индексы - просто добавьте запятых:

const arr = [
  [ 1, 2, 3 ],
  [ 5, 6, 7 ],
  [ 7, 8, 9 ],
];

const [ , [ , val1 ], [ ,, val2 ] ] = arr;

console.log(val1, val2); // 6 9

Или можно заменить квадратные скобки фигурными - массив это тоже объект.
Так что и деструктурировать его как обычный объект не возбраняется:

const arr = [
  [ 1, 2, 3 ],
  [ 5, 6, 7 ],
  [ 7, 8, 9 ],
];

const { 1: { 1: val1 }, 2: { 2: val2 } } = arr;

console.log(val1, val2); // 6 9

раз:

The keys and the values are always in the UTF-16 string format...

два

props: {
  modelValue: {
    type: String,
    default: '',
  },
},
emits: [ 'update:modelValue' ],
setup(props, { emit }) {
  const value = ref('');

  watchEffect(() => value.value = props.modelValue);

  return {
    value,
    onInput: e => emit('update:modelValue', value.value = e.target.value),
  };
},

<input :value="value" @input="onInput">

Вам это не нужно.

Собирайте "передаваемый объект" перед запросом - часть данных достаёте из обычных свойств компонента, часть из computed. Или можете оформить его как ещё одно computed свойство.

Object.values(t).forEach(n => {
  n.children?.sort((a, b) => (a.order - b.order) || a.name.localeCompare(b.name));
});

Как получить квадрат числа:

const square = n => n ** 2;

// или

const square = n => n * n;

// или

const square = n => Math.pow(n, 2);

Как обновить массив:

arr.forEach((n, i, a) => a[i] = square(n));

// или

arr.splice(0, arr.length, ...arr.map(square));

// или

for (const [ i, n ] of arr.entries()) {
  arr[i] = square(n);
}

// или

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