Aquí está mi código JavaScript hasta ahora:

var linkElement = document.getElementById("BackButton");
var loc_array = document.location.href.split('/');
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2]))); 
linkElement.appendChild(newT);

Actualmente, toma el penúltimo elemento de la matriz desde la URL. Sin embargo, quiero hacer una comprobación del último elemento de la matriz "index.html"y, de ser así, tomar el tercer al último elemento.

if (loc_array[loc_array.length - 1] === 'index.html') {
   // do something
} else {
   // something else
}

En el caso de que el servidor sirve el mismo archivo para "index.html" y "index.html" también se puede utilizar: .toLowerCase().

Sin embargo, es posible que desee considerar hacer este lado del servidor si es posible: será más limpio y funcionará para personas sin JS.

No estoy seguro si hay un inconveniente, pero esto parece bastante conciso:

arr.slice(-1)[0] 

o

arr.slice(-1).pop()

Ambos volverán undefinedsi la matriz está vacía.

Utilice Array.pop :

var lastItem = anArray.pop();

Importante : Esto devuelve el último elemento y lo elimina de la matriz.

Una versión más corta de lo que publicó @chaiguy:

Array.prototype.last = function() {
    return this[this.length - 1];
}

Leer el índice -1 undefinedya regresa .

EDITAR:

En estos días, la preferencia parece ser el uso de módulos y evitar tocar el prototipo o usar un espacio de nombres global.

export function last(array) {
    return array[array.length - 1];
}

Dos opciones son:

var last = arr[arr.length - 1]

o

var last = arr.slice(-1)[0]

El primero es más rápido, pero el segundo se ve mejor

http://jsperf.com/slice-vs-length-1-arr

Aquí le mostramos cómo obtenerlo sin efecto en el ARRAY original

a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements

Si usa pop (), modificará su matriz

a.pop();  // will return "abc" AND REMOVES IT from the array 
a.length; // returns 7

Pero puede usar esto para que no tenga efecto en la matriz original:

a.slice(-1).pop(); // will return "abc" won't do modify the array 
                   // because slice creates a new array object 
a.length;          // returns 8; no modification and you've got you last element 

La forma más limpia de ES6 (IMO) sería:

const foo = [1,2,3,4];
const bar = [...foo].pop();

Esto evita la mutación foo, como lo .pop()habría hecho, si no utilizáramos el operador de propagación.
Dicho esto, también me gusta la foo.slice(-1)[0]solución.

Prefiero usar array.pop()que los índices.

while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));

de esta manera siempre obtienes el elemento anterior a index.html (siempre que tu matriz tenga index.html aislado como un elemento). Nota: Sin embargo, perderá los últimos elementos de la matriz.

Creo que si solo quieres obtener el elemento sin eliminar, es más simple usar esto:

arr.slice(-1)[0]

Nota: Si la matriz está vacía (por ejemplo []), esto regresará undefined.

por cierto ... no verifiqué el rendimiento, pero creo que es más simple y limpio de escribir

const [lastItem] = array.slice(-1);

Array.prototype.slice con -1 se puede usar para crear una nueva matriz que contenga solo el último elemento de la matriz original, luego puede usar la asignación de desestructuración para crear una variable usando el primer elemento de esa nueva matriz.

const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);

console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22

Se puede obtener el último elemento de una matriz utilizando el método de división con valores negativos.

Puedes leer más sobre esto aquí en la parte inferior.

var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
  //your code...
}

El uso de pop () cambiará su matriz, lo que no siempre es una buena idea.

Puedes usar este patrón ...

let [last] = arr.slice(-1);

Si bien se lee bastante bien, tenga en cuenta que crea una nueva matriz, por lo que es menos eficiente que otras soluciones, pero casi nunca será el cuello de botella de rendimiento de su aplicación.

Esta pregunta ha existido desde hace mucho tiempo, por lo que me sorprende que nadie haya mencionado volver a poner el último elemento después de un pop().

arr.pop()es exactamente tan eficiente como arr[arr.length-1], y ambos tienen la misma velocidad que arr.push().

Por lo tanto, puede salirse con la suya:

--- EDITADO [comprobar que thePopno es undefinedantes de presionar] ---

let thePop = arr.pop()
thePop && arr.push(thePop)

--- EDICIÓN FINAL ---

Que se puede reducir a esto (misma velocidad [EDITAR: ¡pero inseguro!]):

arr.push(thePop = arr.pop())    //Unsafe if arr empty

Esto es dos veces más lento que arr[arr.length-1], pero no tiene que andar con un índice. Eso vale oro en cualquier día.

De las soluciones que he probado, y en múltiplos de la Unidad de Tiempo de Ejecución (ETU) de arr[arr.length-1]:

[Método] .............. [ETUs 5 elems] ... [ETU 1 millón de elems]

arr[arr.length - 1]      ------> 1              -----> 1

let myPop = arr.pop()
arr.push(myPop)          ------> 2              -----> 2

arr.slice(-1).pop()      ------> 36             -----> 924  

arr.slice(-1)[0]         ------> 36             -----> 924  

[...arr].pop()           ------> 120            -----> ~21,000,000 :)

Las últimas tres opciones, ESPECIALMENTE [...arr].pop(), empeoran MUCHO a medida que aumenta el tamaño de la matriz. En una máquina sin las limitaciones de memoria de mi máquina, [...arr].pop()probablemente mantiene algo así como su relación 120: 1. Aún así, a nadie le gusta un recurso cerdo.

Si uno quiere obtener el último elemento de una vez, puede usar Array#splice():

lastElement = document.location.href.split('/').splice(-1,1);

Aquí, no hay necesidad de almacenar los elementos divididos en una matriz, y luego llegar al último elemento. Si obtener el último elemento es el único objetivo, se debe usar.

Nota: Esto cambia la matriz original al eliminar su último elemento. Piense splice(-1,1)como una pop()función que muestra el último elemento.

Para aquellos que no temen sobrecargar el prototipo de Array (y con el enmascaramiento de enumeración no deberían estarlo):

Object.defineProperty( Array.prototype, "getLast", {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        return this[ this.length - 1 ];
    }
} );

jQuery resuelve esto perfectamente:

> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined

Generalmente uso subrayado , con él puedes hacer

if (_.last(loc_array) === 'index.html'){
  etc...
}

Para mí eso es más semántico que loc_array.slice(-1)[0]

Aquí hay más arte Javascript si viniste a buscarlo

En el espíritu de otra respuesta que usó reduceRight(), pero más corta:

[3, 2, 1, 5].reduceRight(a => a);

Se basa en el hecho de que, en caso de que no proporcione un valor inicial, el último elemento se selecciona como el inicial (consulte los documentos aquí ). Como la devolución de llamada sigue devolviendo el valor inicial, el último elemento será el que se devuelve al final.

Tenga en cuenta que esto debería considerarse arte Javascript y de ninguna manera recomendaría hacerlo, principalmente porque se ejecuta en tiempo O (n), pero también porque perjudica la legibilidad.

Y ahora por la respuesta seria

La mejor manera que veo (considerando que lo quieres más conciso que array[array.length - 1]) es esto:

const last = a => a[a.length - 1];

Entonces solo use la función:

last([3, 2, 1, 5])

La función es realmente útil en caso de que se trate de una matriz anónima como la [3, 2, 1, 5]utilizada anteriormente, de lo contrario, tendría que instanciarla dos veces, lo que sería ineficiente y feo:

[3, 2, 1, 5][[3, 2, 1, 5].length - 1]

Ugh

Por ejemplo, aquí hay una situación en la que tiene una matriz anónima y tendría que definir una variable, pero puede usar last()en su lugar:

last("1.2.3".split("."));

Solo pongo otra opción aquí.

loc_array.splice(-1)[0] === 'index.html'

Encontré el enfoque anterior más limpio y corto en línea. Por favor, siéntase libre de probar este.

Nota: modificará la matriz original; si no desea modificarla, puede usar slice()

loc_array.slice(-1)[0] === 'index.html'

Gracias @VinayPai por señalar esto.

Múltiples formas de encontrar el último valor de una matriz en javascript

• Sin afectar la matriz original

var arr = [1,2,3,4,5];

console.log(arr.slice(-1)[0])
console.log(arr[arr.length-1])
const [last] = [...arr].reverse();
console.log(last)
console.log(arr.reverse()[0])

• Modifica la matriz original.

var arr = [1,2,3,4,5];

console.log(arr.pop())
arr.push(5)
console.log(...arr.splice(-1));

• Mediante la creación de un método auxiliar propio

let arr = [1, 2, 3, 4, 5];

Object.defineProperty(arr, 'last', 
{ get: function(){
  return this[this.length-1];
 }
})

console.log(arr.last);

const lastElement = myArray[myArray.length - 1];

Estas son las mejores opciones desde el punto de vista del rendimiento (~ 1000 veces más rápido que arr.slice (-1)).

Personalmente, votaría por kuporific / kritzikratzi. El método de matriz [array.length-1] se vuelve muy feo si está trabajando con matrices anidadas.

var array = [[1,2,3], [4,5,6], [7,8,9]]
​
array.slice(-1)[0]
​
//instead of 
​
array[array.length-1]
​
//Much easier to read with nested arrays
​
array.slice(-1)[0].slice(-1)[0]
​
//instead of
​
array[array.length-1][array[array.length-1].length-1]

En la Etapa 1 de la propuesta ECMAScript hay una sugerencia para agregar una propiedad de matriz que devolverá el último elemento: offer-array-last .

Sintaxis:

arr.lastItem // get last item
arr.lastItem = 'value' // set last item

arr.lastIndex // get last index

Puedes usar polyfill .

Autor de la propuesta: Keith Cirkel ( autor chai )

Para evitar eliminar el último elemento de la matriz de origen, puede usar

Array.from(myArray).pop()

Principalmente compatible con todos los navegadores (ES6)

Puede agregar una last()función al Arrayprototipo.

Array.prototype.last = function () {
    return this[this.length - 1];
};

Hagas lo que hagas, ¡no lo uses reverse()!

Algunas respuestas mencionan reversepero no mencionan el hecho de que reversemodifica la matriz original y no devuelve (como en otros lenguajes o marcos) una copia.

var animals = ['dog', 'cat'];

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

¡Este puede ser el peor tipo de código para depurar!

La desestructuración de objetos ES6 es otro camino a seguir.

const {length, [length-1]: last}=[1,2,3,4,5]
console.log(last)

Extrae la propiedad de longitud de la matriz mediante la desestructuración de objetos. Puede crear otra clave dinámica utilizando la clave ya extraída por [longitud-1] y asignarla al último , todo en una línea.

Puede agregar un nuevo captador de propiedades al prototipo deArray modo que sea accesible a través de todas las instancias de Array.

Los captadores le permiten acceder al valor de retorno de una función como si fuera el valor de una propiedad. El valor de retorno de la función, por supuesto, es el último valor de la matriz ( this[this.length - 1]).

Finalmente lo envuelve en una condición que verifica si la lastpropiedad todavía está undefined(no definida por otro script que pueda depender de ella).

if(typeof Array.prototype.last === 'undefined') {
    Object.defineProperty(Array.prototype, 'last', {
        get : function() {
            return this[this.length - 1];
        }
    });
}

// Now you can access it like
[1, 2, 3].last;            // => 3
// or
var test = [50, 1000];
alert(test.last);          // Says '1000'

No funciona en IE ≤ 8.

EDITADO:

Recientemente se me ocurrió una solución más que ahora creo que es la mejor para mis necesidades:

function w(anArray) {
  return {
    last() {
      return anArray [anArray.length - 1];
    };
  };
}

Con la definición anterior en efecto, ahora puedo decir:

let last = w ([1,2,3]).last();
console.log(last) ; // -> 3

El nombre "w" significa "envoltorio". Puede ver cómo podría agregar fácilmente más métodos además de 'last ()' a este contenedor.

Digo "lo mejor para mis necesidades", porque esto me permite agregar fácilmente otros "métodos auxiliares" a cualquier tipo de JavaScript incorporado. Lo que viene a la mente son el auto () y el cdr () de Lisp, por ejemplo.

Creo que la forma más fácil y súper ineficiente es:

var array = ['fenerbahce','arsenal','milan'];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".