Holen Sie sich das letzte Element in einem Array

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

arr.slice(-1)[0] 

oder

arr.slice(-1).pop()

Beide geben undefined zurück, wenn das Array leer ist. 

Verwenden Sie Array.pop :

var lastItem = anArray.pop();

Important: Gibt das letzte Element undentfernt aus dem Array zurück

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

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

Das Lesen des Index -1 gibt bereits undefined zurück.

BEARBEITEN:

Heutzutage scheint die Präferenz die Verwendung von Modulen zu sein 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, aber letzteres sieht schöner aus

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

So erhalten Sie es ohne Auswirkungen auf das ursprüngliche ARRAY

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 auf dem ursprünglichen Array keine Wirkung 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 die Veränderung von foo, wie es .pop() hätte, wenn wir den Spread-Operator nicht verwendet hätten.
Das heißt, ich mag auch die foo.slice(-1)[0]-Lösung.

Ich benutze lieber array.pop() als Indizes.

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

auf diese Weise erhalten Sie das Element immer vor index.html (sofern Ihr Array index.html als ein Element isoliert hat). Hinweis: Sie verlieren jedoch die letzten Elemente des Arrays.

Das letzte Element eines Arrays kann mit der Methode slice mit negativen Werten ermittelt werden.

Sie können mehr darüber hier unten lesen.

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

Mit pop () ändern Sie Ihr Array, was nicht immer eine gute Idee ist.

Sie können dieses Muster verwenden ...

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

Beachten Sie, dass es ein neues Array erstellt und damit weniger effizient ist als andere Lösungen. Es wird jedoch fast nie der Leistungsengpass sein Ihre Bewerbung.

Wenn Sie das letzte Element auf einmal erhalten möchten, können Sie Array#splice() verwenden:

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

Hier ist es nicht erforderlich, die aufgeteilten Elemente in einem Array zu speichern und dann zum letzten Element zu gelangen. Wenn das letzte Element das einzige Ziel ist, sollte dieses verwendet werden.

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

Ich denke, wenn Sie nur das Element erhalten möchten, ohne es zu entfernen, verwenden Sie einfach Folgendes:

arr.slice(-1)

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

Für diejenigen, die den Array-Prototyp nicht zu überfordern haben (und mit Aufzählungsmaske sollten Sie nicht):

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 generell underscorejs , damit kann man es einfach machen 

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

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

Diese Frage gibt es schon lange, also bin ich erstaunt, dass niemand erwähnt hat, dass er das letzte Element nach einer pop() wieder anlegt.

arr.pop() ist genauso effizient wie arr[arr.length-1] und beide haben dieselbe Geschwindigkeit wie arr.Push().

Daher können Sie mit:

--- BEARBEITET [überprüfen, dass thePop nicht undefined ist, bevor Sie drücken] ---

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

--- ENDE BEARBEITEN ---

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

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

Dies ist doppelt so langsam wie arr[arr.length-1], aber Sie müssen sich nicht mit einem Index herumschlagen. 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 elems] ... [ETU 1 Million 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 :)

Die letzten drei Optionen, BESONDERS [...arr].pop(), werden sehr viel schlechter, wenn die Größe des Arrays zunimmt. Auf einem Computer ohne die Speicherbeschränkungen meines Computers behält [...arr].pop() wahrscheinlich ein Verhältnis von 120: 1 bei. Trotzdem mag niemand ein Rohstoffschwein.

Ich persönlich würde die Antwort von kuporific/kritzikratzi bestätigen. Die array [array.length-1] -Methode 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]

Sie können dem Prototyp Array eine last()-Funktion hinzufügen.

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

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

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

Sie können dem -Prototyp von Array einen neuen property getter hinzufügen, so dass auf alle Instanzen von Array zugegriffen werden kann.

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 last- Eigenschaft noch undefined ist (nicht von einem anderen 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.

BEARBEITET:  

Vor kurzem habe ich mir eine weitere Lösung ausgedacht, die ich für die beste Lösung halte:

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

Mit der obigen Definition kann ich nun 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 neben 'last ()' diesem Wrapper problemlos weitere Methoden hinzufügen können.

Ich sage "am besten für meine Bedürfnisse", da diesme es ermöglicht, andere "Helper-Methoden" Zu jedem in JavaScript integrierten Typ hinzuzufügen. Was ___ in den Sinn kommt, sind das car () und das cdr () von LISP für die __.-Instanz.

Ich denke, der einfachste und äußerst ineffiziente 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".

Ich schlage vor, eine Hilfsfunktion zu erstellen und sie jedes Mal wiederzuverwenden, Sie werden sie brauchen. Lasst die Funktion allgemeiner gestalten, um nicht nur den letzten Artikel, sondern auch den zweiten Platz usw. zu erhalten.

function last(arr, i) {
    var i = i || 0;
    return arr[arr.length - (1 + i)];
}

Die Verwendung ist einfach

var arr = [1,2,3,4,5];
last(arr);    //5
last(arr, 1); //4
last(arr, 9); //undefined

Lassen Sie uns jetzt das ursprüngliche Problem lösen

Holen Sie sich das vorletzte Element-Formularfeld. Wenn das letzte Element im loc_array "index.html" ist, greifen Sie stattdessen das vorletzte Element an.

Die nächste Zeile erledigt den Job

last(loc_array, last(loc_array) === 'index.html' ? 2 : 1);

Sie müssen also umschreiben

var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2]))); 

auf diese Weise

var newT = document.createTextNode(unescape(capWords(last(loc_array, last(loc_array) === 'index.html' ? 2 : 1)))); 

oder verwenden Sie zusätzliche Variablen, um die Lesbarkeit zu erhöhen

var nodeName = last(loc_array, last(loc_array) === 'index.html' ? 2 : 1);
var newT = document.createTextNode(unescape(capWords(nodeName)));

Der einfache Weg zum letzten Element des Arrays:

var last_item = loc_array.reverse()[0];

Natürlich müssen wir überprüfen, ob das Array zuerst ein Element enthält.

Im ECMAScript-VorschlagStufe 1 wird vorgeschlagen, eine Array-Eigenschaft hinzuzufügen, die das letzte Element zurückgibt: Vorschlag-Array-Last .

Syntax: 

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

arr.lastIndex // get last index

Sie können polyfill verwenden.

Autorenvorschlag: Keith Cirkel ( chai autor)

Verwenden von lodash _.last (array) Ruft das letzte Element von array ab.

data = [1,2,3]
last = _.last(data)
console.log(last)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

Mit dem ES6/ES2015 Spread-Operator (...) können Sie folgendermaßen vorgehen.

const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)

Bitte beachten Sie, dass bei Verwendung von Spread-Operator und Reverse das ursprüngliche Array nicht mutiert wurde. Dies ist eine reine Möglichkeit, ein letztes Element des Arrays zu erhalten.

Sie können dieses Problem auch erreichen, ohne ein Array aus der URL zu extrahieren

Das ist meine Alternative

var hasIndex = (document.location.href.search('index.html') === -1) ? doSomething() : doSomethingElse();

!Schöne Grüße

Hier ist mehr Javascript-Kunst, wenn Sie hierher gekommen sind und danach gesucht haben

Im Sinne einer anderen Antwort, die reduceRight() verwendet hat, aber kürzer:

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

Es beruht auf der Tatsache, dass, wenn Sie keinen Anfangswert angeben, das allerletzte Element als Anfangselement ausgewählt wird (überprüfen Sie die Dokumente hier ). Da der Rückruf nur den ursprünglichen Wert zurückgibt, wird das letzte Element dasjenige sein, das am Ende zurückgegeben wird.

Beachten Sie, dass dies als Javascript art betrachtet werden sollte. Dies ist keinesfalls die Art und Weise, in der ich es empfehlen würde, hauptsächlich, weil es in O(n) läuft, aber auch, weil es für Lesbarkeit nicht wichtig ist .

Und jetzt die ernsthafte Antwort

Der beste Weg, den ich sehe (in Anbetracht der Tatsache, dass Sie es präziser als array[array.length - 1] möchten), lautet:

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

Dann nutzen Sie einfach die Funktion:

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

Die Funktion ist in der Tat nützlich, wenn Sie ein anonymes Array wie [3, 2, 1, 5] verwenden, das Sie oben verwenden. 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.

Hier ist zum Beispiel eine Situation, in der Sie über ein anonymes Array verfügen und eine Variable definieren müssen. Sie können jedoch stattdessen last() verwenden:

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

Wie wäre es mit etwas wie unten:

if ('index.html' === array[array.length - 1]) {  
   //do this 
} else { 
   //do that 
}

Wenn Sie Underscore verwenden, können Sie _.last() verwenden.

if ('index.html' === _.last(array)) {  
   //do this 
} else { 
   //do that 
}

Das ist sauber und effizient: 

let list = [ 'a', 'b', 'c' ]

(xs => xs[xs.length - 1])(list)

Wenn Sie einen Pipe-Operator mit Babel installieren, wird Folgendes: 

list |> (xs => xs[xs.length - 1])

Was auch immer Sie nicht verwenden, reverse() !!!

Einige Antworten erwähnen reverse, erwähnen jedoch nicht die Tatsache, dass reverse das ursprüngliche Array ändert und (wie in einigen anderen Sprachen oder Frameworks) keine Kopie zurückgibt.

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 sein, die es zu debuggen gilt!

Diese Methode wird sich nicht mit Ihrem Prototyp verwirren. Es schützt auch vor 0 Längenarrays sowie null/undefined Arrays. Sie können den Standardwert sogar überschreiben, wenn der zurückgegebene Standardwert möglicherweise einem Element in Ihrem Array entspricht.

const items = [1,2,3]
const noItems = []

/**
 * Returns the last item in an array.
 * If the array is null, undefined, or empty, the default value is returned.
 */
function arrayLast (arrayOrNull, defVal = undefined) {
  if (!arrayOrNull || arrayOrNull.length === 0) {
    return defVal
  }
  return arrayOrNull[arrayOrNull.length - 1]
}

console.log(arrayLast(items))
console.log(arrayLast(noItems))
console.log(arrayLast(null))

console.log(arrayLast(items, 'someDefault'))
console.log(arrayLast(noItems, 'someDefault'))
console.log(arrayLast(null, 'someDefault'))

Dies kann mit lodash _.last oder _.nth erfolgen:

var data = [1, 2, 3, 4]
var last = _.nth(data, -1)
console.log(last)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

Eine weitere ES6-Option wäre die Verwendung von Array.find(item, index)=> {...}) wie folgt:

const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);

wenig praktischer Wert, veröffentlicht, um zu zeigen, dass der Index auch für Ihre Filterlogik verfügbar ist.

Es gibt auch ein npm-Modul, das last zu Array.prototype hinzufügt

npm install array-prototype-last --save

verwendungszweck

require('array-prototype-last');

[1, 2, 3].last; //=> 3 

[].last; //=> undefined 

Um zu verhindern, dass das letzte Element aus dem Origin-Array entfernt wird, können Sie Folgendes verwenden

Array.from(myArray).pop()

Am meisten von allen Browsern unterstützt (ES6)

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 Destructuring Assignment verwenden, um mit dem ersten Element eine Variable zu erstellen neues Array.

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

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

Ob das funktioniert?

if (loc_array.pop() == "index.html"){
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-3])));
}
else{
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2])));
}

Die arrow-Funktion macht die Methode mit der schnellsten Leistung übersichtlicher, indem der Name des Arrays nicht wiederholt wird.

var lastItem = (a => a[a.length - 1])(loc_array);

Verwenden von reduRight :

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

Hier ist eine saubere Prototyperweiterung, die als einfache Implementierung der Antwort von Aaron Harun dient:

Array.prototype.i = function(val){
    if (val < 0) return this[this.length - Math.abs(val)]
    return this[val]
}

Nachdem Sie den Prototyp definiert haben, funktioniert Folgendes:

arr = [1, 2, 3, 4, 5]
arr.i(0)  // 1
arr.i(-1) // 5
arr.i(-2) // 4