JavaScript kodum şu ana kadar:

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

Şu anda dizideki ikinci ile son öğeyi URL'den alıyor. Ancak, dizideki son öğe için bir kontrol yapmak istiyorum "index.html"ve eğer öyleyse, bunun yerine üçüncü son öğe almak.

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

: Sunucu da kullanabilirsiniz "index.html" ve "index.html" için aynı dosyayı vermektedir durumunda .toLowerCase().

Yine de, mümkünse bu sunucu tarafını yapmayı düşünebilirsiniz: daha temiz olacak ve JS'si olmayan kişiler için çalışacaktır.

Bir dezavantaj olup olmadığından emin değilim, ancak bu oldukça özlü görünüyor:

arr.slice(-1)[0] 

veya

arr.slice(-1).pop()

undefinedDizi boşsa her ikisi de geri döner .

Array.pop kullanın :

var lastItem = anArray.pop();

Önemli : Bu son öğeyi döndürür ve kaldırır diziden onu

@Chaiguy'un gönderdiği şeyin daha kısa bir sürümü:

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

-1 dizinini okumak undefinedzaten geri döner .

DÜZENLE:

Bu günlerde tercih modülleri kullanıyor ve prototipe dokunmaktan veya global bir ad alanı kullanmaktan kaçınmak gibi görünüyor.

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

İki seçenek vardır:

var last = arr[arr.length - 1]

veya

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

Birincisi daha hızlı, ancak ikincisi daha güzel görünüyor

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

Orijinal ARRAY üzerinde hiçbir etkisi olmadan nasıl elde edeceğiniz aşağıda açıklanmıştır

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

Pop () kullanırsanız , dizinizi değiştirir

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

Ancak bunu , orijinal dizi üzerinde hiçbir etkisi olmayacak şekilde kullanabilirsiniz :

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 

"En temiz" ES6 yolu (IMO) şöyle olur:

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

Bu , yayılma operatörünü kullanmadığımız foogibi mutasyona uğramasını önler .pop().
Yani foo.slice(-1)[0]çözümü de seviyorum .

array.pop()Dizinlerden çok kullanmayı tercih ederim .

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

bu şekilde öğeyi her zaman index.html'den önce alırsınız (dizinizin tek bir öğe olarak izole index.html olması şartıyla). Not: Yine de dizideki son öğeleri kaybedersiniz.

Sadece kaldırmadan öğeyi almak istiyorsanız, daha basit olduğunu düşünüyorum:

arr.slice(-1)[0]

Not: Dizi boşsa (örn. []) Bu geri döner undefined.

bu arada ... performansı kontrol etmedim, ama bence yazmak daha basit ve temiz

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

-1 ile Array.prototype.slice , yalnızca orijinal Dizinin son öğesini içeren yeni bir Dizi oluşturmak için kullanılabilir, daha sonra yeni Dizinin ilk öğesini kullanarak bir değişken oluşturmak için Yıkıcı Atama'yı kullanabilirsiniz .

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

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

Bir dizinin son öğesinin elde edilmesi, negatif değerlere sahip dilim yöntemi kullanılarak elde edilebilir .

Bununla ilgili daha fazla bilgiyi aşağıda bulabilirsiniz .

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

Pop () kullanılması dizinizi değiştirecektir, bu her zaman iyi bir fikir değildir.

Bu kalıbı kullanabilirsiniz ...

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

Oldukça güzel okur da, diğer çözümlere göre daha az verimli ama o olmak neredeyse bu sayede hiç yeni bir dizi oluşturur akılda tutmak uygulamanızın performansını darboğaz.

Bu soru uzun zamandır var, bu yüzden hiç kimsenin sadece son elementi a pop().

arr.pop()kadar verimli arr[arr.length-1]ve her ikisi de aynı hızdaarr.push() .

Bu nedenle, aşağıdakilerle kurtulabilirsiniz:

--- DÜZENLENDİ [ itmeden önce thePopolmadığını kontrol edin undefined] ---

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

--- SON DÜZENLEME ---

Bu azaltılabilir (aynı hız [EDIT: ama güvensiz!]):

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

Bu iki kat daha yavaştır arr[arr.length-1], ancak bir dizinle uğraşmanıza gerek yoktur. Her gün altın değerinde.

Denediğim çözümlerden ve Yürütme Süresi Biriminin (ETU) katları arr[arr.length-1]:

[Yöntem] .............. [ETU'lar 5 elem] ... [ETU 1 milyon 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 :)

Son üç seçenek, [...arr].pop()özellikle dizinin boyutu arttıkça ÇOK daha da kötüleşir. Makinemin bellek sınırlaması olmayan bir makinede, [...arr].pop()muhtemelen 120: 1 oranı gibi bir şeyi korur. Yine de hiç kimse bir kaynak domuzunu sevmiyor.

Eğer bir kişi en son unsuru bir seferde elde etmek istiyorsa kullanabilir Array#splice():

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

Burada, bölünmüş öğeleri bir dizide saklamanıza ve ardından son öğeye gitmenize gerek yoktur. Eğer son elementi almak tek hedef ise, bu kullanılmalıdır.

Not: Bu , son diziyi kaldırarak orijinal diziyi değiştirir . Son öğeyi açan splice(-1,1)bir pop()işlev olarak düşünün .

Array prototipini aşırı yüklemekten korkmayanlar (ve numaralandırma maskelemesi ile olmamalısınız):

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

jQuery bunu düzgün bir şekilde çözer:

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

Genellikle underscorejs kullanıyorum , bununla sadece

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

Benim için bu daha semantik loc_array.slice(-1)[0]

Eğer buraya gelmek için geldiysen daha fazla Javascript sanatı var

Kullanılan reduceRight(), ancak daha kısa başka bir cevap ruhu içinde :

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

Başlangıç ​​değeri girmemeniz durumunda, ilk öğenin ilk öğe olarak seçildiği gerçeğine dayanır ( burada dokümanları kontrol edin ). Geri arama yalnızca ilk değeri döndürmeye devam ettiğinden, son öğe sonunda döndürülecek olan öğe olacaktır.

Bunun Javascript sanatı olarak kabul edilmesi gerektiğini unutmayın ve çoğunlukla O (n) zamanında çalıştığı için değil, aynı zamanda okunabilirliği de bozduğu için bunu yapmayı tavsiye edeceğim.

Ve şimdi ciddi cevap için

Gördüğüm en iyi yol (daha özlü olmasını istediğinizi düşünerek array[array.length - 1]) şudur:

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

Sonra sadece işlevi kullanın:

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

İşlev aslında [3, 2, 1, 5]yukarıda kullanılan gibi anonim bir dizi ile uğraşıyorsanız faydalıdır , aksi takdirde iki kez başlatmanız gerekir, bu da verimsiz ve çirkin olur:

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

Ugh.

Örneğin, anonim bir diziniz olduğu ve bir değişken tanımlamanız gereken bir durum, ancak last()bunun yerine şunları kullanabilirsiniz :

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

Buraya başka bir seçenek koymak.

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

Yukarıdaki yaklaşımı daha temiz ve kısa onliner buldum. Lütfen, bunu denemek için çekinmeyin.

Not: Orijinal diziyi değiştirir, değiştirmek istemiyorsanız kullanabilirsiniz slice()

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

@VinayPai bunu işaret ettiğiniz için teşekkürler .

Javascript'te bir dizinin son değerini bulmanın birden çok yolu

• Orijinal diziyi etkilemeden

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

• Orijinal diziyi değiştirir

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

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

• Kendi yardımcı yöntemini oluşturarak

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

Bu, performans açısından en iyi seçenektir (arr diliminden (-1) ~ 1000 kat daha hızlı).

Şahsen ben kuporific / kritzikratzi'nin cevabını iptal ediyorum. İç içe dizilerle çalışıyorsanız dizi [array.length-1] yöntemi çok çirkinleşir.

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]

ECMAScript teklif Aşama 1'de , son öğeyi döndürecek bir dizi özelliği eklemeniz için bir öneri var: teklif-dizi-son .

Sözdizimi:

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

arr.lastIndex // get last index

Çoklu dolguyu kullanabilirsiniz .

Teklif yazarı: Keith Cirkel ( chai autor)

Başlangıç ​​öğesinden son öğenin kaldırılmasını önlemek için kullanabilirsiniz

Array.from(myArray).pop()

Çoğunlukla tüm tarayıcılarda desteklenir (ES6)

Prototife bir last()işlev ekleyebilirsiniz Array.

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

Ne yaparsanız yapın sadece kullanmayın reverse()!!!

Birkaç cevap , orijinal diziyi değiştiren ve (diğer bazı dillerde veya çerçevelerde olduğu gibi) bir kopya döndürmediğinden reversebahsetmez reverse.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

Bu hata ayıklamak için en kötü kod türü olabilir!

ES6 nesnesini yok etmek başka bir yol.

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

Sen ayıklamak uzunluk nesne strüktür kullanarak Array malını. [Length-1] tarafından daha önce ayıklanmış anahtarı kullanarak başka bir dinamik anahtar oluşturursunuz ve sonuna bir satırda atayacak şekilde atarsınız .

Yeni bir mülk alıcısı ekleyebilirsiniz . bir prototipArray o tüm örneklerini erişilebilir olması için Array.

Getters, bir işlevin dönüş değerine, tıpkı bir özelliğin değeriymiş gibi erişmenizi sağlar. İşlevin dönüş değeri elbette dizinin ( this[this.length - 1]) son değeridir .

Son olarak, last-property'nin hala olup olmadığını kontrol eden bir koşula sarıyorsunuz undefined(buna güvenebilecek başka bir komut dosyası tarafından tanımlanmadı).

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'

IE work 8 ile çalışmaz.

REDAKTE:

Son zamanlarda ihtiyaçlarım için en iyisi olduğunu düşündüğüm bir çözüm daha buldum:

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

Yukarıdaki tanımın yürürlüğe girmesiyle artık şunu söyleyebilirim:

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

"W" adı " sarmalayıcı" anlamına gelir. Bu sarmalayıcıya 'last ()' öğesinin yanı sıra nasıl daha fazla yöntem ekleyebileceğinizi kolayca görebilirsiniz.

"İhtiyaçlarım için en iyisi" diyorum, çünkü bu herhangi bir JavaScript yerleşik türüne kolayca bu tür "yardımcı yöntemler" eklememe izin veriyor. Akla gelen, örneğin Lisp arabası () ve cdr ().

Bence en kolay ve süper verimsiz yol:

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