Вот мой код 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]
Первый быстрее, но последний выглядит лучше
Здесь, как получить его без влияния на исходное значение 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
Самым "чистым" способом 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.
кстати... я не проверял производительность, но я думаю, что проще написать и написать
Получение последнего элемента массива может быть достигнуто с помощью метода slice с отрицательными значениями.
Вы можете прочитать об этом здесь внизу.
var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
//your code...
}
Использование pop() изменит ваш массив, что не всегда является хорошей идеей.
Вы можете использовать этот шаблон...
let [last] = arr.slice(-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]
Этот вопрос был давно, поэтому я удивлен, что никто не упомянул о том, чтобы просто поставить последний элемент после pop().
arr.pop() точно так же эффективен, как arr[arr.length-1], и оба имеют ту же скорость, что и arr.push().
Таким образом, вы можете сойти с рук:
---EDITED [проверьте, что thePop не undefined перед нажатием] ---
let thePop = arr.pop()
thePop && arr.push(thePop)
---END EDIT---
Который может быть уменьшен до этого (та же скорость [РЕДАКТИРОВАТЬ: но небезопасно!]):
arr.push(thePop = arr.pop()) //Unsafe if arr empty
Это вдвое медленнее, чем arr[arr.length-1], но вам не нужно arr[arr.length-1] с индексом. Это стоит золота в любой день.
Из решений, которые я пробовал, и во множественных arr[arr.length-1] времени выполнения (ETU) arr[arr.length-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. Тем не менее, никто не любит ресурсного борова.
const [lastItem] = array.slice(-1);Array.prototype.slice с -1 можно использовать для создания нового массива, содержащего только последний элемент исходного массива, затем вы можете использовать назначение деструктурирования для создания переменной с использованием первого элемента этого нового массива.
const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);
console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22const 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]
Вы можете добавить функцию last() в прототип Array.
Array.prototype.last = function () {
return this[this.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)
Вы можете добавить новый свойство getter в прототип Array, чтобы он был доступен через все экземпляры Array.
Getters позволяет получить доступ к возвращаемому значению функции так же, как если бы это было значение свойства. Возвращаемое значение функции, конечно, является последним значением массива (this[this.length - 1]).
Наконец, вы завершаете его в состояние, которое проверяет, остается ли last -property undefined (не определено другим script, который может положиться на него).
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'
Редакция:
Недавно я придумал еще одно решение, которое, на мой взгляд, лучше всего подходит для моих нужд:
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.
В духе другого ответа, который использовал 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("."));
Чтобы предотвратить удаление последнего элемента из исходного массива, вы можете использовать
Array.from(myArray).pop()
В основном поддерживается всеми браузерами (ES6)
reverse() !!!В нескольких ответах упоминается reverse, но не упоминается тот факт, что reverse изменяет исходный массив и не (как в некоторых других языках или средах) возвращает копию.
var animals = ['dog', 'cat'];
animals.reverse()[0]
"cat"
animals.reverse()[0]
"dog"
animals.reverse()[1]
"dog"
animals.reverse()[1]
"cat"
Это может быть худший тип кода для отладки!
Я думаю, что самый простой и суперэффективный способ:
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)));
Как насчет чего-то вроде ниже:
if ('index.html' === array[array.length - 1]) {
//do this
} else {
//do that
}
Если вы используете Underscore или Lodash, вы можете использовать _.last(), так что-то вроде:
if ('index.html' === _.last(array)) {
//do this
} else {
//do that
}
Или вы можете создать свою собственную последнюю функцию:
const _last = arr => arr[arr.length - 1];
и используйте это как:
if ('index.html' === _last(array)) {
//do this
} else {
//do that
}
Используя оператор распространения ES6/ES2015 (...), вы можете сделать следующий путь.
const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)