Javascript 如何测试数组索引是否在任意端点和起点之间？

编辑：4年后，我认为这对我来说是一个问得不好的问题。我希望它能对某些人有用，但我认为它是一个很好的删除候选人。继续说下去

假设我有一个数组，某个函数遍历该数组的子数组。此外，如果子数组包含超出数组末尾的索引，则子数组将在数组的第一个索引处恢复

例如，如果数组长度为50，索引从0开始

48 49 0 1 ...

特别是，我使用JavaScript的余数操作符从头到尾进行计算<代码>数组[i%array.length]

虽然这可以得到我想要的连续索引集，但我还想基于索引值进行一些过滤，如果它们超出某个点，我想排除它们。例如，仅将索引“保持在”48和1之间；开始时包含，结束时独占

我所做的只是在一个条件下进行过滤，例如

item.index>=idx&&item.index

，但这显然不适用于数组的开头和结尾

因此，正如标题所述，如何有效地检查给定索引或一组索引是否位于这些点之间

就本问题而言，起点是包容性的，终点是排他性的

---

编辑：为了回应反对票，我澄清了问题并添加了几个片段。为了简洁起见，我省略了问题的每个细节。

如果没有其他条件，这将是一个无限循环，但下面是如何完成的：

for (var i = 1; someCondition; i++) {
    if (i >= array.length - 1) {
        i = 1;
    }
    // some code
}

---

这样的办法应该行得通

function checkPresence(arr, start, stop, value){
  if (arr.slice(arr.indexOf(start), arr.indexOf(stop)).indexOf(value) != -1)
    return true;
  else return false;
}

var tab = [12, 2, 36, 14, 48, 49, 0, 1];
console.log(checkPresence(tab, 48, 1, 49));

---

建议的答案是正确的，但并没有达到目的。我的问题很难表达，所以我不怪他们

对于未来的访问者，下面是实现我的想法的代码

/*源阵列*/
var源=[]；
对于（变量i=0；i<10；i++）{
push（{index:i}）；
}
/*目标阵列*/
var目标=[]；
/*数组中的初始索引引用；在0和长度-1之间绑定*/
var指数=0；
/*要“显示”或分配给子阵列的项目计数；索引=0时，项0,1,2,3将在子数组中*/
var=3；
/*初始目标*/
target=source.slice（索引，显示）；
/*指定更新子阵列时要替换的项目数*/
var增量=1；
变量迭代器=[1,2,3,4,5,6,7,8,9]；
迭代器.forEach（函数（项，i）{
滑动（增量）；
});
console.log（'第一个索引应位于索引：'+iterator.length'，实际索引为：'，目标[0].index）；
console.log（'最后一个索引应位于索引：'+（iterator.length+show-1）%source.length'，实际索引为：'，目标[target.length-1].index）；
功能幻灯片（按）{
如果（！by）{
by=1；
}
var len=source.length；
var-idx；
如果（索引+通过<0）{
idx=len-Math.abs（by）；
}否则如果（索引+按>=len）{
idx=通过；
}否则{
idx=指数+指数；
}
var start=idx+show；
var i；
var j；
对于（i=idx，j=0；i=0）{
目标[loc]={index:null}；
}
目标[j]=源[i%len]；
}
索引=（idx）>len？idx len:idx；
}

一个元素位于两个其他元素之间是什么意思？按照您的说法，任何点都位于任何其他点之间，因为每个点都可能在以后再次出现。这难道不会创建一个无限循环吗？也许你应该解释一下为什么需要这样做。把模运算作为一个起点。这样，思考问题就容易多了。请在你的问题中给出答案。完整性比简洁性更重要。我将一个项目的索引与源数组的索引进行比较。您正在查看编号49、48和1的

索引…但在我的例子中，这些是索引，1永远不会超过49或48。您可以编写原始数组和子数组示例吗？因为对我来说，数组是一系列可以通过索引访问的值。是的，我可以沿着这些思路做一些事情，但它不是很优雅。你觉得（var I=0；condition；I=I>=array.length？0:I+1）的
更优雅吗？你也可以对递增部分使用
i=（i+1）%array.length
，但这比你需要的更多，性能也更低。我对我的答案进行了编辑，这样它就不会在开始索引和结束索引之间迭代。如果你仍然想使用模，但想要性能，请查看哪个显示了比模更快的替代方案。
/* source array */
var source = [];

for (var i = 0; i < 10; i++) {
    source.push({ index: i });
}

/* target array */
var target = [];

/* initial index reference in the array; bound between 0 and length-1 */
var index = 0;

/* count of items to be 'displayed', or allocated to the subarray; with index = 0, items 0,1,2,3 will be in the subarray */
var show = 3;

/* init target */

target = source.slice(index,show);

/* specifies count of items to be replaced when updating the subarray */
var increment = 1;

var iterator = [1,2,3,4,5,6,7,8,9];

iterator.forEach(function(item,i) {
    slide(increment);
});

console.log('first index should be at index: ' + iterator.length, 'actual index is: ', target[0].index);
console.log('last index should be at index: ' + (iterator.length + show - 1)%source.length, 'actual index is: ', target[target.length-1].index);

function slide(by) {

      if (!by) {
        by = 1;
      }

      var len = source.length;
      var idx;

      if (index + by < 0) {
        idx = len - Math.abs(by);
      } else if (index + by >= len) {
        idx = by;
      } else {
        idx = index + by;
      }

      var start = idx + show;

      var i;
      var j;

      for (i = idx, j = 0; i < start; i++, j++) {

        var loc = target.indexOf(source[i%len]);

        if (loc >= 0) {
          target[loc] = { index: null };
        }

        target[j] = source[i%len];
      }

      index = (idx) > len ? idx-len : idx;

}