Oto mój kod JavaScript do tej pory:

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

Obecnie trwa od drugiego do ostatniego elementu w tablicy z adresu URL. Chcę jednak sprawdzić, czy ma być ostatni element w tablicy, "index.html"a jeśli tak, to zamiast tego złap trzeci.

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

W przypadku, gdy serwer służy do tego samego pliku na „index.html” i „index.html” można również użyć: .toLowerCase().

Chociaż możesz rozważyć zrobienie tego po stronie serwera, jeśli to możliwe: będzie czystsze i będzie działać dla osób bez JS.

Nie jestem pewien, czy istnieje wada, ale wydaje się to dość zwięzłe:

arr.slice(-1)[0] 

lub

arr.slice(-1).pop()

Oba powrócą, undefinedjeśli tablica jest pusta.

Użyj Array.pop :

var lastItem = anArray.pop();

Ważne : Zwraca ostatni element i usuwa go z tablicy

Krótsza wersja tego, co opublikował @chaiguy:

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

Odczytywanie indeksu -1 undefinedjuż powraca .

EDYTOWAĆ:

Obecnie preferuje się używanie modułów i unikanie dotykania prototypu lub korzystania z globalnej przestrzeni nazw.

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

Dwie opcje to:

var last = arr[arr.length - 1]

lub

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

Pierwszy jest szybszy, ale drugi wygląda ładniej

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

Oto, jak go uzyskać bez wpływu na oryginalną tablicę

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

Jeśli użyjesz pop (), zmodyfikuje twoją tablicę

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

Ale możesz użyć tego, aby nie miało to wpływu na oryginalną tablicę:

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 

„Najczystszym” sposobem ES6 (IMO) byłoby:

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

Pozwala to uniknąć mutacji foo, tak jak .pop()by to było, gdybyśmy nie korzystali z operatora rozprzestrzeniania.
To powiedziawszy, podoba mi się również foo.slice(-1)[0]rozwiązanie.

Wolałbym używać array.pop()niż indeksów.

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

w ten sposób zawsze otrzymujesz element poprzedzający index.html (pod warunkiem, że twoja tablica ma izolowany index.html jako jeden element). Uwaga: jednak stracisz ostatnie elementy z tablicy.

Myślę, że jeśli chcesz tylko uzyskać element bez usuwania, to jest prostsze użyj tego:

arr.slice(-1)[0]

Uwaga: Jeśli tablica jest pusta (np. []), Funkcja zwróciundefined .

nawiasem mówiąc ... nie sprawdziłem wydajności, ale myślę, że jest prostszy i czystszy do napisania

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

Array.prototype.slice z -1 można użyć do utworzenia nowej tablicy zawierającej tylko ostatni element oryginalnej tablicy, a następnie można użyć Przypisania do restrukturyzacji, aby utworzyć zmienną przy użyciu pierwszego elementu tej nowej tablicy.

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

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

Uzyskanie ostatniego elementu tablicy można osiągnąć za pomocą wycinka metody z wartościami ujemnymi.

Więcej na ten temat możesz przeczytać tutaj na dole.

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

Użycie pop () zmieni tablicę, co nie zawsze jest dobrym pomysłem.

Możesz użyć tego wzoru ...

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

Choć brzmi to dość ładnie, należy pamiętać, że tworzy nową tablicę więc jest mniej wydajny niż inne rozwiązania, ale prawie nigdy nie będzie gardłem wydajności aplikacji.

To pytanie było już dawno, więc jestem zaskoczony, że nikt nie wspomniał o ponownym włączeniu ostatniego elementu po pop() .

arr.pop()jest dokładnie tak samo wydajny, jak arr[arr.length-1]i oba mają taką samą prędkość jak arr.push().

Dlatego możesz uciec od:

--- EDYTOWANE [sprawdź, thePopczy nie jest undefinedprzed pchaniem] ---

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

--- EDYCJA KOŃCOWA ---

Co można zredukować do tej samej prędkości (ta sama prędkość [EDYCJA: ale niebezpieczne!]):

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

Jest to dwa razy wolniejsze niż arr[arr.length-1], ale nie musisz wypełniać indeksu. To jest warte złota każdego dnia.

Rozwiązań, które wypróbowałem oraz w wielokrotności jednostki czasu wykonania (ETU) arr[arr.length-1]:

[Metoda] .............. [ETU 5 elementów] ... [ETU 1 milion elementów]

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

Ostatnie trzy opcje, W SZCZEGÓLNOŚCI [...arr].pop(), stają się BARDZO gorsze wraz ze wzrostem wielkości tablicy. Na komputerze bez ograniczeń pamięci mojego komputera [...arr].pop()prawdopodobnie zachowuje coś w rodzaju współczynnika 120: 1. Mimo to nikt nie lubi wieprza zasobów.

Jeśli ktoś chce uzyskać ostatni element za jednym razem, może użyć Array#splice():

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

W tym przypadku nie ma potrzeby przechowywania podzielonych elementów w tablicy, a następnie przejścia do ostatniego elementu. Jeśli zdobycie ostatniego elementu jest jedynym celem, należy to wykorzystać.

Uwaga: Zmienia to oryginalną tablicę poprzez usunięcie jej ostatniego elementu. Myśleć splice(-1,1)jako pop()funkcji, które pojawia ostatni element.

Dla tych, którzy nie boją się przeciążać prototypu Array (a przy maskowaniu wyliczeń nie powinieneś być):

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

jQuery rozwiązuje to starannie:

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

Zazwyczaj używam podkreślników , dzięki którym możesz po prostu zrobić

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

Dla mnie jest to bardziej semantyczne niż loc_array.slice(-1)[0]

Oto więcej sztuki Javascript, jeśli tu przyszedłeś jej szukać

W duchu innej odpowiedzi, która została użyta reduceRight(), ale krótsza:

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

Opiera się na fakcie, że jeśli nie podasz wartości początkowej, ostatni element jest wybierany jako element początkowy (sprawdź tutaj dokumenty ). Ponieważ wywołanie zwrotne po prostu zwraca wartość początkową, ostatni element będzie zwracany na końcu.

Uważaj, że należy to uznać za sztukę Javascript i nie jest to sposób, w jaki poleciłbym to zrobić, głównie dlatego, że działa w czasie O (n), ale także dlatego, że szkodzi czytelności.

A teraz poważna odpowiedź

Najlepszy sposób, jaki widzę (biorąc pod uwagę, że chcesz bardziej zwięzły niż array[array.length - 1]), to:

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

Następnie wystarczy użyć funkcji:

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

Ta funkcja jest przydatna w przypadku, gdy masz do czynienia z anonimową tablicą, taką jak [3, 2, 1, 5]używana powyżej, w przeciwnym razie musiałbyś utworzyć ją dwukrotnie, co byłoby nieefektywne i brzydkie:

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

Ugh.

Na przykład, oto sytuacja, w której masz anonimową tablicę i musisz zdefiniować zmienną, ale last()zamiast tego możesz użyć :

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

Po prostu umieszczam tutaj inną opcję.

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

Uważam, że powyższe podejście jest bardziej czyste i krótkie onliner. Proszę, spróbuj tego.

Uwaga: zmodyfikuje oryginalną tablicę, jeśli nie chcesz jej modyfikować, możesz jej użyć slice()

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

Dzięki @VinayPai za zwrócenie na to uwagi.

Wiele sposobów na znalezienie ostatniej wartości tablicy w javascript

• Bez wpływu na oryginalną tablicę

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

• Modyfikuje oryginalną tablicę

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

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

• Tworząc własną metodę pomocniczą

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

To najlepsze opcje z punktu widzenia wydajności (~ 1000 razy szybciej niż arr.slice (-1)).

Osobiście głosowałbym za odpowiedzią kuporific / kritzikratzi. Metoda array [array.length-1] staje się bardzo brzydka, jeśli pracujesz z zagnieżdżonymi tablicami.

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]

W etapie 1 propozycji ECMAScript istnieje sugestia dodania właściwości tablicy, która zwróci ostatni element: wniosek-tablica-ostatnia .

Składnia:

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

arr.lastIndex // get last index

Możesz użyć polyfill .

Autor wniosku: Keith Cirkel ( autor chai )

Aby zapobiec usunięciu ostatniego elementu z tablicy pochodzenia, możesz użyć

Array.from(myArray).pop()

Obsługiwany głównie przez wszystkie przeglądarki (ES6)

Możesz dodać last()funkcję do Arrayprototypu.

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

Cokolwiek robisz, nie tylko używajreverse() !!!

Kilka odpowiedzi wspomina, reverseale nie wspomina o tym, że reversemodyfikuje oryginalną tablicę i nie zwraca (jak w innym języku lub frameworku) kopii.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

To może być najgorszy typ kodu do debugowania!

Restrukturyzacja obiektów ES6 to kolejna droga.

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

Wyodrębniasz właściwość length z tablicy za pomocą destrukcji obiektu. Tworzysz kolejny klucz dynamiczny, używając już wyodrębnionego klucza przez [length-1] i przypisujesz go do końca , wszystko w jednym wierszu.

Możesz dodać nowy getter właściwości do prototypuArray , aby był dostępny we wszystkich instancjachArray .

Gettery umożliwiają dostęp do wartości zwracanej przez funkcję tak, jakby to była wartość właściwości. Zwracana wartość funkcji jest oczywiście ostatnią wartością tablicy (this[this.length - 1] ).

Na koniec lastowijamy go w warunek, który sprawdza, czy właściwość -prop nadal jest undefined(nie zdefiniowana przez inny skrypt, który może na niej polegać).

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'

Nie działa w IE ≤ 8.

EDYTOWANE:

Ostatnio wymyśliłem jeszcze jedno rozwiązanie, które moim zdaniem jest najlepsze dla moich potrzeb:

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

Dzięki powyższej definicji mogę teraz powiedzieć:

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

Nazwa „w” oznacza „opakowanie”. Możesz zobaczyć, jak możesz łatwo dodać do tego opakowania więcej metod niż „last ()”.

Mówię „najlepiej dla moich potrzeb”, ponieważ pozwala mi to łatwo dodawać inne takie „metody pomocnicze” do każdego wbudowanego typu JavaScript. Na myśl przychodzi na przykład car () i cdr () z Lisp.

Myślę, że najłatwiejszym i najbardziej nieefektywnym sposobem jest:

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