到目前为止，这是我的 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如果数组为空，两者都将返回。
@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]
前者更快，但后者看起来更好
今天 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 的情况下获得它
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这可以避免 mutating 。
也就是说，我也喜欢这个解决方案。.pop()foo.slice(-1)[0]
const [lastItem] = array.slice(-1);带有 -1 的Array.prototype.slice可用于创建仅包含原始 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);
// => 22const [y] = x.slice(-1)
快速说明：
这种语法
[y] = <array/object>称为解构赋值，根据 Mozilla 文档，解构赋值可以将数组中的值或对象中的属性解包为不同的变量了解更多信息：这里
我宁愿使用而array.pop()不是索引。
while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));
这样，您始终可以获取 index.html 之前的元素（前提是您的数组已将 index.html 隔离为一项）。注意：不过，您将丢失数组中的最后一个元素。
const lastElement = myArray[myArray.length - 1];
从性能的角度来看，这是最好的选择（比 快约 1000 倍arr.slice(-1)）。
你可以使用这个模式...
let [last] = arr.slice(-1);
虽然它读起来相当不错，但请记住它会创建一个新数组，因此它的效率低于其他解决方案，但它几乎永远不会成为应用程序的性能瓶颈。
您可以使用相对索引Array#at：
const myArray = [1, 2, 3]
console.log(myArray.at(-1))
// => 3
如果一个人想一次性获得最后一个元素，他/她可以使用Array#splice()：
lastElement = document.location.href.split('/').splice(-1,1);
在这里，不需要将拆分的元素存储在一个数组中，然后到达最后一个元素。如果获取最后一个元素是唯一的目标，则应该使用它。
注意：这会通过删除其最后一个元素来更改原始数组。将splice(-1,1)其视为pop()弹出最后一个元素的函数。
可以通过使用带负值的slice方法来获取数组的最后一项。
你可以在底部阅读更多关于它的信息。
var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
//your code...
}
使用 pop() 会改变你的数组，这并不总是一个好主意。
在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);这个问题已经存在了很长时间，所以我很惊讶没有人提到在pop().
arr.pop()与 完全一样有效arr[arr.length-1]，并且两者的速度都与 相同arr.push()。
因此，您可以摆脱：
---已编辑[在推送之前检查thePop是否]---undefined
let thePop = arr.pop()
thePop && arr.push(thePop)
---结束编辑---
可以减少到这个（相同的速度[编辑：但不安全！]）：
arr.push(thePop = arr.pop()) //Unsafe if arr empty
这比 慢两倍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 的比率。尽管如此，没有人喜欢资源猪。
只是在这里放另一个选择。
loc_array.splice(-1)[0] === 'index.html'
我发现上述方法在网上更简洁、更简短。请随意尝试这个。
注意：它将修改原始数组，如果您不想修改它可以使用slice()
loc_array.slice(-1)[0] === 'index.html'
感谢@VinayPai指出这一点。
ES6 对象解构是另一种方法。
const {length, [length-1]: last}=[1,2,3,4,5]
console.log(last)您可以使用对象解构从 Array 中提取长度属性。您使用已通过[length-1]提取的密钥创建另一个动态密钥，并将其分配给last，全部在一行中。
对于那些不怕重载 Array 原型（并且不应该使用枚举掩码）的人：
Object.defineProperty( Array.prototype, "getLast", {
enumerable: false,
configurable: false,
writable: false,
value: function() {
return this[ this.length - 1 ];
}
} );
本着使用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("."));
我通常使用underscorejs，你可以这样做
if (_.last(loc_array) === 'index.html'){
etc...
}
对我来说，这比loc_array.slice(-1)[0]
jQuery巧妙地解决了这个问题：
> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined
为了防止从原始数组中删除最后一项，您可以使用
Array.from(myArray).pop()
大部分浏览器都支持 (ES6)
在 ECMAScript 提案 阶段 1中，建议添加一个返回最后一个元素的数组属性：proposal-array-last。
句法：
arr.lastItem // get last item
arr.lastItem = 'value' // set last item
arr.lastIndex // get last index
您可以使用polyfill。
提案作者：Keith Cirkel ( chai autor)
我认为这应该可以正常工作。
var arr = [1, 2, 3];
var last_element = arr.reverse()[0];
只需反转数组并获取第一个元素。
编辑：如下所述，原始数组将被反转。为避免这种情况，您可以将代码更改为：
var arr = [1, 2, 3];
var last_element = arr.slice().reverse()[0];
这将创建原始数组的副本。
reverse()！一些答案提到reverse但没有提到reverse修改原始数组的事实，并且不（如在某些其他语言或框架中）返回副本。
var animals = ['dog', 'cat'];
animals.reverse()[0]
"cat"
animals.reverse()[0]
"dog"
animals.reverse()[1]
"dog"
animals.reverse()[1]
"cat"
这可能是最难调试的代码类型！
就个人而言，我会赞成 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];
};
编辑：
您可以使用 aSymbol来避免与其他代码不兼容：
const last = Symbol('last');
Array.prototype[last] = function() {
return this[this.length - 1];
};
console.log([0, 1][last]());您可以向 的原型添加一个新的属性获取器，以便可以通过.ArrayArray
Getter 允许您访问函数的返回值，就像访问属性的值一样。函数的返回值当然是数组的最后一个值（this[this.length - 1]）。
最后，您将其包装在一个条件中，该条件检查last-property 是否仍然存在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 内置类型。例如，想到的是 Lisp 的 car() 和 cdr()。
我认为对于初学者来说最容易理解和超级低效的方法是：
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)));
如果您使用的是 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. 列出来自（Learn You a Haskell）的怪物
通常你不应该弄乱内置类型的原型，但这里有一个 hack/快捷方式：
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
使用 ES6/ES2015 扩展运算符 (...) 您可以执行以下操作。
const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)请注意，使用扩展运算符和反向我们没有改变原始数组，这是获取数组最后一个元素的纯粹方法。
使用 lodash _.last(array)获取数组的最后一个元素。
data = [1,2,3]
last = _.last(data)
console.log(last)<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>像下面这样的东西怎么样：
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
}
这行得通吗？
if (loc_array.pop() == "index.html"){
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-3])));
}
else{
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2])));
}
您也可以在不从 url 中提取数组的情况下解决此问题
这是我的选择
var hasIndex = (document.location.href.search('index.html') === -1) ? doSomething() : doSomethingElse();
！问候
这是干净有效的：
let list = [ 'a', 'b', 'c' ]
(xs => xs[xs.length - 1])(list)
如果你使用 Babel 安装一个管道操作符，它会变成：
list |> (xs => xs[xs.length - 1])
另一个ES6唯一的选择是使用Array.find(item, index)=> {...})如下：
const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);
实用价值不大，张贴以表明索引也可用于您的过滤逻辑。
这种方法不会弄乱你的原型。它还可以防止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'))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' ] ] ]
可以通过该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提案Array.prototype.findLast现在处于第 3 阶段！
以下是您可以使用它的方法：
const array = [1, 2, 3, 4, 5];
const last_element = array.findLast((item) => true);
console.log(last_element);您可以在这篇 V8 博客文章中阅读更多内容。
您可以在“Chrome 中的新功能”系列中找到更多信息。
箭头函数通过不重复数组的名称，使执行速度最快的方法更加简洁。
var lastItem = (a => a[a.length - 1])(loc_array);
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
根据 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.还有一个 npm 模块，添加last到Array.prototype
npm install array-prototype-last --save
用法
require('array-prototype-last');
[1, 2, 3].last; //=> 3
[].last; //=> undefined
对于可读且简洁的解决方案，您可以使用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);
使用reduceRight：
[3,2,1,5].reduceRight((a,v) => a ? a : v);
简单的答案
const array = [1,2,3]
array[array.length - 1]
获取数组最后一项的简单方法：
var last_item = loc_array.reverse()[0];
当然，我们需要先检查以确保数组至少有一项。
要使用 c# 访问数组中的最后一个元素，我们可以使用 GetUpperBound(0)
(0) 如果这个一维数组
my_array[my_array.GetUpperBound(0)] //this is the last element in this one dim array
array.reverse()[0]
就是这么简单