javascript - 如何从同一数组的反向中找到数组 1 的相邻元素

Question

function compareNumbers(x, y) {
return x - y;
}  
var a = [3,6,2,7,8,10,43] //I have one array
var b = a.slice().sort(compareNumbers).reverse(); //I reverse this array 

//现在我有2个数组

a = [3,6,2,7,8,10,43]
b = [43, 10, 8, 7, 6, 3, 2]   

我的问题：我想在数组 a 中找到 b 的相邻元素。例如：

b[0] 即 43 ，想在数组 a 中找到 43 的两个邻居。// 10

b[1] 即 10 ，想在数组 a 中找到 10 的两个邻居。// 43,8

b[6] 即 2，想在数组 a 中找到 2 的两个邻居。// 6,7

Answer 1

如果其中一个邻居不存在，您将得到null.

var searchvalue = b[0]
var index = a.indexOf(searchvalue)

var firstNeighbour = index > 0 ? a[index-1] : null
var secondNeighbour = index < (a.length - 1) ? a[index + 1] : null

Answer 2

您可以运行数组的循环，然后检查它是否可以有左或右邻居，是否有它，如果它没有离开那个邻居。例如，如果循环是第一个，那么在这种情况下将没有左邻居离开 left_neigbour，如果循环是最后一个，那么在这种情况下将没有右邻居离开右邻居并获得 left_neighbour。只需使用以下代码

a = [3,6,2,7,8,10,43];
    b = [43, 10, 8, 7, 6, 3, 2];
    for (i = 0; i < b.length; i++) {
        if (i == 0) {
            var left_neighbour = '';
        } else {
            var left_neighbour = a[i - 1];
        }
        if (i == b.length) {
            var right_neighbour = '';
        } else {
            var right_neighbour = a[i + 1];
        }
        if (left_neighbour !== '') {
            if (right_neighbour) {
                console.log(left_neighbour + "," + right_neighbour);
            } else {
                console.log(left_neighbour);
            }
        } else {
            if (right_neighbour) {
                console.log(right_neighbour);
            } else {
                console.log(left_neighbour);
            }
        }

    }

这是小提琴：http: //jsfiddle.net/r3vvba58/1/

希望这可以帮助你

Answer 3

无需第二个数组并获得舒适的数据读取：

http://jsfiddle.net/7pz13Lg2/1/

var a = [3,6,2,7,8,10,43];

a.retrieveNeighbour = function (needle) {
    if (this.indexOf(needle) == -1) {
        return {
            right: null,
            left: null
        }; 
    }
    else {
        return {
            left: (this[this.indexOf(needle)-1] != undefined) && this[this.indexOf(needle)-1],
            right: (this[this.indexOf(needle)+1] != undefined) &&  this[this.indexOf(needle)+1]
        }
    }
};
console.log(a.retrieveNeighbour(3).right);
console.log(a.retrieveNeighbour(6).left);
console.log(a.retrieveNeighbour(93).right);

要检索 LEFT 邻居，请使用：

a.retrieveNeighbour(search).left;

要检索正确的：

a.retrieveNeighbour(search).right;

如果数组中不存在该元素，则脚本向左和向右都返回 null。

如果元素存在但属性不存在（如a.retrieveNeighbour(3).left），则脚本将 false 分配给该值。

测试：