Получить последний элемент в массиве.

не уверен, что есть недостаток, но это кажется довольно кратким:

arr.slice(-1)[0] 

или

arr.slice(-1).pop()

оба вернутся undefined если массив пуст.

использовать массив.поп:

var lastItem = anArray.pop();

важно : это возвращает последний элемент ивыводит это из массива

более короткая версия того, что @chaiguy опубликовал:

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

чтение индекса -1 возвращает undefined уже.

EDIT:

В эти дни предпочтение, похоже, использует модули и не касается прототипа или использования глобального пространства имен.

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

два варианта:

var last = arr[arr.length - 1]

или

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

первый быстрее, но последний выглядит лучше

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

вот как получить его без влияния на исходный массив

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

Если вы используете pop (), это будет изменить массив

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

но вы можете использовать это так, что он имеет нет эффекта на исходном массиве:

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 

Я бы предпочел использовать array.pop() чем индексы.

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

таким образом, вы всегда получаете элемент, предшествующий индексу.html (при условии, что Ваш массив имеет изолированный индекс.html как один элемент). Примечание: вы потеряете последние элементы из массива, хотя.

"самый чистый" способ ES6 (IMO) будет:

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

Это позволяет избежать мутации foo, как pop, если бы мы не использовали оператор spread. Тем не менее, мне очень нравится foo.slice(-1)[0] решение тоже.

получение последнего элемента массива может быть достигнуто с помощью slice метод с отрицательными значениями.

вы можете прочитать больше об этом здесь в самом низу.

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

использование pop () изменит Ваш массив, что не всегда является хорошей идеей.

если кто-то хочет получить последний элемент за один раз, он/она может использовать Array#splice():

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

здесь нет необходимости хранить разделения элементов в массиве, а затем добраться до последнего элемента. Если получение последнего элемента является единственной целью, это должно быть использовано.

Примечание: это изменяет исходный массив удалив его последний элемент. Подумайте о splice(-1,1) как pop() функция, которая выводит последний элемент.

jQuery решает это аккуратно:

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

вы можете использовать этот шаблон...

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

хотя он читает довольно хорошо, имейте в виду, что он создает новый массив, поэтому он менее эффективен, чем другие решения, но он почти никогда не будет the производительность приложения.

для тех, кто не боится перегружать прототип массива (причем с перечисление маскирование вы не должны быть):

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

Я обычно использую underscorejs, С ним вы можете просто сделать

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

для меня это больше смысловое, чем loc_array.slice(-1)[0]

лично я бы проголосовал за ответ от kuporific / kritzikratzi. Массив[массив.length - 1] метод становится очень уродливым, если вы работаете с вложенными массивами.

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]

вы можете добавить

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

Это лучшие варианты с точки зрения производительности (~1000 раз быстрее, чем arr.нарезать(-1)).

вы можете добавить новый свойство getter до прототип Array так что он доступен через все экземпляры Array.

геттеры позволяют получить доступ к возвращаемому значению функции так же, как если бы это было значение свойства. Возвращаемое значение функции конечно является последним значением массива (this[this.length - 1]).

наконец, вы заверните его в состояние, которое проверяет, является ли last-свойства undefined (не определяется другим сценарием, который может полагаться на него).

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 ≤ 8.

редактировать:

недавно я придумал еще одно решение, которое я теперь считаю лучшим для моих нужд:

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

с приведенным выше определением в действительности я могу теперь сказать:

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

имя "w" расшифровывается как"обертка". Вы можете увидеть, как вы можете легко добавить больше методы, кроме 'last ()' к этой оболочке.

Я говорю "лучше для моих нужд", потому что это позволяет мне легко добавить другие такие " вспомогательные методы" к любому JavaScript встроенный тип. Что происходит на ум приходят автомобиль () и cdr () Lisp для пример.

этот вопрос был вокруг долгое время, так что я удивлен, что никто не упомянул просто положить последний элемент обратно после pop().

arr.pop() точно так же эффективно, как arr[arr.length-1], и оба имеют ту же скорость, что и arr.push().

таким образом, вы можете уйти с:

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

который может быть уменьшен до этого (та же скорость):

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

это в два раза медленнее,arr[arr.length-1], но вам не нужно возиться с индексом. Это стоит золота в любой день.

из решений, которые я пробовал, и в кратных единицах времени выполнения (ETU)arr[arr.length-1]:

[способ]..............[ETUs 5 elems]...[ETU 1 миллион 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 :)

последние три варианта, особенно [...arr].pop(), получить очень много хуже, как размер массива увеличивается. На машине без ограничений памяти моей машины,[...arr].pop() вероятно, поддерживает что-то вроде соотношения 120:1. Тем не менее, никто не любит пожирателем ресурсов.

Я думаю, что если вы хотите только получить элемент без удаления, проще использовать это:

arr.slice(-1)

кстати... я не проверял производительность, но думаю проще и понятнее писать

Я думаю, что самый простой и супер неэффективный способ-это:

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

Я предлагаю создать вспомогательную функцию и использовать ее каждый раз, когда она вам понадобится. Давайте сделаем функцию более общей, чтобы иметь возможность получить не только последний элемент, но и второй от последнего и так далее.

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

использование просто

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

теперь давайте решим исходную проблему

захватите предпоследний элемент формы массива. Если последний элемент в loc_array - " index.html " вместо этого возьмите третий до последнего элемента.

следующую строку делает работу

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

Итак, вам нужно будет переписать

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

таким образом

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

или использовать дополнительную переменную для повышения читабельности

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

используя лодашь _.последний(массив) возвращает последний элемент массива.

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>

вы можете достичь этой проблемы также без извлечения массива из url

Это моя альтернатива

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

!Привет¡

С помощью оператора ES6 / ES2015 spread (...) вы можете сделать следующим образом.

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

обратите внимание, что с помощью оператора spread и reverse мы не мутировали исходный массив, это чистый способ получения последнего элемента массива.

в предложении ECMAScriptЭтап 1 есть предложение добавить свойство массива, который возвращает последний элемент:

есть также модуль npm, который добавляет last до Array.prototype

npm install array-prototype-last --save

использование

require('array-prototype-last');

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

[].last; //=> undefined 

другое ES6 только вариант будет использовать Array.find(item, index)=> {...}) следующим образом:

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

небольшое практическое значение, опубликованное, чтобы показать, что индекс также доступен для вашей логики фильтрации.

это чисто и эффективно:

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

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

при установке оператора трубы с помощью Babel он становится:

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