Ecco il mio codice JavaScript finora:

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);

Attualmente richiede il penultimo elemento dell'array dall'URL. Tuttavia, voglio fare un controllo per l'ultimo elemento dell'array "index.html"e, in tal caso, afferrare invece il terzo all'ultimo elemento.

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

Nel caso in cui il server serve la stessa lima per "index.html" e "index.html" è anche possibile utilizzare: .toLowerCase().

Tuttavia, potresti prendere in considerazione l'idea di fare questo lato server, se possibile: sarà più pulito e funzionerà per le persone senza JS.

Non sono sicuro che ci sia un inconveniente, ma questo sembra abbastanza conciso:

arr.slice(-1)[0] 

o

arr.slice(-1).pop()

Entrambi restituiranno undefinedse l'array è vuoto.

Usa Array.pop :

var lastItem = anArray.pop();

Importante : questo restituisce l'ultimo elemento e lo rimuove dall'array

Una versione più breve di ciò che ha pubblicato @chaiguy:

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

La lettura dell'indice -1 ritorna undefinedgià.

MODIFICARE:

In questi giorni la preferenza sembra usare i moduli ed evitare di toccare il prototipo o utilizzare uno spazio dei nomi globale.

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

Due opzioni sono:

var last = arr[arr.length - 1]

o

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

Il primo è più veloce, ma il secondo sembra più bello

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

Ecco come ottenerlo senza alcun effetto sull'ARRAY originale

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

Se usi pop (), modificherà l'array

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

Ma puoi usarlo in modo che non abbia alcun effetto sull'array originale:

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 

Il modo più pulito di ES6 (IMO) sarebbe:

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

Questo evita la mutazione foo, come .pop()avremmo fatto, se non avessimo utilizzato l'operatore di diffusione.
Detto questo, mi piace anche la foo.slice(-1)[0]soluzione.

Preferirei usare gli array.pop()indici.

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

in questo modo ottieni sempre l'elemento precedente a index.html (a condizione che l'array abbia isolato index.html come un unico elemento). Nota: tuttavia , perderai gli ultimi elementi dell'array.

Penso che se vuoi solo ottenere l'elemento senza rimuoverlo, è più semplice usare questo:

arr.slice(-1)[0]

Nota: se l'array è vuoto (ad es. []) Questo ritornerà undefined.

a proposito ... non ho controllato le prestazioni, ma penso che sia più semplice e pulito da scrivere

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

Array.prototype.slice con -1 può essere utilizzato per creare un nuovo array contenente solo l'ultimo elemento dell'array originale, quindi è possibile utilizzare Destructuring Assignment per creare una variabile utilizzando il primo elemento di quel nuovo array.

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

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

È possibile ottenere l'ultimo elemento di un array utilizzando il metodo slice con valori negativi.

Puoi leggere di più a riguardo qui in fondo.

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

L'uso di pop () cambierà l'array, il che non è sempre una buona idea.

Puoi usare questo modello ...

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

Mentre legge piuttosto bene, tieni presente che crea un nuovo array, quindi è meno efficiente di altre soluzioni, ma non sarà quasi mai il collo di bottiglia delle prestazioni della tua applicazione.

Questa domanda è in sospeso da molto tempo, quindi sono sorpreso che nessuno abbia menzionato il fatto di rimettere l'ultimo elemento dopo un pop().

arr.pop()è esattamente efficiente arr[arr.length-1]ed entrambi hanno la stessa velocità di arr.push().

Pertanto, puoi cavartela con:

--- MODIFICATO [verifica che thePopnon sia undefinedprima di premere] ---

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

--- MODIFICA FINE ---

Che può essere ridotto a questo (stessa velocità [EDIT: ma non sicuro!]):

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

Questo è due volte più lento di arr[arr.length-1], ma non è necessario spostarsi con un indice. Vale la pena l'oro in qualsiasi giorno.

Delle soluzioni che ho provato, e in multipli di Execution Time Unit (ETU) di arr[arr.length-1]:

[Metodo] .............. [ETUs 5 elems] ... [ETU 1 milione 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 :)

Le ultime tre opzioni, IN PARTICOLARE [...arr].pop(), peggiorano MOLTO molto di più all'aumentare della dimensione dell'array. Su una macchina senza i limiti di memoria della mia macchina, [...arr].pop()probabilmente mantiene qualcosa come il suo rapporto 120: 1. Tuttavia, a nessuno piace un porco di risorse.

Se uno vuole ottenere l'ultimo elemento in una volta sola, può usare Array#splice():

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

Qui, non è necessario archiviare gli elementi divisi in un array, quindi arrivare all'ultimo elemento. Se ottenere l'ultimo elemento è l'unico obiettivo, questo dovrebbe essere usato.

Nota: questo modifica l'array originale rimuovendo il suo ultimo elemento. Pensa splice(-1,1)a una pop()funzione che apre l'ultimo elemento.

Per coloro che non hanno paura di sovraccaricare il prototipo di array (e con il mascheramento di enumerazione non dovresti essere):

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

jQuery risolve questo in modo chiaro:

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

In genere uso underscorejs , con cui puoi semplicemente farlo

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

Per me è più semantico di loc_array.slice(-1)[0]

Ecco più arte Javascript se sei venuto qui a cercarla

Nello spirito di un'altra risposta che ha usato reduceRight(), ma più breve:

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

Si basa sul fatto che, nel caso in cui non si fornisca un valore iniziale, l'ultimo elemento viene selezionato come quello iniziale (controllare i documenti qui ). Poiché il callback continua a restituire il valore iniziale, l'ultimo elemento sarà quello restituito alla fine.

Attenzione che questo dovrebbe essere considerato arte Javascript e non è affatto il modo in cui lo consiglierei, soprattutto perché funziona in tempo O (n), ma anche perché danneggia la leggibilità.

E ora per la risposta seria

Il modo migliore che vedo (considerando che lo vuoi più conciso di array[array.length - 1]) è questo:

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

Quindi basta usare la funzione:

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

La funzione è effettivamente utile nel caso in cui tu abbia a che fare con un array anonimo come [3, 2, 1, 5]usato sopra, altrimenti dovresti istanziarlo due volte, il che sarebbe inefficiente e brutto:

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

Ugh.

Ad esempio, ecco una situazione in cui hai un array anonimo e dovresti definire una variabile, ma puoi usare last()invece:

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

Metto solo un'altra opzione qui.

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

Ho trovato l'approccio sopra più pulito e breve onliner. Per favore, sentiti libero di provare questo.

Nota: modificherà l'array originale, se non si desidera modificarlo, è possibile utilizzarlo slice()

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

Grazie @VinayPai per averlo segnalato.

Diversi modi per trovare l'ultimo valore di un array in javascript

• Senza influire sull'array originale

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 l'array originale

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

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

• Creando il proprio metodo di supporto

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];

Questa è la migliore opzione dal punto di vista delle prestazioni (~ 1000 volte più veloce di arr.slice (-1)).

Personalmente vorrei dare una risposta a kuporific / kritzikratzi. Il metodo array [array.length-1] diventa molto brutto se si lavora con array nidificati.

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]

Nella fase 1 della proposta ECMAScript c'è un suggerimento per aggiungere una proprietà array che restituirà l'ultimo elemento: proposta-array-last .

Sintassi:

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

arr.lastIndex // get last index

È possibile utilizzare polyfill .

Autore della proposta: Keith Cirkel ( chai autor)

Per impedire la rimozione dell'ultimo elemento dall'array di origine che è possibile utilizzare

Array.from(myArray).pop()

Principalmente supportato da tutti i browser (ES6)

È possibile aggiungere una last()funzione al Arrayprototipo.

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

Qualunque cosa tu faccia, non usare soloreverse() !!!

Alcune risposte menzionano reversema non menzionano il fatto che reversemodifica l'array originale e che non restituisce una copia (come in altri linguaggi o framework).

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

Questo può essere il peggior tipo di codice per il debug!

La distruzione degli oggetti ES6 è un'altra strada da percorrere.

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

È possibile estrarre la proprietà della lunghezza dall'array utilizzando la distruzione degli oggetti. Si crea un'altra chiave dinamica utilizzando la chiave già estratta di [lunghezza-1] e la si assegna per durare , tutto in una riga.

È possibile aggiungere un nuovo getter di proprietà al prototipo di inArray modo che sia accessibile attraverso tutte le istanze di Array.

I Getter ti consentono di accedere al valore di ritorno di una funzione proprio come se fosse il valore di una proprietà. Il valore di ritorno della funzione ovviamente è l'ultimo valore dell'array ( this[this.length - 1]).

Infine lo avvolgi in una condizione che controlla se la lastproprietà è ancora undefined(non definita da un altro script che potrebbe fare affidamento su di essa).

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'

Non funziona in IE ≤ 8.

MODIFICATO:

Di recente ho trovato un'altra soluzione che ora ritengo sia la migliore per le mie esigenze:

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

Con la definizione sopra in vigore ora posso dire:

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

Il nome "w" sta per "wrapper". Puoi vedere come aggiungere facilmente altri metodi oltre a "last ()" in questo wrapper.

Dico "il meglio per le mie esigenze", perché ciò mi consente di aggiungere facilmente altri "metodi di supporto" a qualsiasi tipo di JavaScript incorporato. Ciò che viene in mente sono ad esempio car () e cdr () di Lisp.

Penso che il modo più semplice e super inefficiente sia:

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