到目前为止，这是我的 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"，如果是，则改为获取倒数第三项。
【问题讨论】：
标签： javascript arrays es2022
这个问题已经存在很长时间了，所以我很惊讶没有人提到在 pop() 之后将最后一个元素重新打开。
arr.pop() 与arr[arr.length-1] 一样高效，并且两者的速度都与arr.push() 相同。
因此，您可以逃脱：
---EDITED [在推送之前检查thePop 不是undefined]---
let thePop = arr.pop()
thePop && arr.push(thePop)
---结束编辑---
这可以减少到这个（相同的速度[编辑：但不安全！]）：
arr.push(thePop = arr.pop()) //Unsafe if arr empty
这比arr[arr.length-1] 慢两倍，但您不必用索引来解决问题。这在任何一天都值得黄金。
在我尝试过的解决方案中，以 arr[arr.length-1] 的执行时间单位 (ETU) 的倍数计算：
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 的比率。尽管如此，没有人喜欢资源狂。
【讨论】：
[] 会变成[undefined]。您需要使用明确的undefined 检查来保护向后推送，例如myPop !== undefined && arr.push(myPop)
In ECMAScript proposalStage 1 建议添加一个数组属性，该属性将返回最后一个元素：proposal-array-last。
语法：
arr.lastItem // get last item
arr.lastItem = 'value' // set last item
arr.lastIndex // get last index
您可以使用polyfill。
提案作者：Keith Cirkel(chaiautor)
【讨论】：
本着使用reduceRight()但更短的另一个答案的精神：
[3, 2, 1, 5].reduceRight(a => a);
它依赖于这样一个事实，即如果您不提供初始值，则选择最后一个元素作为初始值（查看文档here）。由于回调只是不断返回初始值，因此最后一个元素将是最后返回的元素。
请注意，这应该被视为 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("."));
【讨论】：
这个方法不会弄乱你的原型。它还防范0 长度数组以及null/undefined 数组。如果返回的默认值可能与数组中的某个项目匹配，您甚至可以覆盖默认值。
const items = [1,2,3]
const noItems = []
/**
* Returns the last item in an array.
* If the array is null, undefined, or empty, the default value is returned.
*/
function arrayLast (arrayOrNull, defVal = undefined) {
if (!arrayOrNull || arrayOrNull.length === 0) {
return defVal
}
return arrayOrNull[arrayOrNull.length - 1]
}
console.log(arrayLast(items))
console.log(arrayLast(noItems))
console.log(arrayLast(null))
console.log(arrayLast(items, 'someDefault'))
console.log(arrayLast(noItems, 'someDefault'))
console.log(arrayLast(null, 'someDefault'))【讨论】：
获取数组最后一项的简单方法：
var last_item = loc_array.reverse()[0];
当然，我们需要先检查确保数组至少有一项。
【讨论】：
reverse 改变了原始数组，所以如果你连续运行两次，你会得到不同的结果（假设长度> 1）
如果您使用 JS，我建议您查看 Ramda，它是一个函数式编程库（类似于 Lodash 和 Underscore，除了更高级和模块化）。 Ramda 提供了 R.last
import * as R from 'ramda';
R.last(['fi', 'fo', 'fum']); //=> 'fum'
R.last([]); //=> undefined
R.last('abc'); //=> 'c'
R.last(''); //=> ''
它还提供init、head、tail。 List monster from (Learn You a Haskell)
【讨论】：
R.pipe(R.take(1), x=>x*2)（也适用于 typescript）
如下所示：
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
}
【讨论】：
reverse() !!!一些答案提到了reverse，但没有提到reverse 修改了原始数组，并且不（如在某些其他语言或框架中）返回副本。
var animals = ['dog', 'cat'];
animals.reverse()[0]
"cat"
animals.reverse()[0]
"dog"
animals.reverse()[1]
"dog"
animals.reverse()[1]
"cat"
这可能是最难调试的代码类型！
【讨论】：
[...animals].reverse()
[1,3,4,5,"last"].slice().reverse()[0]
为了防止从原始数组中删除最后一项，您可以使用
Array.from(myArray).pop()
大多数浏览器都支持 (ES6)
【讨论】：
const [lastItem] = array.slice(-1);Array.prototype.slice 和 -1 可用于创建仅包含原始 Array 的最后一项的新 Array，然后您可以使用 Destructuring Assignment 使用该新 Array 的第一项创建变量。
const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);
console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22【讨论】：
.slice(-1) 的答案已经多次给出，从in 2012 开始，其含义已详细讨论（与此处不同）。请不要为了获得点赞而重复回答。
array.reverse()[0]
就是这么简单
【讨论】：
在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);【讨论】：
console.log(arr.reverse()[0]) - 恭喜，您刚刚修改了原始数组。
要使用 c# 访问数组中的最后一个元素，我们可以使用 GetUpperBound(0)
(0) 如果这个一维数组
my_array[my_array.GetUpperBound(0)] //this is the last element in this one dim array
【讨论】：
只是在这里添加另一个选项。
loc_array.splice(-1)[0] === 'index.html'
我发现上述方法在网上更简洁。请随意尝试这个。
注意：它会修改原始数组，如果不想修改可以使用slice()
loc_array.slice(-1)[0] === 'index.html'
感谢@VinayPai 指出这一点。
【讨论】：
.slice(-1) 的答案已经多次给出，从 in 2012 开始，其含义已详细讨论（与此处不同）。请不要为了获得点赞而重复回答。
ES6 对象解构是另一种方法。
const {length, [length-1]: last}=[1,2,3,4,5]
console.log(last)您使用对象解构从 Array 中提取 length 属性。您使用 [length-1] 已提取的密钥创建另一个动态密钥，并将其分配给 last，全部在一行中。
【讨论】：
length 是数组的第一个索引。但[length-1] 是最后一个索引（它之前的那个）。 :last 是用于定义最后一个索引的别名（或者确切地说是第一个索引之前的那个）
length 然后使用computed property name [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];
这将创建原始数组的副本。
【讨论】：
arr.slice().pop()
要获得可读且简洁的解决方案，您可以使用Array.prototype.slice 和destructuring 的组合。
const linkElement = document.getElementById("BackButton");
const loc_array = document.location.href.split('/');
// assign the last three items of the array to separate variables
const [thirdLast, secondLast, last] = loc_array.slice(-3);
// use the second last item as the slug...
let parentSlug = secondLast;
if (last === 'index.html') {
// ...unless this is an index
parentSlug = thirdLast;
}
const newT = document.createTextNode(
unescape(
capWords(parentSlug)
)
);
linkElement.appendChild(newT);
但要简单地获取数组中的最后一项，我更喜欢这种表示法：
const [lastItem] = loc_array.slice(-1);
【讨论】：
今天 2020.05.16 我在 MacOs High Sierra v10.13.6 上的 Chrome v81.0、Safari v13.1 和 Firefox v76.0 上执行所选解决方案的测试
arr[arr.length-1] (D) 被推荐为最快的跨浏览器解决方案arr.pop() (A) 和不可变解决方案_.last(arr) (L) 速度很快我测试了两个案例的解决方案：
两种情况
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 的短字符串示例结果
【讨论】：
您可以通过Array#at 使用相对索引：
const myArray = [1, 2, 3]
console.log(myArray.at(-1))
// => 3
【讨论】：
jscOptions=--useAtMethod=true)。 lastItem 提案可能会被撤回。
简单的回答
const array = [1,2,3]
array[array.length - 1]
【讨论】：
Array.prototype.last = function(){
return this[this.length - 1];
}
let a = [1, 2, 3, [4, 5]];
console.log(a.last());
// [ 4, 5 ]
console.log(a.last().last());
// 5
Array.prototype.last = function(val=null) {
if (this.length === 0) {
if (val) this[0] = val;
else return null;
}
temp = this;
while(typeof temp[temp.length-1] === "object") {
temp = temp[temp.length-1];
}
if (val) temp[temp.length-1] = val; //Setter
else return temp[temp.length-1]; //Getter
}
var arr = [[1, 2], [2, 3], [['a', 'b'], ['c', 'd']]];
console.log(arr.last()); // 'd'
arr.last("dd");
console.log(arr); // [ [ 1, 2 ], [ 2, 3 ], [ [ 'a', 'b' ], [ 'c', 'dd' ] ] ]
【讨论】：
通常你不应该弄乱内置类型的原型，但这里有一个技巧/捷径：
Object.defineProperty(Array.prototype, 'last', {
get() {
return this[this.length - 1];
}
});
这将允许所有数组对象具有last 属性，您可以像这样使用它：
const letters = ['a', 'b', 'c', 'd', 'e'];
console.log(letters.last); // 'e'
您不应该弄乱内置类型的原型，因为您永远不会在发布新的 ES 版本时，并且如果新版本使用与您的自定义属性相同的属性名称，各种中断都可以发生。此外，其他人很难遵循您的代码，特别是对于加入团队的人。您可以将属性设置为您知道 ES 版本永远不会使用的东西，例如 listLastItem，但这由开发人员自行决定。
或者你可以用一个简单的方法：
const getLast = (list) => list[list.length - 1];
const last = getLast([1,2,3]); // returns 3
【讨论】：
const [y] = x.slice(-1)
快速解释：
这种语法
[y] = <array/object>被称为解构赋值，根据 Mozilla 文档，解构赋值可以将数组中的值或对象的属性解压缩到不同的变量中了解更多信息：here
【讨论】：
arr[arr.length - 1] 肯定更好，因为它在大多数浏览器上更具可读性和快一个数量级。
var str = ["stackoverflow", "starlink"];
var last = str[str.length-1];//basically you are putting the last index value into the array and storing it in la
【讨论】：
可以通过length 属性获取最后一项。由于数组计数从 0 开始，您可以通过引用 array.length - 1 项来选择最后一项。
const arr = [1,2,3,4];
const last = arr[arr.length - 1];
console.log(last); // 4另一个选项是使用at 方法，它接受一个整数值并返回该索引处的项目。负整数从数组中的最后一项开始倒数，所以如果我们想要最后一项，我们可以传入-1
const arr = [1,2,3,4];
const last = arr.at(-1);
console.log(last); // 4【讨论】：
Proposal for Array.prototype.findLast 现在处于第 3 阶段！
你可以这样使用它：
const array = [1, 2, 3, 4, 5];
const last_element = array.findLast((item) => true);
console.log(last_element)【讨论】：
根据 ES2022，您可以使用 Array.at() 方法，该方法采用整数值并返回该索引处的项目。允许正整数和负整数。负整数从数组的最后一项开始倒数。
演示：
const href = 'www.abc.com/main/index.html';
const loc_array = href.split('/');
// To access elements from an array we can use Array.at()
console.log(loc_array.at(-1)); // This will return item at last index.【讨论】：