1674

到目前为止,这是我的 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",如果是,则改为获取倒数第三项。

4

58 回答 58

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

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

不过,如果可能的话,你可能会考虑在服务器端做这个:它会更干净,并且适合没有 JS 的人。

于 2010-07-09T19:48:58.323 回答
1432

不确定是否有缺点,但这似乎很简洁:

arr.slice(-1)[0] 

或者

arr.slice(-1).pop()

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

于 2012-08-23T20:19:25.437 回答
369

使用Array.pop

var lastItem = anArray.pop();

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

于 2012-06-14T14:06:47.357 回答
200

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

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

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

编辑:

这些天来,偏好似乎是使用模块并避免接触原型或使用全局命名空间。

export function last(array) {
    return array[array.length - 1];
}
于 2012-10-01T15:08:54.500 回答
186

两个选项是:

var last = arr[arr.length - 1]

或者

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

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

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

于 2014-01-07T21:57:15.077 回答
102

表现

今天 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) 很快
  • 解决方案 I、J 对于长字符串来说很慢
  • 解决方案 H、K (jQuery) 在所有浏览器上最慢

在此处输入图像描述

细节

我测试了两种解决方案:

  • 可变:ABC

  • 不可变:DEFGHI、J(我的),

  • 从外部库不可变:KLM

两种情况

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

在此处输入图像描述

于 2020-05-16T15:50:08.390 回答
83

以下是如何在不影响原始 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 
于 2014-09-03T21:25:54.567 回答
60

“最干净”的 ES6 方式(IMO)将是:

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

如果我们不使用扩展运算符,foo这可以避免 mutating 。 也就是说,我也喜欢这个解决方案。.pop()
foo.slice(-1)[0]

于 2017-06-16T19:43:56.283 回答
52

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);
// => 22

于 2019-05-29T10:05:21.567 回答
52
const [y] = x.slice(-1)

快速说明

这种语法[y] = <array/object>称为解构赋值,根据 Mozilla 文档,解构赋值可以将数组中的值或对象中的属性解包为不同的变量

了解更多信息:这里

于 2021-03-28T22:43:42.150 回答
45

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

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

这样,您始终可以获取 index.html 之前的元素(前提是您的数组已将 index.html 隔离为一项)。注意:不过,您将丢失数组中的最后一个元素。

于 2012-02-24T18:39:05.850 回答
36
const lastElement = myArray[myArray.length - 1];

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

于 2014-06-18T12:33:58.200 回答
34

你可以使用这个模式...

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

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

于 2017-09-29T09:13:03.670 回答
34

您可以使用相对索引Array#at

const myArray = [1, 2, 3]

console.log(myArray.at(-1))
// => 3
于 2020-05-17T04:54:36.853 回答
30

如果一个人想一次性获得最后一个元素,他/她可以使用Array#splice()

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

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

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

于 2012-03-16T00:53:37.617 回答
30

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

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

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

使用 pop() 会改变你的数组,这并不总是一个好主意。

于 2013-02-12T09:13:42.147 回答
30

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

于 2019-09-06T13:55:23.507 回答
27

这个问题已经存在了很长时间,所以我很惊讶没有人提到在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]

[方法].......[ETU 5 elems]...[ETU 1 百万 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 的比率。尽管如此,没有人喜欢资源猪。

于 2018-08-09T09:33:41.153 回答
24

只是在这里放另一个选择。

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

我发现上述方法在网上更简洁、更简短。请随意尝试这个。

注意:它将修改原始数组,如果您不想修改它可以使用slice()

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

感谢@VinayPai指出这一点。

于 2019-11-05T09:57:48.983 回答
22

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

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

您可以使用对象解构从 Array 中提取长度属性。您使用已通过[length-1]提取的密钥创建另一个动态密钥,并将其分配给last,全部在一行中。

于 2020-03-09T17:24:38.457 回答
21

对于那些不怕重载 Array 原型(并且不应该使用枚举掩码)的人:

Object.defineProperty( Array.prototype, "getLast", {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        return this[ this.length - 1 ];
    }
} );
于 2012-09-02T17:32:36.900 回答
21

如果您来这里寻找它,这里有更多 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("."));
于 2018-09-16T00:08:13.897 回答
20

我通常使用underscorejs,你可以这样做

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

对我来说,这比loc_array.slice(-1)[0]

于 2014-01-07T17:40:59.667 回答
19

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

> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined
于 2013-05-21T10:28:51.833 回答
15

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

Array.from(myArray).pop()

大部分浏览器都支持 (ES6)

于 2019-05-14T12:09:57.177 回答
14

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

于 2018-08-30T19:31:08.830 回答
14

我认为这应该可以正常工作。

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

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

编辑:如下所述,原始数组将被反转。为避免这种情况,您可以将代码更改为:

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

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

于 2020-03-29T20:09:11.883 回答
12

无论你做什么不只是使用reverse()

一些答案提到reverse但没有提到reverse修改原始数组的事实,并且不(如在某些其他语言或框架中)返回副本。

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

这可能是最难调试的代码类型!

于 2019-04-14T09:13:26.530 回答
11

就个人而言,我会赞成 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]
于 2016-03-03T12:53:05.180 回答
10

您可以向原型添加一个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]());

于 2015-07-20T08:21:04.163 回答
9

您可以向 的原型添加一个新的属性获取器,以便可以通过.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'

不适用于 IE ≤ 8。

于 2014-07-06T19:27:27.280 回答
8

编辑:

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

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()。

于 2018-03-18T18:50:11.337 回答
6

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

var array = ['fenerbahce','arsenal','milan'];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".
于 2014-10-27T03:32:29.937 回答
6

我会建议创建辅助函数并每次重用它,你会需要它。让函数更通用,不仅可以获取最后一项,还可以获取倒数第二个等。

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)));
于 2017-04-20T10:59:01.543 回答
6

使用 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. 列出来自(Learn You a Haskell)的怪物

列出怪物

于 2018-12-31T15:01:15.677 回答
6

通常你不应该弄乱内置类型的原型,但这里有一个 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
于 2020-11-24T06:33:01.743 回答
5

使用 ES6/ES2015 扩展运算符 (...) 您可以执行以下操作。

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

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

于 2017-03-17T19:14:45.887 回答
5

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

于 2017-09-20T20:31:38.380 回答
5

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

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

如果使用UnderscoreLodash,您可以使用_.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 
}
于 2019-01-31T12:13:15.287 回答
4

这行得通吗?

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])));
}
于 2010-07-09T19:49:00.973 回答
4

这可以通过 lodash_.last_.nth:

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>

于 2018-11-22T06:26:20.513 回答
3

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

这是我的选择

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

!问候

于 2014-09-15T02:55:27.390 回答
3

这是干净有效的:

let list = [ 'a', 'b', 'c' ]

(xs => xs[xs.length - 1])(list)

如果你使用 Babel 安装一个管道操作符,它会变成:

list |> (xs => xs[xs.length - 1])
于 2017-12-11T10:05:03.510 回答
3

另一个ES6唯一的选择是使用Array.find(item, index)=> {...})如下:

const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);

实用价值不大,张贴以表明索引也可用于您的过滤逻辑。

于 2018-01-14T19:32:50.947 回答
3

这种方法不会弄乱你的原型。它还可以防止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'))

于 2018-10-27T22:46:27.257 回答
3

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; //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' ] ] ]
于 2020-10-25T06:50:24.207 回答
3

可以通过该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

于 2022-01-14T20:41:10.547 回答
3

更新 - 2021 年 10 月 27 日(Chrome 97+)

提案Array.prototype.findLast现在处于第 3 阶段!

以下是您可以使用它的方法:

const array = [1, 2, 3, 4, 5];

const last_element = array.findLast((item) => true);
console.log(last_element);

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

您可以在“Chrome 中的新功能”系列中找到更多信息。

于 2022-01-31T13:42:31.877 回答
2

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

var lastItem = (a => a[a.length - 1])(loc_array);
于 2017-08-03T00:24:44.623 回答
2
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
于 2021-04-07T01:14:53.410 回答
2

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

于 2022-02-23T18:07:04.830 回答
1

还有一个 npm 模块,添加lastArray.prototype

npm install array-prototype-last --save

用法

require('array-prototype-last');

[1, 2, 3].last; //=> 3 

[].last; //=> undefined 
于 2017-07-28T06:05:28.573 回答
1

对于可读且简洁的解决方案,您可以使用Array.prototype.slicedestructuring的组合。

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);
于 2020-04-11T12:44:35.033 回答
0

使用reduceRight

[3,2,1,5].reduceRight((a,v) => a ? a : v);
于 2016-04-04T12:04:53.120 回答
0

简单的答案

const array = [1,2,3]
array[array.length - 1]
于 2020-08-14T18:48:57.593 回答
-1

获取数组最后一项的简单方法:

var last_item = loc_array.reverse()[0];

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

于 2018-11-22T02:28:43.280 回答
-3

要使用 c# 访问数组中的最后一个元素,我们可以使用 GetUpperBound(0)

(0) 如果这个一维数组

my_array[my_array.GetUpperBound(0)] //this is the last element in this one dim array
于 2019-10-25T03:52:07.587 回答
-6
array.reverse()[0]

就是这么简单

于 2019-07-31T08:41:55.043 回答