箭头函数通过不重复数组的名称，使执行速度最快的方法更加简洁。

var lastItem = (a => a[a.length - 1])(loc_array);

为了获得一个可读且简洁的解决方案，可以使用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);

以下是如何在不影响原始阵列的情况下获得它

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 

可以通过长度属性获取最后一项。由于数组计数从0开始，因此可以通过引用array.length-1项来拾取最后一项

常量arr=[1,2,3,4]；常量last=arr[arr.length-1]；console.log（最后一个）；//4.

另一个选项是使用新的Array.prototype.at（）方法，该方法接受一个整数值并返回该索引处的项。负整数从数组中的最后一项开始倒数，所以如果我们想要最后一项，我们只需传入-1

常量arr=[1,2,3,4]；常量last=arr.at（-1）；console.log（最后一个）；//4.

另一个选项是使用新的findLast方法。你可以在这里看到提案

常量arr=[1,2,3,4]；const last=arr.findLast（x=>true）；console.log（最后一个）；//4.

另一个选项是使用Array.prototype.slice（）方法，该方法将数组的一部分的浅拷贝返回到新的数组对象中。

常量arr=[1,2,3,4]；常量last=arr.slice（-1）[0]；console.log（最后一个）；//4.

这个问题已经存在了很长一段时间，所以我很惊讶没有人提到在pop（）之后重新打开最后一个元素。

arr.pop（）的效率与arr[arr.length-1]完全相同，两者的速度都与arr.push（）相同。

因此，您可以避免：

---已编辑[在推送前检查顶部是否未定义]---

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）的倍数表示：

[方法]。。。。。。。。。。。。。。[ETU 5元素]。。。[ETU 100万元]

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的比率。然而，没有人喜欢资源猪。

2020年更新

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