javascript - 选择数组中的两个最大值

Question

我正在尝试编写一个函数，在一个数字数组中找到两个最大值并将它们存储在一个新数组中。我无法先从原始数组中删除第一个最大的数字，然后再找到第二大的数字。

这是我的代码:

function choseBig (myArray) {
    //var myArray = str.split(" "); 
    var result = [];
    var firstBig;
    var secondBig;
        // select the biggest value
        firstBig = Math.max.apply(Math, myArray);
        // find its index
        var index = myArray.indexOf(firstBig);
        // remove the biggest value from the original array 
        var myArray_2 = myArray.slice((index -1), 1);
        // choose the second biggest value
        secondBig = Math.max.apply(Math, myArray_2);
        // push the results into a new array
        result.push(firstBig, secondBig);

    return result;
}

console.log(choseBig ([1,2,3,4,5,9]));  

Answer 1

乍一看，我建议:

function choseBig(myArray) {
  return myArray.sort((a, b) => b - a).slice(0, 2);
}

console.log(choseBig([1, 2, 3, 4, 5, 9]));

为了稍微扩展上面的内容，例如为用户提供选项以指定返回值应该是最高数字还是最低数字，以及他们希望返回多少，我会提供以下内容:

function choseBig(myArray, opts) {
  // 'max':      Boolean,
  //             true:  returns the highest numbers,
  //             false: returns the lowest numbers
  // 'howMany':  Number,
  //             specifies how many numbers to return:
  var settings = {
      'max': true,
      'howMany': 2
    };

  // ensuring we have an Object, otherwise
  // Object.keys( opts ) returns an error:
  opts = opts || {};

  // retrieving the keys of the opts Object, and
  // uses Array.prototype.forEach() to iterate over
  // those keys; 'o' (in the anonymous function) is
  // the array element (the property-name/key) from
  // the array Object keys over which we're iterating:
  Object.keys(opts).forEach(function(o) {

    // updating the settings Object to the new values
    // (if any is specified) to those set in the user-
    // supplied opts Object:
    settings[o] = opts[o];
  });

  // here we first sort the Array, using a numeric sort;
  // using ES2015 Arrow functions. 'a' and 'b' are supplied
  // by Array.prototype.sort() and refer to the current ('a')
  // and next ('b') array-elements. If b - a is less than zero
  // b is moved to a lower index; if a - b is less than zero
  // a is moved to a lower index.
  // Here we use a ternary operator based on whether settings.max
  // is true; if it is true we sort to move the larger number to
  // the lower index; otherwise we sort to move the smaller number
  // to the lower index.
  // Then we slice the resulting array to return the numbers from
  // the 0 index (the first number) to the settings.howMany number
  // (the required length of the array).
  // this is then returned to the calling context.
  return myArray.sort((a, b) => settings.max === true ? b - a : a - b).slice(0, settings.howMany);
}

console.log(choseBig([1, 2, 3, 4, 5, 9], {
  // here we specify to select the largest numbers:
  'max': true,
  // we specify we want the 'top' three numbers:
  'howMany': 3
}));

function choseBig(myArray, opts) {
  var settings = {
    'max': true,
    'howMany': 2
  };

  opts = opts || {};

  Object.keys(opts).forEach(function(o) {
    settings[o] = opts[o];
  });

  return myArray.sort((a, b) => settings.max === true ? b - a : a - b).slice(0, settings.howMany);
}

console.log(choseBig([1, 2, 3, 4, 5, 9], {
  'max': true,
  'howMany': 3
}));

JS Fiddle demo .

引用资料:

• > Array.prototype.forEach .
• > Array.prototype.slice() .
• > Array.prototype.sort() .
• > Conditional (Ternary) Operator: statement ? ifTrue : ifFalse
  • > How do you use the ? : (conditional) operator in JavaScript? .
• > Object.keys() .