Javascript: использование reduce() для поиска минимального и максимального значений?

Хитрость заключается в предоставлении пустого массива в качестве параметра initialValue.

arr.reduce(callback, [initialValue])

initialValue [Необязательно] Значение для использования в качестве первого аргумента при первом вызове обратного вызова. Если начальное значение не указано, будет использован первый элемент массива.

Таким образом, код будет выглядеть так:

function minMax(items) {
    return items.reduce((acc, val) => {
        acc[0] = ( acc[0] === undefined || val < acc[0] ) ? val : acc[0]
        acc[1] = ( acc[1] === undefined || val > acc[1] ) ? val : acc[1]
        return acc;
    }, []);
}

В ES6 вы можете использовать оператор распространения. Одно строковое решение:

 Math.min(...items)

Вы можете использовать массив в качестве возвращаемого значения:

function minMax(items) {
    return items.reduce(
        (accumulator, currentValue) => {
            return [
                Math.min(currentValue, accumulator[0]), 
                Math.max(currentValue, accumulator[1])
            ];
        }, [Number.MAX_VALUE, Number.MIN_VALUE]
    );
}

Решение с использованием функций Math.min() и Math.max():

function minMax(items) {
    var minMaxArray = items.reduce(function (r, n) {
            r[0] = (!r[0])? n : Math.min(r[0], n);
            r[1] = (!r[1])? n : Math.max(r[1], n);
            return r;
        }, []);

    return minMaxArray;
}

console.log(minMax([4, 1, 2, 7, 6]));

Поскольку вызов сокращения на самом деле не нужен, вы можете повеселиться с ним.

let items = [62, 3, 7, 9, 33, 6, 322, 67, 853];

let arr = items.reduce((w,o,r,k,s=Math)=>[s.min.apply(0, k),s.max.apply(0, k)],[]);

console.log(arr);

Все, что вам действительно нужно, это let minMaxArray = [Math.min.apply(0,items), Math.max.apply(0,items)]

Вы можете использовать сделать так. Аргументов может быть сколько угодно.

function minValue(...args) {
    const min = args.reduce((acc, val) => {
        return acc < val ? acc : val;
    });
    return min;
}

function maxValue(...args) {
    const max= args.reduce((acc, val) => {
        return acc > val ? acc : val;
    });
    return max;
}

Чтобы получить минимальное и максимальное значение массива, используя функцию уменьшения

const ArrayList = [1, 2, 3, 4, 3, 20, 0];
const LargestNum = ArrayList.reduce((prev, curr) => {
      return Math.max(prev, curr)
});
const MinNum = ArrayList.reduce((prev,curr)=>{
      return Math.min(prev,curr)
});
console.log(LargestNum);
console.log(MinNum);

let arr = [8978, 'lol', -78, 989, NaN, null, undefined, 6, 9, 55, 989];


let minMax = arr.reduce(([min, max], v) => [
                Math.min(min, v) || min,
                Math.max(max, v) || max], [Infinity, -Infinity]);


console.log(minMax);

Как это работает:

1. || min чек v номер.

2. [Infinity, -Infinity] это .reduce начальное значение

3. Он использует присваивание js destructuring

1. Решение с использованием только Math.min и Math.max:

⚠️ Это не сработает, если вы используете большие массивы, т. е. предоставляете Math.min() много аргументов, так как вы рискуете превысить ограничение длины аргумента движка JavaScript. Последствия применения функции со слишком большим количеством аргументов (думаю, более десятков тысяч аргументов) различаются в зависимости от движка (JavaScriptCore имеет жестко запрограммированное ограничение на количество аргументов, равное 65 536), потому что ограничение (на самом деле, даже природа любого чрезмерно большого стека поведение) не указано. Некоторые механизмы выдают исключение. из веб-документов MDN.

function minMax(items) {
  return [
      Math.min.apply(null, items),
      Math.max.apply(null, items)
  ]
}

... или если вы предпочитаете синтаксис Spread ES6:

const minMax = items => [
  Math.min(...items),
  Math.max(...items)
]

function minMax(arr) {
  return arr.reduce(function(acc, cur) {
    return [
      Math.min(cur, acc[0]),
      Math.max(cur, acc[1])
    ]
  }, [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]);
}

const minMax = items =>
  items.reduce((acc, cur) =>
    [Math.min(cur, acc[0]), Math.max(cur, acc[1])],
    [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]
  )

function minMax(items) {
  let newItems = []
  const isArray = Array.isArray(items)
  const onlyHasNumbers = !items.some(i => isNaN(parseFloat(i)))

  // only proceed if items is a non-empty array of numbers
  if (isArray && items.length > 0 && onlyHasNumbers) {
    newItems = items.reduce((acc, cur) => [
        Math.min(cur, acc[0]),
        Math.max(cur, acc[1])
      ], [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])
  }

  return newItems
}

Документация для Math.min

Документация по Math. макс

Документация для Array.prototype.reduce()< /а>

Мы можем добиться этого, объявив пустой массив в качестве значения аккумулятора для функции сокращения, а затем выполнив другой набор операций на последней итерации метода сокращения. Мы делаем это, передавая все четыре параметра методу сокращения (total, item, index, array) и используя сравнение индекса с длиной массива, чтобы сделать что-то другое на этой последней итерации.

var prices = [32.99, 21.99, 6.99, 4.99, 12.99, 8.98, 5.99];

var highLowPrices = prices.reduce(function(accumulatorArray, price, index, pricesArray){
    if (index === pricesArray.length-1){
        accumulatorArray.push(price);
        var returnArray = [];
        accumulatorArray.sort(function(price1, price2){
            return price1 - price2;
        });
        var lowestPrice = accumulatorArray[0];
        var highestPrice = accumulatorArray[accumulatorArray.length-1];
        returnArray.push(lowestPrice);
        returnArray.push(highestPrice);
        return returnArray;
    } else {
        accumulatorArray.push(price);
        return accumulatorArray;
    }
}, []);

console.log(highLowPrices);

Я намеренно использовал несколько шагов больше, чем необходимо, и использовал семантически подробные имена переменных, чтобы сделать логику более понятной.

if (index === pricesArray.length-1) означает, что на последней итерации метода сокращения массива цен выполняется другой набор операций. До этого момента мы просто воссоздаем массив цен, что тривиально. Но на последней итерации, после полного воссоздания массива цен, мы делаем что-то другое. Мы создаем еще один пустой массив, тот, который мы собираемся вернуть. Затем мы сортируем переменную 'accumulatorArray', которая является воссозданным массивом цен, сортируя его от самой низкой до самой высокой. Теперь мы берем самую низкую цену и самую высокую цену и сохраняем их в переменных. Отсортировав массив в порядке возрастания, мы знаем, что самый низкий индекс находится в индексе 0, а самый высокий — в индексе array.length - 1. Затем мы помещаем эти переменные в наш ранее объявленный возвращаемый массив. И вместо того, чтобы возвращать саму переменную-аккумулятор, мы возвращаем свой собственный специально объявленный возвращаемый массив. Результатом является массив с самой низкой ценой, а затем с самой высокой ценой.

Я знаю, что на этот вопрос был дан ответ, но я отказался от ответа @Sergey Zhukov (который кажется неполным) и смог получить минимальное и максимальное значения в двух строках:

let vals = [ numeric values ]
let min = Math.min.apply(undefined, vals) 
let max = Math.max.apply(undefined, vals)

Я вижу значение в Array.reduce, но с таким очень простым вариантом использования и, если вы понимаете, что делает Function.apply, это будет моим решением для перехода.