Hier ist mein bisheriger JavaScript-Code:

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

Derzeit wird das vorletzte Element im Array von der URL übernommen. Ich möchte jedoch überprüfen, ob das letzte Element im Array vorhanden ist, "index.html"und in diesem Fall stattdessen das drittletzte Element abrufen.

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

Für den Fall, dass Ihr Server dieselbe Datei für "index.html" und "inDEX.htML" bereitstellt, können Sie auch Folgendes verwenden : .toLowerCase().

Möglicherweise möchten Sie dies jedoch nach Möglichkeit auf der Serverseite tun: Es ist sauberer und funktioniert für Personen ohne JS.

Ich bin mir nicht sicher, ob es einen Nachteil gibt, aber das scheint ziemlich kurz zu sein:

arr.slice(-1)[0] 

oder

arr.slice(-1).pop()

Beide werden zurückgegeben, undefinedwenn das Array leer ist.

Verwenden Sie Array.pop :

var lastItem = anArray.pop();

Wichtig : Dies gibt das letzte Element zurück und entfernt es aus dem Array

Eine kürzere Version von dem, was @chaiguy gepostet hat:

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

Das Lesen des -1-Index kehrt undefinedbereits zurück.

BEARBEITEN:

Heutzutage scheint die Präferenz darin zu bestehen, Module zu verwenden und zu vermeiden, den Prototyp zu berühren oder einen globalen Namespace zu verwenden.

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

Zwei Optionen sind:

var last = arr[arr.length - 1]

oder

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

Ersteres ist schneller, letzteres sieht aber besser aus

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

Hier erfahren Sie, wie Sie es ohne Auswirkung auf das Original ARRAY erhalten

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

Wenn Sie pop () verwenden, wird Ihr Array geändert

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

Sie können dies jedoch verwenden, damit es keine Auswirkungen auf das ursprüngliche Array hat:

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 

Der "sauberste" ES6-Weg (IMO) wäre:

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

Dies vermeidet eine Mutation foo, wie dies der Fall .pop()wäre, wenn wir den Spread-Operator nicht verwendet hätten.
Das heißt, ich mag auch die foo.slice(-1)[0]Lösung.

Ich würde lieber array.pop()als Indizes verwenden.

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

Auf diese Weise erhalten Sie immer das Element vor index.html (vorausgesetzt, Ihr Array hat index.html als ein Element isoliert). Hinweis: Sie verlieren jedoch die letzten Elemente aus dem Array.

Ich denke, wenn Sie nur das Element ohne entfernen erhalten möchten, ist dies einfacher:

arr.slice(-1)[0]

Hinweis: Wenn das Array leer ist (z. B. []), wird dies zurückgegeben undefined.

Übrigens ... ich habe die Leistung nicht überprüft, aber ich denke, es ist einfacher und sauberer zu schreiben

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

Array.prototype.slice mit -1 kann verwendet werden, um ein neues Array zu erstellen, das nur das letzte Element des ursprünglichen Arrays enthält. Anschließend können Sie mithilfe der Destructuring Assignment eine Variable mit dem ersten Element dieses neuen Arrays erstellen.

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

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

Das Abrufen des letzten Elements eines Arrays kann mithilfe der Slice- Methode mit negativen Werten erreicht werden.

Mehr dazu lesen Sie hier unten.

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

Die Verwendung von pop () ändert Ihr Array, was nicht immer eine gute Idee ist.

Sie können dieses Muster verwenden ...

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

Denken Sie daran, dass es ein neues Array erstellt, sodass es weniger effizient ist als andere Lösungen, aber es wird fast nie der Leistungsengpass Ihrer Anwendung sein.

Diese Frage gibt es schon lange, daher bin ich überrascht, dass niemand erwähnt hat, dass nur das letzte Element nach a wieder aufgesetzt wird pop().

arr.pop()ist genau so effizient wie arr[arr.length-1]und beide haben die gleiche Geschwindigkeit wie arr.push().

Daher können Sie davonkommen mit:

--- BEARBEITET [überprüfen Sie, dass thePopnicht undefinedvor dem Drücken] ---

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

--- END EDIT ---

Was auf diese reduziert werden kann (gleiche Geschwindigkeit [EDIT: aber unsicher!]):

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

Das ist doppelt so langsam wie arr[arr.length-1] , aber Sie müssen nicht mit einem Index herumspielen. Das ist an jedem Tag Gold wert.

Von den Lösungen, die ich ausprobiert habe, und in Vielfachen der Execution Time Unit (ETU) von arr[arr.length-1] :

[Methode] .............. [ETUs 5 Elemente] ... [ETU 1 Million Elemente]

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

Die letzten drei Optionen werden INSBESONDERE [...arr].pop()mit zunehmender Größe des Arrays SEHR viel schlechter. Auf einem Computer ohne die Speicherbeschränkungen meines Computers wird [...arr].pop()wahrscheinlich das Verhältnis 120: 1 beibehalten. Trotzdem mag niemand ein Ressourcenschwein.

Wenn jemand das letzte Element auf einmal erhalten möchte, kann er / sie Folgendes verwenden Array#splice():

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

Hier besteht keine Notwendigkeit, die geteilten Elemente in einem Array zu speichern und dann zum letzten Element zu gelangen. Wenn das einzige Ziel darin besteht, das letzte Element zu erhalten, sollte dies verwendet werden.

Hinweis: Dadurch wird das ursprüngliche Array geändert, indem das letzte Element entfernt wird. Stellen Sie sich splice(-1,1)eine pop()Funktion vor, die das letzte Element öffnet.

Für diejenigen, die keine Angst haben, den Array-Prototyp zu überladen (und mit Aufzählungsmaskierung sollten Sie es nicht sein):

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

jQuery löst dies ordentlich:

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

Ich benutze normalerweise Unterstriche , damit kannst du es einfach machen

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

Für mich ist das semantischer als loc_array.slice(-1)[0]

Hier ist mehr Javascript-Kunst, wenn Sie hierher gekommen sind, um danach zu suchen

Im Geiste einer anderen Antwort, die verwendet wurde reduceRight(), aber kürzer:

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

Dies hängt davon ab, dass für den Fall, dass Sie keinen Anfangswert angeben, das allerletzte Element als Anfangswert ausgewählt wird (siehe Dokumente hier ). Da der Rückruf immer wieder den Anfangswert zurückgibt, wird am Ende das letzte Element zurückgegeben.

Beachten Sie, dass dies als Javascript-Kunst betrachtet werden sollte und keineswegs die Art und Weise ist, wie ich es empfehlen würde, hauptsächlich, weil es in O (n) -Zeit ausgeführt wird, aber auch, weil es die Lesbarkeit beeinträchtigt.

Und jetzt zur ernsthaften Antwort

Der beste Weg, den ich sehe (wenn man bedenkt, dass Sie es prägnanter wollen als array[array.length - 1]), ist folgender:

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

Dann nutzen Sie einfach die Funktion:

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

Die Funktion ist tatsächlich nützlich, wenn Sie mit einem anonymen Array wie dem [3, 2, 1, 5]oben verwendeten arbeiten, andernfalls müssten Sie es zweimal instanziieren, was ineffizient und hässlich wäre:

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

Pfui.

In diesem Fall haben Sie beispielsweise ein anonymes Array und müssten eine Variable definieren. Sie können jedoch Folgendes verwenden last():

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

Setzen Sie hier einfach eine andere Option.

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

Ich fand den obigen Ansatz sauberer und kurzer Onliner. Bitte zögern Sie nicht, dieses zu versuchen.

Hinweis: Das ursprüngliche Array wird geändert. Wenn Sie es nicht ändern möchten, können Sie es verwenden slice()

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

Vielen Dank an @VinayPai für den Hinweis.

Mehrere Möglichkeiten, den letzten Wert eines Arrays in Javascript zu finden

• Ohne das ursprüngliche Array zu beeinflussen

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

• Ändert das ursprüngliche Array

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

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

• Durch Erstellen einer eigenen Hilfsmethode

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

Dies ist aus Sicht der Leistung die beste Option (~ 1000-mal schneller als arr.slice (-1)).

Persönlich würde ich die Antwort von kuporific / kritzikratzi positiv bewerten. Die Methode array [array.length-1] wird sehr hässlich, wenn Sie mit verschachtelten Arrays arbeiten.

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]

In ECMAScript-Vorschlag Stufe 1 gibt es einen Vorschlag zum Hinzufügen einer Array-Eigenschaft, die das letzte Element zurückgibt: Vorschlag-Array-Letzte .

Syntax:

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

arr.lastIndex // get last index

Sie können Polyfill verwenden .

Verfasser des Vorschlags: Keith Cirkel ( chai autor)

Um zu verhindern, dass das letzte Element aus dem Ursprungsarray entfernt wird, können Sie es verwenden

Array.from(myArray).pop()

Wird meistens von allen Browsern unterstützt (ES6)

Sie können last()dem ArrayPrototyp eine Funktion hinzufügen .

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

Was immer Sie tun nicht nur verwenden reverse()!!!

In einigen Antworten wird reversedie Tatsache erwähnt, aber nicht erwähnt, dass reversedas ursprüngliche Array geändert wird und keine Kopie (wie in einer anderen Sprache oder einem anderen Framework) zurückgegeben wird.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

Dies kann die schlechteste Art von Code zum Debuggen sein!

Die Zerstörung von ES6-Objekten ist ein weiterer Weg.

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

Sie extrahieren die Längeneigenschaft mithilfe der Objektdestrukturierung aus dem Array. Sie erstellen einen weiteren dynamischen Schlüssel mit dem bereits extrahierten Schlüssel von [Länge-1] und weisen ihn dem letzten zu , alles in einer Zeile.

Sie können dem Prototyp von einen neuen Property Getter hinzufügen , damit auf alle Instanzen von zugegriffen werden kann .ArrayArray

Mit Getters können Sie auf den Rückgabewert einer Funktion zugreifen, als wäre es der Wert einer Eigenschaft. Der Rückgabewert der Funktion ist natürlich der letzte Wert des Arrays (this[this.length - 1] ).

Schließlich wickeln Sie es in eine Bedingung ein, die prüft, ob die lastEigenschaft noch vorhanden ist undefined(nicht durch ein anderes Skript definiert, das möglicherweise darauf angewiesen ist).

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'

Funktioniert nicht in IE ≤ 8.

EDITIERT:

Kürzlich habe ich eine weitere Lösung gefunden, die meiner Meinung nach die beste für meine Bedürfnisse ist:

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

Mit der obigen Definition kann ich jetzt sagen:

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

Der Name "w" steht für "Wrapper". Sie können sehen, wie Sie diesem Wrapper neben 'last ()' problemlos weitere Methoden hinzufügen können.

Ich sage "am besten für meine Bedürfnisse", weil ich auf diese Weise jedem integrierten JavaScript-Typ problemlos andere "Hilfsmethoden" hinzufügen kann. Was mir in den Sinn kommt, sind zum Beispiel das Auto () und das CDR () von Lisp.

Ich denke, der einfachste und ineffizienteste Weg ist:

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