Ini kode JavaScript saya sejauh ini:

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

Saat ini dibutuhkan item kedua hingga terakhir dalam array dari URL. Namun, saya ingin melakukan pengecekan untuk item terakhir dalam array menjadi "index.html"dan jika demikian, ambil item ketiga menjadi terakhir.

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

Dalam hal server Anda berfungsi file yang sama untuk "index.html" dan "index.html" Anda juga dapat menggunakan: .toLowerCase().

Meskipun, Anda mungkin ingin mempertimbangkan melakukan sisi server ini jika mungkin: itu akan lebih bersih dan berfungsi untuk orang tanpa JS.

Tidak yakin apakah ada kekurangan, tetapi ini tampaknya cukup singkat:

arr.slice(-1)[0] 

atau

arr.slice(-1).pop()

Keduanya akan kembali undefinedjika array kosong.

Gunakan Array.pop :

var lastItem = anArray.pop();

Penting : Ini mengembalikan elemen terakhir dan menghapusnya dari array

Versi pendek dari apa yang diposkan @chaiguy:

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

Membaca indeks -1 undefinedsudah kembali .

EDIT:

Hari-hari ini preferensi tampaknya menggunakan modul dan untuk menghindari menyentuh prototipe atau menggunakan namespace global.

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

Dua opsi adalah:

var last = arr[arr.length - 1]

atau

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

Yang pertama lebih cepat, tetapi yang terakhir terlihat lebih bagus

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

Begini cara mendapatkannya tanpa efek pada ARRAY asli

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

Jika Anda menggunakan pop (), itu akan mengubah array Anda

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

Tetapi Anda dapat menggunakan ini sehingga tidak berpengaruh pada array asli:

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 

Cara ES6 "terbersih" (IMO) adalah:

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

Ini menghindari bermutasi foo, seperti .pop()seharusnya, jika kami tidak menggunakan operator spread.
Yang mengatakan, saya suka juga foo.slice(-1)[0]solusinya.

Saya lebih suka menggunakan array.pop()daripada indeks.

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

dengan cara ini Anda selalu mendapatkan elemen sebelum index.html (menyediakan array Anda telah mengisolasi index.html sebagai satu item). Catatan: Anda akan kehilangan elemen terakhir dari array.

Saya pikir jika Anda hanya ingin mendapatkan elemen tanpa menghapus, lebih mudah gunakan ini:

arr.slice(-1)[0]

Catatan: Jika array kosong (mis. []) Ini akan kembali undefined.

omong-omong ... saya tidak memeriksa kinerja, tetapi saya pikir lebih sederhana dan bersih untuk menulis

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

Array.prototype.slice dengan -1 dapat digunakan untuk membuat Array baru yang hanya berisi item terakhir dari Array asli, Anda kemudian dapat menggunakan Destrukturisasi Assignment untuk membuat variabel menggunakan item pertama dari Array baru.

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

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

Mendapatkan item terakhir dari sebuah array dapat dicapai dengan menggunakan metode slice dengan nilai negatif.

Anda dapat membaca lebih lanjut di sini di bagian bawah.

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

Menggunakan pop () akan mengubah array Anda, yang tidak selalu merupakan ide yang bagus.

Anda dapat menggunakan pola ini ...

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

Sementara itu berbunyi agak baik, perlu diingat itu menciptakan sebuah array baru sehingga kurang efisien dibandingkan solusi lain tetapi hampir tidak pernah akan dengan hambatan kinerja aplikasi Anda.

Pertanyaan ini sudah ada sejak lama, jadi saya terkejut bahwa tidak ada yang menyebutkan hanya mengembalikan elemen terakhir setelah pop().

arr.pop()persis seefisien arr[arr.length-1], dan keduanya sama kecepatannya arr.push().

Karena itu, Anda bisa lolos dengan:

--- DIedit [periksa itu thePopbukan undefinedsebelum mendorong] ---

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

--- AKHIR EDIT ---

Yang bisa direduksi menjadi ini (kecepatan yang sama [EDIT: tapi tidak aman!]):

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

Ini dua kali lebih lambat arr[arr.length-1], tetapi Anda tidak perlu mencari-cari indeks. Itu bernilai emas setiap hari.

Dari solusi yang saya coba, dan dalam kelipatan Unit Waktu Eksekusi (ETU) dari arr[arr.length-1]:

[Metode] .............. [ETU 5 elem] ... [ETU 1 juta elem]

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

Tiga opsi terakhir, TERUTAMA [...arr].pop(), menjadi SANGAT jauh lebih buruk karena ukuran array meningkat. Pada mesin tanpa batasan memori mesin saya, [...arr].pop()mungkin mempertahankan sesuatu seperti rasio 120: 1. Namun, tidak ada yang suka babi sumber daya.

Jika seseorang ingin mendapatkan elemen terakhir sekaligus, ia dapat menggunakan Array#splice():

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

Di sini, tidak perlu menyimpan elemen yang terpecah dalam array, dan kemudian sampai ke elemen terakhir. Jika mendapatkan elemen terakhir adalah satu-satunya tujuan, ini harus digunakan.

Catatan: Ini mengubah array asli dengan menghapus elemen terakhirnya. Anggap splice(-1,1)sebagai pop()fungsi yang muncul elemen terakhir.

Bagi mereka yang tidak takut untuk membebani prototipe Array (dan dengan cara penghitungan, Anda seharusnya tidak):

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

jQuery memecahkan ini dengan rapi:

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

Saya biasanya menggunakan underscorejs , dengan itu Anda bisa melakukannya

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

Bagi saya itu lebih semantik daripada loc_array.slice(-1)[0]

Ini lebih banyak seni Javascript jika Anda datang ke sini mencarinya

Dengan semangat jawaban lain yang digunakan reduceRight(), tetapi lebih pendek:

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

Itu bergantung pada fakta bahwa, jika Anda tidak memberikan nilai awal, elemen terakhir dipilih sebagai yang awal (periksa dokumen di sini ). Karena panggilan balik hanya mengembalikan nilai awal, elemen terakhir akan menjadi yang dikembalikan pada akhirnya.

Berhati-hatilah karena ini harus dianggap sebagai seni Javascript dan sama sekali tidak seperti cara saya akan merekomendasikan melakukannya, terutama karena itu berjalan dalam waktu O (n), tetapi juga karena itu menyakitkan keterbacaan.

Dan sekarang untuk jawaban yang serius

Cara terbaik yang saya lihat (mengingat Anda menginginkannya lebih ringkas daripada array[array.length - 1]) adalah ini:

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

Kemudian gunakan saja fungsinya:

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

Fungsi ini sebenarnya berguna jika Anda berurusan dengan array anonim seperti yang [3, 2, 1, 5]digunakan di atas, jika tidak Anda harus instantiate dua kali, yang akan menjadi tidak efisien dan jelek:

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

Ugh.

Misalnya, inilah situasi di mana Anda memiliki array anonim dan Anda harus mendefinisikan variabel, tetapi Anda bisa menggunakannya last()sebagai gantinya:

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

Hanya menempatkan opsi lain di sini.

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

Saya menemukan pendekatan di atas lebih bersih dan onliner pendek. Tolong, jangan ragu untuk mencoba yang ini.

Catatan: Ini akan mengubah array asli, jika Anda tidak ingin memodifikasinya, Anda dapat menggunakannya slice()

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

Terima kasih @VinayPai untuk menunjukkan ini.

Berbagai cara untuk menemukan nilai terakhir array dalam javascript

• Tanpa memengaruhi array asli

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

• Memodifikasi array asli

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

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

• Dengan membuat metode pembantu sendiri

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

Ini adalah opsi terbaik dari sudut pandang kinerja (~ 1000 kali lebih cepat daripada arr.slice (-1)).

Secara pribadi saya akan menjawab dengan jawaban kuporific / kritzikratzi. Metode array [array.length-1] menjadi sangat jelek jika Anda bekerja dengan array bersarang.

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]

Dalam proposal ECMAScript Tahap 1 ada saran untuk menambahkan properti array yang akan mengembalikan elemen terakhir: proposal-array-last .

Sintaksis:

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

arr.lastIndex // get last index

Anda bisa menggunakan polyfill .

Penulis proposal: Keith Cirkel ( chai autor)

Untuk mencegah penghapusan item terakhir dari array asal, Anda dapat menggunakan

Array.from(myArray).pop()

Yang paling didukung dari semua browser (ES6)

Anda dapat menambahkan last()fungsi ke Arrayprototipe.

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

Apa pun yang Anda lakukan jangan hanya gunakan reverse()!!!

Beberapa jawaban menyebutkan reversetetapi tidak menyebutkan fakta bahwa reversememodifikasi array asli, dan tidak (seperti dalam beberapa bahasa atau kerangka kerja lain) mengembalikan salinan.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

Ini bisa menjadi jenis kode terburuk untuk di-debug!

Penghancuran objek ES6 adalah cara lain untuk pergi.

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

Anda mengekstrak properti panjang dari Array menggunakan perusakan objek. Anda membuat kunci dinamis lain menggunakan kunci yang sudah diekstraksi oleh [length-1] dan menetapkannya untuk bertahan lama , semuanya dalam satu baris.

Anda bisa menambahkan pengambil properti baru ke prototipeArray sehingga dapat diakses melalui semua contoh Array.

Getters memungkinkan Anda untuk mengakses nilai pengembalian suatu fungsi sama seperti nilai properti. Nilai kembali dari fungsi tentu saja adalah nilai terakhir dari array ( this[this.length - 1]).

Akhirnya Anda membungkusnya dalam kondisi yang memeriksa apakah last-property masih undefined(tidak ditentukan oleh skrip lain yang mungkin bergantung padanya).

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'

Tidak bekerja di IE ≤ 8.

Diedit:

Baru-baru ini saya menemukan satu solusi lagi yang sekarang saya pikir merupakan yang terbaik untuk kebutuhan saya:

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

Dengan definisi di atas yang berlaku sekarang saya dapat mengatakan:

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

Nama "w" adalah singkatan dari "wrapper". Anda dapat melihat bagaimana Anda dapat dengan mudah menambahkan lebih banyak metode selain 'last ()' ke pembungkus ini.

Saya mengatakan "terbaik untuk kebutuhan saya", karena ini memungkinkan saya untuk dengan mudah menambahkan "metode pembantu" lainnya ke semua tipe bawaan JavaScript. Apa yang terlintas dalam pikiran adalah mobil () dan cdr () dari Lisp misalnya.

Saya pikir cara termudah dan super tidak efisien adalah:

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