Вот мой код JavaScript:

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

В настоящее время он занимает от второго до последнего элемента в массиве из URL. Тем не менее, я хочу сделать проверку последнего элемента в массиве "index.html"и, если это так, вместо этого взять третий элемент до последнего.

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

В случае, если ваш сервер обслуживает один и тот же файл «index.html» и «index.html» вы также можете использовать: .toLowerCase().

Тем не менее, вы можете рассмотреть возможность использования этой серверной части, если это возможно: она будет чище и будет работать для людей без JS.

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

arr.slice(-1)[0] 

или

arr.slice(-1).pop()

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

Используйте Array.pop :

var lastItem = anArray.pop();

Важно : это возвращает последний элемент и удаляет его из массива

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

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

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

РЕДАКТИРОВАТЬ:

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

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 

Самый «чистый» путь ES6 (IMO) будет:

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

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

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

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

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

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

arr.slice(-1)[0]

Примечание. Если массив пуст (например, []), он вернетсяundefined .

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

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

Array.prototype.slice с -1 можно использовать для создания нового массива, содержащего только последний элемент исходного массива, затем вы можете использовать Destructuring Assignment для создания переменной с использованием первого элемента этого нового массива.

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

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

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

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

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

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

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

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

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

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

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

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

--- отредактировано [проверьте, что thePopне undefinedдо нажатия] ---

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

--- КОНЕЦ РЕДАКТИРОВАНИЯ ---

Который может быть уменьшен до этого (та же скорость [РЕДАКТИРОВАТЬ: но небезопасно!]):

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

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

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

[Метод] .............. [ETUs 5 elems] ... [ETUs 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. Тем не менее, никто не любит ресурсного борова.

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

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

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

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

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

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

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

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

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

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

Для меня это более семантически, чем loc_array.slice(-1)[0]

Вот еще искусство Javascript, если вы пришли сюда в поисках

В духе другого ответа, который использовал reduceRight(), но короче:

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

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

Помните, что это следует рассматривать как искусство Javascript, и я ни в коем случае не рекомендую делать это, в основном потому, что он выполняется за время O (n), а также потому, что это ухудшает читабельность.

А теперь серьезный ответ

Лучший способ, который я вижу (учитывая, что вы хотите его более кратким, чем array[array.length - 1]), заключается в следующем:

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

Тогда просто используйте функцию:

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

Функция на самом деле полезна в случае, если вы имеете дело с анонимным массивом, подобным [3, 2, 1, 5]используемому выше, в противном случае вам придется создавать его дважды, что было бы неэффективно и уродливо:

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

Тьфу.

Например, вот ситуация, когда у вас есть анонимный массив и вам нужно определить переменную, но вы можете использовать last()вместо этого:

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

Просто поставлю еще один вариант здесь.

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

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

Примечание: он изменит исходный массив, если вы не хотите изменять его, вы можете использовать slice()

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

Спасибо @VinayPai за указание на это.

Несколько способов найти последнее значение массива в JavaScript

• Без влияния на исходный массив

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

• Изменяет исходный массив

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

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

• Создав собственный вспомогательный метод

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

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

Лично я бы приветствовал ответ от kuporific / kritzikratzi. Метод array [array.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]

В стадии предложения ECMAScript 1 предлагается добавить свойство массива, которое будет возвращать последний элемент: offer-array-last .

Синтаксис:

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

arr.lastIndex // get last index

Вы можете использовать полифилл .

Автор предложения: Кит Циркель ( Chai Autor)

Для предотвращения удаления последнего элемента из исходного массива вы можете использовать

Array.from(myArray).pop()

В основном поддерживается всеми браузерами (ES6)

Вы можете добавить last()функцию к Arrayпрототипу.

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

Все, что вы делаете, не просто использоватьreverse() !!!

В нескольких ответах упоминается, reverseно не упоминается тот факт, что он reverseизменяет исходный массив и не (как в некоторых других языках или платформах) не возвращает копию.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

Это может быть худший тип кода для отладки!

Уничтожение объектов ES6 - это еще один путь.

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

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

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

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

Наконец, вы заключаете его в условие, которое проверяет, lastявляется ли свойство -pro все еще 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. Например, на ум приходят car () и cdr () из Lisp.

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

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