Javascript 获取数组中的最后一项

以下是我迄今为止的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的人工作。

---

我宁愿使用

array.pop（）

而不是索引。

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

---

这样，您总是将元素放在index.html之前（前提是您的数组将index.html作为一项隔离）注意：您将丢失阵列中的最后一个元素。

如果希望一次性获得最后一个元素，他/她可以使用：

在这里，不需要将分割的元素存储在数组中，然后获取最后一个元素。如果获取最后一个元素是唯一的目标，那么应该使用它

注意：此操作通过删除原始数组的最后一个元素来更改原始数组。将

splice（-1,1）

视为弹出最后一个元素的

pop（）

函数。

使用：

---

重要：返回最后一个元素，并将其从数组中删除

不确定是否有缺陷，但这看起来相当简洁：

arr.slice(-1)[0] 

或

---

如果数组为空，则两者都将返回

undefined

对于那些不怕让阵列原型过载的人（你不应该这样做）：

---

@chaiguy发布内容的简短版本：

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

读取-1索引将返回未定义的

编辑：

如今，人们倾向于使用模块，避免接触原型或使用全局名称空间

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

---

通过使用带负值的切片方法可以获取数组的最后一项

你可以在底部阅读更多关于它的信息

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

使用pop（）将更改数组，这并不总是一个好主意。

巧妙地解决了这一问题：

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

我一般用，用它你就可以了

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

对我来说，这比

loc\u array.slice（-1）[0]

更具语义，有两个选项：

var last = arr[arr.length - 1]

或

前者更快，但后者看起来更好

---

从性能角度来看，这是最好的选择（

arr.slice（-1）

）快约1000倍）。下面介绍如何在不影响原始阵列的情况下获得它

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 

您可以将

last（）

函数添加到

Array

原型中

Array.prototype.last = function () {
    return this[this.length - 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]

“最清洁”的ES6方式（IMO）是：

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

这避免了变异

foo

，因为如果我们不使用扩展运算符，

.pop（）

会发生变异。

---

也就是说，我也喜欢

foo.slice（-1）[0]

解决方案。

您可以使用此模式

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

---

虽然它读起来相当不错，但请记住，它创建了一个新的数组，因此它的效率低于其他解决方案，但它几乎永远不会成为应用程序的性能瓶颈。

这个问题已经存在很长时间了，所以我很惊讶没有人提到在

pop（）

之后重新启用最后一个元素

arr.pop（）

因此，您可以逃脱：

---已编辑[在按下前检查
页面是否
未定义]---

---结束编辑---

可以降低到这个速度（相同的速度[编辑：但不安全]）：

这是
arr[arr.length-1]
的两倍，但您不必到处填充索引。这在任何一天都值黄金

在我尝试过的解决方案中，以执行时间单位（ETU）的倍数
arr[arr.length-1]
：

[方法]………[ETU 5个元素]…[ETU 100万个元素]
最后三个选项，尤其是
[…arr].pop（）
，会随着数组大小的增加而变得非常糟糕。在没有我的机器内存限制的机器上，
[…arr].pop（）
可能保持120:1的比例。不过，没有人喜欢资源猪。
有人建议添加一个将返回最后一个元素的数组属性：

语法：

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

arr.lastIndex // get last index

你可以用

提案作者：（autor）
如果您来这里寻找，这里有更多的Javascript艺术
根据另一个使用了
reduceRight（）
，但较短的答案的精神：

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

这取决于这样一个事实：如果您不提供初始值，那么最后一个元素将被选择为初始元素（检查文档）。由于回调只会不断返回初始值，最后一个元素将是最终返回的元素

请注意，这应该被视为Javascript艺术，决不是我推荐的方式，主要是因为它在O（n）时间内运行，但也因为它损害了可读性

现在是严肃的回答
我认为最好的方法（考虑到您希望它比
数组[array.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("."));

无论您做什么，都不要只使用
reverse（）
！！！
一些答案
let [last] = arr.slice(-1);

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

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

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.lastItem // get last item
arr.lastItem = 'value' // set last item

arr.lastIndex // get last index

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

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

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

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

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

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

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

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

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

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