如何在Javascript中获取特定坐标（x，y）周围的坐标

Question

As in title I am struggling with getting coordinates that are around specific coordinate. In this example I will say 24, 7.

Answer 1

I usually use two loops in this case:

 const results = [];

  for(const dx of [-1, 0, 1]) {
   for(const dy of [-1, 0, 1]) {
     if(dx === 0 && dy === 0) continue;
     results.push({ x: x + dx, y: y + dy });
  }
}

Or just:

 const neighbours = [
    [-1, -1], [-1,  0], [-1,  1],
    [ 0, -1], /*0, 0*/  [ 0,  1], 
    [ 1, -1], [ 1,  0], [ 1,  1]
 ];

 const results = neighbours.map(([dx, dy]) => ({ x: x + dx, y: y + dy }));

Answer 2

It's good that you want to not only achieve this, but achieve it nicely! In my personal opinion, this could be made "nice" by working with a definition of "adjacency" explicit in the code.

 // This code makes "adjacency" explicit by working with "adjacency offset generators" // These are functions which return all offsets that move a point to all of its adjacent points let manhattanAdjacencyOffsets = dist => { // Returns adjacency offsets corresponding to all points within a manhattan distance of `dist` let ret = []; for (let x = -dist; x <= dist; x++) { for (let y = -dist; y <= dist; y++) { if (x === 0 && y === 0) continue; // Don't include the 0,0 point ret.push({ x, y }); }} return ret; }; // Now `nCoordinates` becomes very short: let nCoordinates = (x0, y0, adjacencyOffsets) => { return adjacencyOffsets.map(({ x, y }) => ({ x: x + x0, y: y + y0 })); }; // Here's manhattan adjacency offsets with a distance of 1 let adjacencyOffsets = manhattanAdjacencyOffsets(1); // And here's all neighbours of the point (10,20), with regard to those offsets let neighbours = nCoordinates(10, 20, adjacencyOffsets); console.log(neighbours); 

I like this approach because it makes "adjacency" explicit. You could even define new adjacency functions to change your code's definition of "adjacency".

For example you could use cartesian distance instead of manhattan distance (all points within a circular range of the source tile):

let cartesianAdjacencyOffsets = dist => {
  let sqrDist = dist * dist;
  let ret = [];
  let min = Math.ceil(-dist);
  let max = Math.floor(dist);
  for (let x = min; x <= max; x++) { for (let y = min; y <= max; y++) {
    if (x === 0 && y === 0) continue; // Don't include the 0,0 point
    if (sqrDist < x * x + y * y) continue; // Don't include points too far away
    ret.push({ x, y });
  }}
  return ret;
};

Answer 3

There are two basic ways, both O(n).

1. The first one is so simple, efficient and ugly that i think it's a sin in CS to do such things.

 var neighborFunctions = [ (x,y) => [x+1,y] , (x,y) => [x+1,y+1] , (x,y) => [x,y+1] , (x,y) => [x-1,y+1] , (x,y) => [x-1,y] , (x,y) => [x-1,y-1] , (x,y) => [x,y-1] , (x,y) => [x+1,y-1] ], getNeigborCoords = (x,y) => Array.from({length:8}, (_,i) => neighborFunctions[i](x,y)), result = getNeigborCoords(24,7); console.log(JSON.stringify(result));

2. Now lets dive into another sin but a functional one, Math.sin() .

 var getNeigborCoords = (x,y) => Array.from( {length:8} , (_,i) => [ x+Math.round(Math.cos(Math.PI*i/4)) , y+Math.round(Math.sin(Math.PI*i/4)) ] ), result = getNeigborCoords(24,7); console.log(JSON.stringify(result));

Since the second one is a functional solution you may develop it further to calculate the second neighbors and whatnot.