Javascript 检查数组中的值是否在范围内

我需要检查我的数组是否在特定范围内

我有一个数组：

var times = [79, 118, 145, 245, 688, 833, 934, 956, 1019, -339, -324, -265, 65, 81, 83, 121, 151, 154, 359]

并希望获得这些范围内的值计数：

var ranges = ['0-10', '11-20', '21-30', '31-40', '41-50', '51-60', '61 +'];

这是我目前掌握的代码

$.each(times, function (i, datum) 
{
    if (datum <= 0) 
        sum1 += 1;
    else if (datum > 10 && datum <= 20) 
        sum2 += 1;
    else if (datum > 20 && datum <= 30)
        sum3 += 1;
    else if (datum > 30 && datum <= 40)
        sum4 += 1;
    else if (datum > 40 && datum <= 50)
        sum5 += 1;
    else if (datum > 50 && datum <= 60)
        sum6 += 1;
    else if (datum > 60)
        sum7 += 1;
}

$。每个（时间、函数（i、基准）
{
如果（基准10和基准20和基准30和基准40和基准50和基准60）
sum7+=1；
}

---

如何获取范围和和的对象。例如，{'0-10'：2，'11-20'：19，'21-30'：45}

假设您将范围重写为这样：

rangeList = $.map(ranges, function(item) {
    values = item.split('-')
    return {min: parseInt(values[0]), max: parseInt(values[1]) || Number.POSITIVE_INFINITY, label: item}
})

您有一个很好的结构。现在您必须针对每个范围测试每个值。（从技术上讲，您可以在第一次匹配时停止，因此您可能可以使用

any

，而不是

each

，如果满足范围，则返回true）

var总和={}
$。每个（时间，函数（i，基准）{
$.each（范围列表，函数（范围索引，范围）{
如果（基准面>range.min&&datum
var时间=[79118145245688339349561019，-339，-324，-265658183121154359]；
变量范围=['0-10'、'11-20'、'21-30'、'31-40'、'41-50'、'51-60'、'61+']；
函数getObj（范围）{
var obj={}；
范围=范围。替换（“+”，“-无限”）；
var arr=范围分割（“-”）；
返回{sum:0，min:Number（arr[0]），max:Number（arr[1]）；
}
var和={}；
对于（var i=0；i，我建议输出一个集合，而不是一个对象，因为它更易于使用；因为它是一个对象数组，您可以对其进行过滤、映射和缩减，而这在对象上是不容易做到的。例如：

function getStepRanges(ranges, times) {
  return ranges.map(function(range) {
    var ranges = range.split(/[-+]/)
    var min = +ranges[0]
    var max = +ranges[1] || Infinity
    return times.reduce(function(acc, x) {
      // Note that your range is not inclusive
      // you may want to do "x >= min" instead
      if (x > min && x <= max) {
        acc.range = range
        acc.values = (acc.values||[]).concat(x)
      }
      return acc
    },{})
  })
}

它将返回此集合：

[ { range: '0-10', values: [ 1, 2, 3, 4, 5, 10 ] },
  { range: '11-20', values: [ 12, 13, 14 ] },
  { range: '21-30', values: [ 23, 24, 25, 26 ] },
  { range: '31-40', values: [ 32, 33, 34, 35 ] },
  { range: '41-50', values: [ 42, 43, 44, 45 ] },
  { range: '51-60', values: [ 52, 53, 54, 55 ] },
  { range: '61+', values: [ 62, 63 ] } ]

利用这些数据，您可以执行所需操作，例如获取最大值：

var result = getStepRanges(ranges, times)

// Easy, we have a collection!
// but careful, it mutates the original object
// you may want to use an "extend" helper to clone it first
var maxRanges = result.map(function(x) {
  x.max = Math.max.apply(0, x.values)
  return x
})

console.log(maxRanges)
/*[ { range: '0-10', values: [ 1, 2, 3, 4, 5, 10 ], max: 10 },
  { range: '11-20', values: [ 12, 13, 14 ], max: 14 },
  { range: '21-30', values: [ 23, 24, 25, 26 ], max: 26 },
  { range: '31-40', values: [ 32, 33, 34, 35 ], max: 35 },
  { range: '41-50', values: [ 42, 43, 44, 45 ], max: 45 },
  { range: '51-60', values: [ 52, 53, 54, 55 ], max: 55 },
  { range: '61+', values: [ 62, 63 ], max: 63 } ]*/

没有，因此如果没有答案，答案将是完整的：

var时间=[791181452456888339349561019，-339，-324，-265658183121151154359]
变量范围=['0-10'、'11-20'、'21-30'、'31-40'、'41-50'、'51-60'、'61+']；
var计数=(范围).减少(功能)(备注,范围){
备注[范围]=0；
返回备忘录；
}, {});
counts.outOfBounds=0；
var rangePattern=/（\d+）\s*-\s*（\d+）/；
var moreThanPattern=/（\d+）\s*\+/；
var lessThanPattern=/-\s*（\d+）/；
_（次）.forEach（函数（值）{
变量范围=(范围).find（函数(testRange){
var匹配；
开关（假）{
案例！（match=testRange.match（rangePattern））：
返回（值>=match[1]&&value=match[1]）；
案例！（match=testRange.match（lessThanPattern））：
返回（值您可以尝试以下代码：

var times = [79, 118, 145, 245, 688, 833, 15, 934, 956, 1019, -339, -324, -265, 65, 81, 83, 121, 151, 154, 359];
var ranges = ['0-10', '11-20', '21-30', '31-40', '41-50', '51-60', '61 +'];
var rangeStops = [0,11,21,31,41,51,61];
var rangeCounts = [0];
//sort the times first 
times.sort(function(a,b){return a - b});
var k = 0;
for(var i = 0; i < times.length; i++){    
  if(rangeStops[k] > times[i]) continue;
  else if(rangeStops[k+1] <= times[i]&&k != rangeStops.length - 1){
    rangeCounts[++k] = 0;          
    i--;
  } else rangeCounts[k]++;
}
//output
ranges = ranges.map(function(e,i){    
  var result = {};
  result[e] = rangeCounts[i];
  return result;
});
//log it and see the result in console window
console.log(ranges);

您的范围最好描述为
[[0,10]，[11,20]，[21,30]，[31,40]，[41,50]，[51,60]，[61，Number.POSITIVE_INFINITY]
（或
[{min:0，max:10，label:'0-10'}，][/code>）以及您需要帮助的问题到底是什么？您的问题中没有实际问题。
[ { range: '0-10', values: [ 1, 2, 3, 4, 5, 10 ] },
  { range: '11-20', values: [ 12, 13, 14 ] },
  { range: '21-30', values: [ 23, 24, 25, 26 ] },
  { range: '31-40', values: [ 32, 33, 34, 35 ] },
  { range: '41-50', values: [ 42, 43, 44, 45 ] },
  { range: '51-60', values: [ 52, 53, 54, 55 ] },
  { range: '61+', values: [ 62, 63 ] } ]

var result = getStepRanges(ranges, times)

// Easy, we have a collection!
// but careful, it mutates the original object
// you may want to use an "extend" helper to clone it first
var maxRanges = result.map(function(x) {
  x.max = Math.max.apply(0, x.values)
  return x
})

console.log(maxRanges)
/*[ { range: '0-10', values: [ 1, 2, 3, 4, 5, 10 ], max: 10 },
  { range: '11-20', values: [ 12, 13, 14 ], max: 14 },
  { range: '21-30', values: [ 23, 24, 25, 26 ], max: 26 },
  { range: '31-40', values: [ 32, 33, 34, 35 ], max: 35 },
  { range: '41-50', values: [ 42, 43, 44, 45 ], max: 45 },
  { range: '51-60', values: [ 52, 53, 54, 55 ], max: 55 },
  { range: '61+', values: [ 62, 63 ], max: 63 } ]*/

var times = [79, 118, 145, 245, 688, 833, 934, 956, 1019, -339, -324, -265, 65, 81, 83, 121, 151, 154, 359]

var ranges = ['0-10', '11-20', '21-30', '31-40', '41-50', '51-60', '61 +'];

var counts = _(ranges).reduce(function(memo, range) {
  memo[range] = 0;
  return memo;
}, {});

counts.outOfBounds = 0;

var rangePattern    = /(\d+)\s*-\s*(\d+)/;
var moreThanPattern = /(\d+)\s*\+/;
var lessThanPattern = /-\s*(\d+)/;

_(times).forEach(function(value) {
  var range = _(ranges).find(function(testRange) {
    var match;
    switch (false) {
      case !(match = testRange.match(rangePattern)):
        return (value >= match[1] && value <= match[2]);
      case !(match = testRange.match(moreThanPattern)):
        return (value >= match[1]);
      case !(match = testRange.match(lessThanPattern)):
        return (value <= match[1]);
      default:
        return false;
    }
  });
  counts[range || 'outOfBounds']++;
});

console.log(counts);

var times = [79, 118, 145, 245, 688, 833, 15, 934, 956, 1019, -339, -324, -265, 65, 81, 83, 121, 151, 154, 359];
var ranges = ['0-10', '11-20', '21-30', '31-40', '41-50', '51-60', '61 +'];
var rangeStops = [0,11,21,31,41,51,61];
var rangeCounts = [0];
//sort the times first 
times.sort(function(a,b){return a - b});
var k = 0;
for(var i = 0; i < times.length; i++){    
  if(rangeStops[k] > times[i]) continue;
  else if(rangeStops[k+1] <= times[i]&&k != rangeStops.length - 1){
    rangeCounts[++k] = 0;          
    i--;
  } else rangeCounts[k]++;
}
//output
ranges = ranges.map(function(e,i){    
  var result = {};
  result[e] = rangeCounts[i];
  return result;
});
//log it and see the result in console window
console.log(ranges);

'0-10': 0
'11-20': 1 //the 15 value
'21-30': 0
'31-40': 0
'41-50': 0
'51-60': 0
'61+' : 16 //all the other positive values