if (loc_array[loc_array.length - 1] === 'index.html') {// do something} else {// something else}

如果您的服务器为“index.html”和“inDEX.htML”提供相同的文件，您也可以使用：.toLowerCase()。

不过，如果可能的话，您可能需要考虑在服务器端执行此操作：它将更干净，并且适用于没有JS的人。

编辑-ES-2022

使用ES-2022#0，上面可以这样写：

if (loc_array.at(-1) === 'index.html') {// do something} else {// something else}

这个能行吗？

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

我宁愿使用array.pop()而不是索引。

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

通过这种方式，您始终可以获得index.html之前的元素（假设您的数组已将index.html隔离为一个项目）。

如果一个人想一次性获得最后一个元素，他/她可以使用#0：

lastElement = document.location.href.split('/').splice(-1,1);

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

注意：这将更改原始数组通过删除其最后一个元素。将splice(-1,1)视为弹出最后一个元素的pop()函数。

使用Array.pop：

var lastItem = anArray.pop();

重要：返回数组中的最后一个元素和删除

不确定是否有缺点，但这似乎很简洁：

arr.slice(-1)[0]

或

arr.slice(-1).pop()

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

对于那些不怕重载Array原型的人（对于枚举掩蔽你不应该）：

Object.defineProperty( Array.prototype, "getLast", {enumerable: false,configurable: false,writable: false,value: function() {return this[ this.length - 1 ];}} );

更短版本的@chaiGuy发布：

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

读取-1索引已经返回undefined。

编辑：

如今，首选项似乎是使用模块并避免接触原型或使用全局命名空间。

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

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

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

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

使用pop（）会改变你的数组，这并不总是一个好主意。

jQuery巧妙地解决了这个问题：

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

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

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

对我来说，这比loc_array.slice(-1)[0]更具语义

两种选择是：

var last = arr[arr.length - 1]

或

var last = arr.slice(-1)[0]

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

http://jsperf.com/slice-vs-length-1-arr

const lastElement = myArray[myArray.length - 1];

从性能的角度来看，这是最好的选择（比arr.slice(-1)快1000倍）。

您可以向原型#0添加一个新的属性getter，以便可以通过Array的所有实例访问它。

Getters允许您访问函数的返回值，就像它是属性的值一样。函数的返回值当然是数组的最后一个值（this[this.length - 1]）。

最后，您将其包装在一个条件中，该条件检查last-属性是否仍然是undefined（未由可能依赖它的另一个脚本定义）。

Object.defineProperty(Array.prototype, 'last', {get : function() {return this[this.length - 1];}});
// Now you can access it like[1, 2, 3].last;            // => 3// orvar test = [50, 1000];alert(test.last);          // Says '1000'

在IE≤8中不起作用。

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

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 arraya.length; // returns 7

但是你可以使用这个，所以它在原始数组上有没有效果：

a.slice(-1).pop(); // will return "abc" won't do modify the array// because slice creates a new array objecta.length;          // returns 8; no modification and you've got you last element

您也可以在不从url中提取数组的情况下实现此问题

这是我的选择

var hasIndex = (document.location.href.search('index.html') === -1) ? doSomething() : doSomethingElse();

！问候

我认为对于初学者来说最容易理解和超级低效的方法是：😆

var array = ['fenerbahce','arsenal','milan'];var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]console.log(reversed_array[0]) // result is "milan".

您可以将last()函数添加到Array原型。

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

编辑：

您可以使用Symbol来避免与其他代码不兼容：

const last = Symbol('last');Array.prototype[last] = function() {return this[this.length - 1];};
console.log([0, 1][last]());

就我个人而言，我会赞成kuporifi/kritzikratzi的回答。如果您使用嵌套数组，数组[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]

使用降权：

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

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

const data = [1, 2, 3, 4]const [last] = [...data].reverse()console.log(last)

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

我建议创建helper函数并每次重用它，你会需要它。让函数更通用，不仅能够获取最后一项，还能够从最后一项中获取第二项，依此类推。

function last(arr, i) {var i = i || 0;return arr[arr.length - (1 + i)];}

用法很简单

var arr = [1,2,3,4,5];last(arr);    //5last(arr, 1); //4last(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)));

“最干净”的ES6方式（IMO）是：

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

这避免了突变foo，就像.pop()一样，如果我们不使用扩展运算符。
我也喜欢foo.slice(-1)[0]的解决方案。

还有一个npm模块，将last添加到Array.prototype

npm install array-prototype-last --save

使用

require('array-prototype-last');
[1, 2, 3].last; //=> 3
[].last; //=> undefined

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

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

使用Lodash_. Last（数组）获取数组的最后一个元素。

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>

您可以使用此模式…

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

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

这是干净和高效的：

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

小实用价值，发布以显示索引也可用于您的过滤逻辑。

编辑：

最近我又想出了一个解决方案，我现在认为最适合我的需求：

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（）实例。

这个问题已经存在很长时间了，所以我很惊讶没有人提到在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]的两倍慢，但你不必在任何一天都有价值的索引。

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

【方法】……………【ETU 5个elems】……【ETU100万elems】

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的比例。尽管如此，没有人喜欢占用资源。

在ECMAScript提案中阶段1建议添加一个返回最后一个元素的数组属性：最后一个提案列表。

语法：

arr.lastItem // get last itemarr.lastItem = 'value' // set last item
arr.lastIndex // get last index

您可以使用聚填充。

作者：Keith Cirkel（chai autor）

这里有更多的Javascript艺术，如果你来这里寻找它

在另一个使用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("."));

此方法不会弄乱您的原型。它还可以防止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];

当然，我们需要先检查以确保数组至少有一项。

这可以用Lodash#0或#1完成：

var data = [1, 2, 3, 4]var last = _.nth(data, -1)console.log(last)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

使用Ramda进行函数式编程

如果您使用的是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。列表怪物从（学习你一个Haskell）

像下面这样的东西怎么样：

if ('index.html' === array[array.length - 1]) {//do this} else {//do that}

如果使用下划线或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"

这可能是最糟糕的调试代码类型！

为了防止从原始数组中删除最后一项，您可以使用

Array.from(myArray).pop()

主要支持所有浏览器（ES6）

const [lastItem] = array.slice(-1);

Array.prototype.slice和-1可用于创建仅包含原始数组的最后一项的新数组，然后可以使用解构任务使用该新数组的第一项创建变量。

const lotteryNumbers = [12, 16, 4, 33, 41, 22];const [lastNumber] = lotteryNumbers.slice(-1);
console.log(lotteryNumbers.slice(-1));// => [22]console.log(lastNumber);// => 22

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

要使用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'

谢谢@陈志立指出这一点。

ES6对象解构是另一种方法。

const {length, [length-1]: last}=[1,2,3,4,5]console.log(last)

您使用对象解构从Array中提取长度属性。您使用[长度-1]已经提取的键创建另一个动态键并将其分配给最后，所有这些都在一行中。

我认为这应该工作得很好。

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

只需反转数组并获取第一个元素。

编辑：如下所述，原始数组将被颠倒。为避免这种情况，您可以将代码更改为：

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

这将创建原始数组的副本。

对于可读和简洁的解决方案，您可以使用#0和解构的组合。

const linkElement = document.getElementById("BackButton");const loc_array = document.location.href.split('/');
// assign the last three items of the array to separate variablesconst [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 indexparentSlug = thirdLast;}
const newT = document.createTextNode(unescape(capWords(parentSlug)));
linkElement.appendChild(newT);

但是为了简单地获取数组中的最后一项，我更喜欢这种表示法：

const [lastItem] = loc_array.slice(-1);

性能

今天2020.05.16我在MacO High Sierra v10.13.6Chromev81.0、Safariv13.1和Firefox v76.0上执行所选解决方案的测试

结论

• arr[arr.length-1]（D）被推荐为最快的跨浏览器解决方案
• 可变解arr.pop()（A）和不可变解_.last(arr)（L）是快速的
• 解I，J对于长弦来说是慢的
• 解决方案H，K（jQuery）在所有浏览器上最慢

详情

我测试两个案例的解决方案：

• 可变：一个，B，C，

• 不可变：D，E，F，g，H，我，J（我的），

• 外部库不可变：K，L，M，

对两个案件

• 短字符串-10个字符-您可以运行test这里
• 长字符串-1M字符-您可以运行test这里

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的示例结果

您可以使用#0的相对索引：

const myArray = [1, 2, 3]
console.log(myArray.at(-1))// => 3

简单的答案

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

Setter和Getter

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; //Setterelse 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文档，解构分析可以将数组中的值或对象中的属性解压为不同的变量

阅读更多：这里

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

另一种选择是使用新的Array.prototype.at()方法，它接受一个整数值并返回该索引处的项目。负整数从数组中的最后一项倒数，因此如果我们想要最后一项，我们可以传入-1

const arr = [1,2,3,4];const last = arr.at(-1);console.log(last); // 4

另一种选择是使用新的findLast方法。您可以看到提案这里

const arr = [1,2,3,4];const last = arr.findLast(x => true);console.log(last); // 4

另一种选择是使用Array.prototype.slice()方法，它将数组的一部分的浅表副本返回到新的数组对象中。

const arr = [1,2,3,4];const last = arr.slice(-1)[0];console.log(last); // 4

更新-27十月2021（Chrome97+）

提案Array.prototype.findLast现在是在阶段3！

以下是你如何使用它：

const array = [1, 2, 3, 4, 5];
const last_element = array.findLast((item) => true);console.log(last_element);

您可以在这篇V8博客文章中阅读更多内容。

你可以在“Chrome”系列中找到更多。

根据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.

要查找数组中的最后一个元素，请使用以下命令：

let arr = [1,2,3,4,5];
1) console.log(arr[arr.length-1])2) console.log(arr.slice(-1)[0])3) console.log(arr.findLast(x => true))4) console.log(arr.at(-1))many more...

~拉胡尔·达克什