Y y X: ¿lo estoy haciendo mal?

A veces me encuentro con pequeños problemas al hacer mis proyectos de JavaScript. Esto se debe a que la mayoría de las funciones integradas de JavaScript ejecutan X, Y si se necesitan posiciones. (En ese orden).

Pero cuando construyo una matriz 2D empiezo con Y, me parece más lógico ejecutar el eje X horizontal. Si soy malo para explicarlo, déjame mostrarte:

Entonces mis bucles se ven así:

for(var y = 0; y < 10; y++){
    for(var x = 0; x < 10; x++){
        console.log("Doh!");
    }
}

¿Es esto tan loco? Me gustaría convertirme a la práctica normal para que sea más fácil mientras construyo mi juego y no tenga que hacer intercambios constantes.

Entonces, ¿por qué es X antes de Y?

Editar: Aquí hay otro ejemplo, y probablemente la razón principal de mi confusión: X es horizontal e Y es vertical en mis libros.

[
[0,1,2,3,4],
[0,1,2,3,4],
[0,1,2,3,4],
[0,1,2,3,4],
]

No, si te está funcionando, no lo estás haciendo mal. Si desea cambiar, entonces hágalo. El orden en que procesa las filas / columnas es a veces arbitrario, a veces no. El orden que use depende completamente del algoritmo que esté usando.

Hay múltiples combinaciones diferentes para procesar X, Y. Depende de usted elegir cuál es el correcto para su algoritmo. En el caso en que cada iteración sea independiente de cualquier otra, puede elegir la que desee. Puede cambiar cuál está en el bucle interno y también puede cambiar si los bucles van de min a max o max a min.

Me imagino que el valor predeterminado es:

for xmin to xmax
    for ymin to ymax

porque así es como se ordenan los datos en la memoria. (No necesariamente es cierto para todos los idiomas, ya que el orden del índice puede cambiar).

Por ejemplo, una matriz A[3][3]( A[X][Y]):

Cuando el yvalor está en el bucle interno, primero se incrementa y luego se "rueda" para incrementar el xvalor. Aparte de eso, (X, Y) es la forma estándar de escribirlo en matemáticas.

Lo estás haciendo mal ... más o menos. Lo incorrecto que está haciendo es correlacionar el orden en que se escriben las coordenadas con el orden en que se anidan los bucles. ¡Esas son ideas totalmente diferentes!

Más específicamente, lo incorrecto es que su sistema de coordenadas está vinculado de una manera fuerte (y frágil) a la implementación de su almacenamiento de datos. Eso significa que está diseñando un código incorrecto desde el punto de vista de OO. El almacenamiento de datos debe ser opaco a lo que lo usa, y lo que lo usa no debe importar cómo se almacenan los datos. El usuario de los datos solo necesita saber cómo obtener la información que desea.

Lo que debe hacer es encontrar una manera de abstraer su estructura de datos de matriz anidada y ocultarla en un método como getPoint(x,y). Entonces no tiene que preocuparse por qué matriz está anidada en qué orden. Puede dejar su estructura de datos hacia atrás exactamente como está, siempre que su método getter primero encuentre la matriz y, y luego busque dentro de ella el elemento x. Pero cualquier código que llame getPoint()no lo sabe. Solo necesita saber las dos coordenadas que le interesan.

¡No importa! También siempre escribo Y primero (parece más natural). Cuando tiene su matriz en matriz como filas, incluso puede hacer algo de optimización. En lugar de esto:

for(var y=0; y<h; y++){
    for(var x=0; x<w; x++){
        m[y*w+x] = a;
    }
}

puedes usar esto:

for(var y=0; y<h; y++){
    var i = y*w;
    for(var x=0; x<w; x++, i++){
        m[i] = a;
    }
}

¡y evita muchas multiplicaciones! :)