Las matrices permiten representar estructuras con filas y columnas: tableros, imágenes, mapas, datos y transformaciones geométricas.
Las matrices son útiles porque muchos problemas de programación tienen forma de tabla, grilla o colección de valores relacionados por posición.
Entender esta estructura permite organizar información y recorrerla con algoritmos claros.
Un tablero se puede modelar como una matriz donde cada celda tiene un valor.
const tablero = [
["X", "", "O"],
["", "X", ""],
["O", "", "X"]
];
console.log(tablero[0][0]);
console.log(tablero[1][1]);
console.log(tablero[2][2]);La primera posición indica la fila y la segunda indica la columna.
Recorrer una matriz permite encontrar posiciones que cumplen una condición.
function buscarValor(tablero, valor) {
for (let fila = 0; fila < tablero.length; fila++) {
for (let columna = 0; columna < tablero[fila].length; columna++) {
if (tablero[fila][columna] === valor) {
return { fila, columna };
}
}
}
return null;
}
const tablero = [
["", "", ""],
["", "X", ""],
["", "", "O"]
];
console.log(buscarValor(tablero, "X"));Este patrón sirve para juegos, editores de mapas y grillas interactivas.
En videojuegos, una matriz puede representar paredes, caminos, monedas o enemigos.
const mapa = [
[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 0, 2, 1],
[1, 1, 1, 1]
];
console.log(mapa[1][1]); // camino
console.log(mapa[2][2]); // objeto especialLos números funcionan como códigos para interpretar cada celda.
Un recorrido completo permite contar cuántas celdas tienen cierto significado.
function contarCeldas(mapa, codigo) {
let cantidad = 0;
for (let fila = 0; fila < mapa.length; fila++) {
for (let columna = 0; columna < mapa[fila].length; columna++) {
if (mapa[fila][columna] === codigo) {
cantidad++;
}
}
}
return cantidad;
}
const mapa = [
[1, 1, 1],
[1, 0, 2],
[1, 0, 0]
];
console.log(contarCeldas(mapa, 0));Este cálculo puede indicar cuántos espacios libres, obstáculos u objetivos hay.
Una imagen digital puede pensarse como una matriz de píxeles. Cada píxel guarda información de color o intensidad.
Los valores cercanos a 0 representan tonos oscuros y los cercanos a 255 representan tonos claros.
Modificar una imagen puede modelarse como aplicar una operación a cada elemento de la matriz.
function aumentarBrillo(imagen, incremento) {
const resultado = [];
for (let fila = 0; fila < imagen.length; fila++) {
resultado[fila] = [];
for (let columna = 0; columna < imagen[fila].length; columna++) {
const nuevoValor = imagen[fila][columna] + incremento;
resultado[fila][columna] = Math.min(nuevoValor, 255);
}
}
return resultado;
}
const imagen = [[20, 80], [180, 240]];
console.log(aumentarBrillo(imagen, 40));La función limita el valor máximo a 255 para mantener un rango válido.
Una matriz puede representar filas de datos numéricos, como ventas por sucursal y por mes.
const ventas = [
[1200, 1500, 1800],
[900, 1100, 1300],
[2000, 2100, 2300]
];
console.log(ventas[0][2]);
console.log(ventas[2][1]);Cada fila puede ser una sucursal y cada columna puede ser un mes.
Sumar cada fila permite obtener totales por registro.
function sumarFilas(matriz) {
const totales = [];
for (let fila = 0; fila < matriz.length; fila++) {
let suma = 0;
for (let columna = 0; columna < matriz[fila].length; columna++) {
suma += matriz[fila][columna];
}
totales.push(suma);
}
return totales;
}
const ventas = [
[1200, 1500, 1800],
[900, 1100, 1300]
];
console.log(sumarFilas(ventas));Este patrón aparece en reportes, balances y paneles de control.
Sumar columnas permite comparar categorías, meses o variables.
function sumarColumnas(matriz) {
const columnas = matriz[0].length;
const totales = Array(columnas).fill(0);
for (let fila = 0; fila < matriz.length; fila++) {
for (let columna = 0; columna < columnas; columna++) {
totales[columna] += matriz[fila][columna];
}
}
return totales;
}
const ventas = [
[1200, 1500, 1800],
[900, 1100, 1300],
[2000, 2100, 2300]
];
console.log(sumarColumnas(ventas));La matriz permite analizar la información por diferentes direcciones.
En gráficos, las matrices pueden representar transformaciones como escalado, rotación o traslación.
Aunque las bibliotecas gráficas suelen ocultar los detalles, internamente usan operaciones matriciales.
Una lista de puntos puede transformarse aplicando factores de escala a cada coordenada.
function escalarPuntos(puntos, escalaX, escalaY) {
const resultado = [];
for (let i = 0; i < puntos.length; i++) {
resultado.push({
x: puntos[i].x * escalaX,
y: puntos[i].y * escalaY
});
}
return resultado;
}
const puntos = [
{ x: 2, y: 3 },
{ x: 5, y: 1 }
];
console.log(escalarPuntos(puntos, 2, 3));Esta idea se conecta con transformaciones más generales mediante matrices.
En inteligencia artificial, los datos y pesos de un modelo suelen organizarse como matrices.
Esta representación permite procesar muchos valores con operaciones repetitivas y eficientes.
Al trabajar con matrices en código, conviene mantener dimensiones claras y validar que todas las filas tengan la misma longitud.
function esMatrizRegular(matriz) {
if (matriz.length === 0) {
return true;
}
const columnas = matriz[0].length;
for (let fila = 0; fila < matriz.length; fila++) {
if (matriz[fila].length !== columnas) {
return false;
}
}
return true;
}
console.log(esMatrizRegular([[1, 2], [3, 4]]));
console.log(esMatrizRegular([[1, 2], [3]]));Una matriz irregular puede romper algoritmos que esperan una estructura rectangular.
Las matrices son una herramienta práctica para modelar información con dos dimensiones. Su utilidad aparece en juegos, imágenes, mapas, datos, gráficos e inteligencia artificial.
En el próximo tema se estudiará la interpretación de fórmulas utilizadas en software.