Два варианта:

var last = arr[arr.length - 1]

or

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

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

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

Вот как это сделать, не влияя на исходный ARRAY

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 

Представление

Сегодня 2020.05.16 я тестирую выбранные решения на Chrome v81.0, Safari v13.1 и Firefox v76.0 на MacOs High Sierra v10.13.6

Выводы

• arr[arr.length-1] (D) рекомендуется как самое быстрое кросс-браузерное решение.
• изменяемое решение arr.pop() (A) и неизменное _.last(arr) (L) быстро
• решения I, J медленные для длинных строк
• решения H, K (jQuery) самые медленные во всех браузерах

Подробности

Я тестирую два случая на предмет решений:

• изменчивый: A, B, C,

• неизменяемый: D, E, F, G, H, I, J (мой),

• неизменяемый из внешних библиотек: K, L, M,

на два случая

• короткая строка - 10 символов - вы можете запустить тест ЗДЕСЬ
• длинная строка - 1 млн символов - вы можете запустить тест ЗДЕСЬ

function A(arr) {
  return arr.pop();
}

function B(arr) {  
  return arr.splice(-1,1);
}

function C(arr) {  
  return arr.reverse()[0]
}

function D(arr) {
  return arr[arr.length - 1];
}

function E(arr) {
  return arr.slice(-1)[0] ;
}

function F(arr) {
  let [last] = arr.slice(-1);
  return last;
}

function G(arr) {
  return arr.slice(-1).pop();
}

function H(arr) {
  return [...arr].pop();
}

function I(arr) {  
  return arr.reduceRight(a => a);
}

function J(arr) {  
  return arr.find((e,i,a)=> a.length==i+1);
}

function K(arr) {  
  return $(arr).get(-1);
}

function L(arr) {  
  return _.last(arr);
}

function M(arr) {  
  return _.nth(arr, -1);
}






// ----------
// TEST
// ----------

let loc_array=["domain","a","b","c","d","e","f","g","h","file"];

log = (f)=> console.log(`${f.name}: ${f([...loc_array])}`);

[A,B,C,D,E,F,G,H,I,J,K,L,M].forEach(f=> log(f));

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js" integrity="sha256-VeNaFBVDhoX3H+gJ37DpT/nTuZTdjYro9yBruHjVmoQ=" crossorigin="anonymous"></script>

Пример результатов для Chrome для короткой строки

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Если кто-то хочет получить последний элемент за один раз, он / она может использовать _ 1_:

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

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

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

Этот вопрос существует уже давно, поэтому я удивлен, что никто не упомянул о том, чтобы просто вернуть последний элемент после 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]:

[Метод] .............. [ETU 5 элементов] ... [ETU 1 миллион элементов]

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. Тем не менее, никому не нравится пожирание ресурсов.

Несколько способов найти последнее значение массива в 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)

let copyArr = [...arr];
console.log(copyArr.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);

Просто помещаю сюда еще один вариант.

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

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

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

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

Благодарим @VinayPai за указание на это.

TL; DR

const [y] = x.slice(-1)

Объяснение:
Этот забавный синтаксис [y] = <array-or-an-object> на самом деле называется Назначение деструктуризации и согласно документации Mozilla

Синтаксис деструктурирующего присваивания - это выражение JavaScript, которое позволяет распаковывать значения из массивов или свойства из объектов в отдельные переменные

Подробнее об этом здесь

Деструктуризация объекта ES6 - еще один путь.

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

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

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

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]

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

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

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

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

Помните, что это следует рассматривать как искусство 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("."));

jQuery решает эту проблему:

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

Предложение Array.prototype.at (этап 3) добавляет метод относительной индексации (MDN):

const myArray = [1, 2, 3]

console.log(myArray.at(-1))
// => 3

Другое предложение TC39, Array.prototype.lastItem предложение (этап 1), добавляет геттер, который возвращает последний элемент в массиве:

const myArray = [1, 2, 3]

console.log(myArray.lastItem)
// => 3

Предложение .at в настоящее время реализовано только в предварительных версиях Firefox и Safari.

.lastItem не поддерживается ни в одном браузере, и в настоящее время автор предложения рассматривает возможность его отзыва.

Чтобы предотвратить удаление последнего элемента из исходного массива, вы можете использовать

Array.from(myArray).pop()

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

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

Синтаксис:

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

arr.lastIndex // get last index

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

Автор предложения: Кейт Сиркель (chai автор)

Что бы вы ни делали, не просто используйте reverse() !!!

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

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

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

Лично я бы поддержал ответ 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]

Я думаю, это должно работать нормально.

var arr = [1, 2, 3];
var last_element = arr.reverse()[0];

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

Изменить: как указано ниже, исходный массив будет перевернут. Чтобы этого избежать, вы можете изменить код на:

var arr = [1, 2, 3];
var last_element = arr.slice().reverse()[0];

Это создаст копию исходного массива.

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

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