Hoy vamos a ver cómo invertir un arreglo en JavaScript de dos maneras: con un método manual que usa ciclos e intercambio de variables, y con uno que invierte el arreglo con funciones nativas.

Voy a mostrar dos maneras de invertir el arreglo porque, aunque ya existe la función nativa, es importante analizar (sobre todo si eres estudiante) algunos algoritmos y ejercicios con arreglos de JavaScript.

Método 1: con método reverse

Los arreglos en JavaScript (sin importar el tipo) ya cuentan con un método llamado reverse, el cual invierte el arreglo directamente, sin regresar nada. Su forma de uso es:

elArreglo.reverse();

Al final dejaré un ejemplo.

Método 2: algoritmo manual para invertir un arreglo en JavaScript

Ahora veamos el enfoque en donde intercambiamos valores dentro del arreglo. Lo que hacemos es recorrer el arreglo desde 0 hasta su mitad, e ir intercambiando el primer elemento con el último, el segundo con el penúltimo y así sucesivamente.

const invertirManual = arreglo => {
  // Guardar de una vez la longitud para hacer más legible el código
  let longitudDelArreglo = arreglo.length;
  // Recorrer arreglo hasta la mitad. Si es impar, se va al entero anterior más 
  // próximo. P. ej. 5 / 2 => 2
  for (let x = 0; x < longitudDelArreglo / 2; x++) {
    // Respaldar el valor actual
    let temporal = arreglo[x];
    // Calcular el índice contrario, es decir, el del otro lado de la mitad; el cual irá descendiendo
    let indiceContrario = longitudDelArreglo - x - 1;
    // En el actual ahora está el del otro lado
    arreglo[x] = arreglo[indiceContrario];
    // Y en el otro lado, el que estaba originalmente en el actual
    arreglo[indiceContrario] = temporal;
  }

  // No regresamos nada porque ya modificamos al arreglo internamente
};

Utilizo una variable temporal para guardar el elemento que se intercambia. Al final, el arreglo estará invertido y no tengo que regresarlo, pues está modificado internamente.

Nota: no te confundas, en el código utilizo las funciones flecha.

Probar maneras de invertir arreglos con JS

Voy a poner todo el código junto y a probar que realmente funciona. El código queda así:

/**
 * Dos métodos para invertir arreglos en JavaScript:
 * algoritmo que intercambia valores dentro del arreglo y otro
 * que usa una función nativa de los arreglos en JavaScript
 * 
 * @author parzibyte
 * Visita: parzibyte.me/blog
 */
const invertirManual = arreglo => {
  // Guardar de una vez la longitud para hacer más legible el código
  let longitudDelArreglo = arreglo.length;
  // Recorrer arreglo hasta la mitad. Si es impar, se va al entero anterior más 
  // próximo. P. ej. 5 / 2 => 2
  for (let x = 0; x < longitudDelArreglo / 2; x++) {
    // Respaldar el valor actual
    let temporal = arreglo[x];
    // Calcular el índice contrario, es decir, el del otro lado de la mitad; el cual irá descendiendo
    let indiceContrario = longitudDelArreglo - x - 1;
    // En el actual ahora está el del otro lado
    arreglo[x] = arreglo[indiceContrario];
    // Y en el otro lado, el que estaba originalmente en el actual
    arreglo[indiceContrario] = temporal;
  }

  // No regresamos nada porque ya modificamos al arreglo internamente
};

const lenguajes = ["PHP", "C", "C#", "Rust", "Java", "JavaScript", "C++", "Go"];
// Imprimir arreglo original
console.log("Original: ", lenguajes);
// Invertir con método manual
invertirManual(lenguajes);
console.log("Invertido manualmente: ", lenguajes);

// Invertir con método existente
lenguajes.reverse();
console.log("Invertido con reverse: ", lenguajes);