Javascript 循环通过循环的数字序列

有一个由数字组成的

数组
[1,2,3,4,5,6,7,8,9,10]

我需要从这个序列中获得所有数字，这些数字与当前的2个以上的项目不同，但是是循环的

例如，如果当前编号为1，则新列表应包含除
9,10,1,2,3
之外的所有内容，或者如果当前编号为4，则新列表应包含除
2,3,4,5,6
之外的所有内容

有什么技术可以做到这一点，而不必在开始和结束时为项目创建多个循环

谢谢。
我认为这符合您的要求：

// Sorry about the name
function strangePick(value, array) {
  var n = array.length
    , i = array.indexOf(value);

  if (i >= 0) {
    // Picked number
    var result = [value];

    // Previous 2 numbers
    result.unshift(array[(i + n - 1) % n]);
    result.unshift(array[(i + n - 2) % n]);

    // Next 2 numbers
    result.push(array[(i + 1) % n]);
    result.push(array[(i + 2) % n]);

    return result;
  } else {
    return [];
  }
}

一些测试：

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

console.log(strangePick(1, array)); // [9,10,1,2,3]
console.log(strangePick(4, array)); // [2,3,4,5,6]

您可以使用javascript array.slice：

function get_offset_sequence(arr, index, offset) {
        var result = [];
        if (index - offset < 0) {
            result = arr.slice(index - offset).concat(arr.slice(0, index + offset + 1));
        }
        else if (index + offset > arr.length - 1) {
            result = arr.slice(index - offset).concat(arr.slice(0, Math.abs(arr.length - 1 - index - offset)));
        }
        else {
            result = arr.slice(index - offset, index + offset + 1)
        }
        return result;
    }

函数获取偏移量序列（arr、索引、偏移量）{
var结果=[]；
如果（索引-偏移量<0）{
结果=arr.slice（索引-偏移量）.concat（arr.slice（0，索引+偏移量+1））；
}
否则如果（索引+偏移>阵列长度-1）{
结果=arr.slice（index-offset）.concat（arr.slice（0，Math.abs（arr.length-1-index-offset））；
}
否则{
结果=arr.slice（索引-偏移，索引+偏移+1）
}
返回结果；
}

使用示例：

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var index = 1;
var offset = 2;

for (var i=0; i < 10; i++) { console.log(i, arr[i], get_offset_sequence(arr, i, offset)) }

var-arr=[1,2,3,4,5,6,7,8,9,10]；
var指数=1；
var偏移=2；
对于（vari=0；i<10；i++）{console.log（i，arr[i]，获取_offset_序列（arr，i，offset））}
变量a=[1,2,3,4,5,6,7,8,9,10]；
var exclude=函数（开始、距离、数组）{
var结果=[]；
对于（var i=0；i距离）{
结果：push（数组[i]）；
}                                         
}                                             
返回结果；
}                                                 
你能提供更多的例子吗？又增加了一个例子，希望现在更清楚。数组总是一样的吗？如果它总是在10点循环？它是否总是包含连续的元素等。它们返回的顺序是与原始数组相同还是与顺序无关？新的顺序应该相同，但没有这些数字。数组长度和项目数是动态的（可以是包含25个项目的数组，也可以是包含300个项目的数组）。而且总是连续的，谢谢。你的方法是最快的。我刚刚更改为“d>距离”，因为我需要新数组中的项目已经排除。
var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];          

var exclude = function (start, distance, array) { 
    var result = [];                              

    for (var i = 0; i < array.length; i++) {      

        var d = Math.min(                         
            Math.abs(start - i - 1),              
            Math.abs(array.length + start - i - 1)
        )                                         

        if (d > distance) {                      
            result.push(array[i]);                
        }                                         
    }                                             

    return result;                                
}