我建议您创建助手函数，并在每次需要时重用它。让我们让函数更通用，以便不仅可以获取最后一项，还可以获取倒数第二项，依此类推。

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)));

2022年ECMA

使用ECMA 2022，您可以在（）处获得一个新属性。要从数组或字符串中获取最后一个元素，可以在中使用负索引-1。[1,2,3].在（-1）处。https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at

如果您希望像arr.last这样更流畅地接收最后一项，则可以为数组对象定义自己的属性。

if（！Array.protocol.hasOwnProperty（“last”））{Object.defineProperty（Array.prototype，“last”{获取（）{返回此。在（-1）；}});}a=[1,2,3]；console.log（a.last）；

简单的回答

const array = [1,2,3]
array[array.length - 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' ] ] ]

这个问题已经存在了很长一段时间，所以我很惊讶没有人提到在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的比率。然而，没有人喜欢资源猪。

使用ES6/ES2015排列运算符（…），可以执行以下操作。

常量数据=[1，2，3，4]const[last]=[…data].reverse（）console.log（最后一个）

请注意，使用扩展运算符和反转，我们没有对原始数组进行变异，这是获取数组最后一个元素的纯方法。