获取数组中的最后一项

Question

到目前为止，这是我的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”，如果是这样，请抓住第三项到最后一项。

Answer 1

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

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

尽管如此，如果可能的话，你可能会考虑做这个服务器端：它会更干净，适用于没有JS的人。

Answer 2

不确定是否有缺点，但这看起来非常简洁：

arr.slice(-1)[0] 

或

arr.slice(-1).pop()

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

Answer 3

使用Array.pop：

var lastItem = anArray.pop();

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

Answer 4

@chaiguy发布的缩短版本：

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

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

修改

现在，偏好似乎是使用模块并避免触及原型或使用全局命名空间。

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

Answer 5

有两个选项：

var last = arr[arr.length - 1]

或

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

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

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

Answer 6

以下是如何使它对原始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 

Answer 7

＆＃34;最干净＆＃34; ES6方式（IMO）将是：

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

如果我们没有使用点差运算符，这可以避免像foo那样变异.pop()。
也就是说，我也喜欢foo.slice(-1)[0]解决方案。

Answer 8

性能

今天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）在所有浏览器中最慢

详细信息

我测试了两种情况的解决方案：

• 可变：A， B， C，

• 不可变：D， E， F， G， H， I， J（我），

• 不能从外部库：K， L， M，

两种情况

• 短字符串-10个字符-您可以运行测试HERE
• 长字符串-1M个字符-您可以运行测试HERE

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的短字符串结果示例

Answer 9

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

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

通过这种方式，您始终可以获得index.html之前的元素（假设您的数组已将孤立的index.html作为一个项目）。 注意：但是，您将丢失数组中的最后一个元素。

Answer 10

使用带负值的切片方法可以获得数组的最后一项。

您可以在底部详细了解here。

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

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

Answer 11

我认为，如果只希望获取元素而不删除它，则更简单：

arr.slice(-1)[0]

注意：如果数组为空（例如[]），它将返回undefined。

顺便说一句...我没有检查性能，但是我认为编写起来更简单，更干净

Answer 12

您可以使用此模式...

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

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

Answer 13

TL;DR

const [y] = x.slice(-1)

<块引用>

说明：
这种看起来很有趣的语法 [y] = <array-or-an-object> 实际上被称为 Destructuring assignment & 根据 Mozilla 文档

"解构赋值语法是一个 JavaScript 表达式 可以从数组中解压缩值，或从 对象，变成不同的变量"

阅读更多相关信息here

Answer 14

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

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

这里，不需要将split元素存储在数组中，然后到达最后一个元素。如果获得最后一个元素是唯一的目标，那么应该使用它。

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

Answer 15

对于那些不怕重载数组原型的人（以及使用enumeration masking你不应该）：

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

Answer 16

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

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

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

Answer 17

我通常使用underscorejs，你只需要做

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

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

更具语义性

Answer 18

jQuery整齐地解决了这个问题：

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

Answer 19

这个问题已经存在很长时间了，所以令我惊讶的是，没有人提到在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]的两倍，但是您不必费力地使用索引。在任何一天都值得黄金。

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

[方法] .............. [ETU 5个元素] ... [ETU 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的比率。尽管如此，没有人喜欢资源消耗。

Answer 20

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

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

Answer 21

就个人而言，我会通过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]

Answer 22

您可以向last()原型添加Array功能。

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

Answer 23

已编辑：

最近我提出了另一个解决方案，我现在认为这是最符合我需求的解决方案：

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

Answer 24

只需在此处放置另一个选项即可。

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

我发现上述方法更加简洁明了。请随意尝试一下。

注意：它将修改原始数组

感谢@VinayPai指出这一点。

Answer 25

尚未实现！

新的TC39 Array.prototype.lastItem proposal（第1阶段）添加了一个吸气剂，该吸气剂返回数组中的最后一项：

const myArray = [1, 2, 3]

console.log(myArray.lastItem)
//=> 3

Array.prototype.item proposal（第3阶段）添加了其他API：

const myArray = [1, 2, 3]

console.log(myArray.item(-1))
//=> 3

Answer 26

您可以向property getter添加新的prototype of Array，以便Array的所有实例都可以访问它。

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

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

if(typeof Array.prototype.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
// or
var test = [50, 1000];
alert(test.last);          // Says '1000'

Does not work in IE ≤ 8.

Answer 27

在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)
console.log(arr.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);

Answer 28

如果您是来这里寻找的，则是更多的Javascript艺术

本着另一个使用reduceRight()，但更简短的答案的精神：

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

它基于这样一个事实，如果您不提供初始值，则会选择最后一个元素作为初始值（请检查文档here）。由于回调只是不断返回初始值，因此最后一个元素将是最后返回的元素。

请注意，这应该被视为 Javascript art ，绝不是我建议这样做的方法，主要是因为它运行时间为O（n），而且还损害了可读性。 / p>

现在是认真的答案

我看到的最好方式（考虑到您希望它比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]

gh。

例如，在这种情况下，您有一个匿名数组，必须定义一个变量，但是可以改用last()：

last("1.2.3".split("."));

Answer 29

我认为这应该很好。

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

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

Answer 30

我建议创建帮助函数并每次重用它，你需要它。让我们的功能更加通用，不仅可以获得最后一项，还可以获得最后一项，等等。

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中的最后一项是＆＃34; index.html＆＃34;抓住第三个到最后一个项目。

下一行完成工作

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

Answer 31

我认为最简单，效率最低的方法是：

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

Answer 32

In ECMAScript proposal Stage 1，建议添加一个数组属性，该属性将返回最后一个元素：proposal-array-last。

语法：

arr.lastItem // get last item
arr.lastItem = 'value' // set last item

arr.lastIndex // get last index

您可以使用polyfill。

提案作者：Keith Cirkel（chai导师）

Answer 33

使用lodash _.last(array)获取数组的最后一个元素。

＆＃13;

＆＃13;

.env.testing

＆＃13;

data = [1,2,3]
last = _.last(data)
console.log(last)

＆＃13;

＆＃13;

＆＃13;

Answer 34

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

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

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

Answer 35

类似以下内容：

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 
}

Answer 36

更新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

Answer 37

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

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

实用价值很小，贴出来表明索引也适用于您的过滤逻辑。

Answer 38

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

Answer 39

您也可以在不从网址

中提取数组的情况下解决此问题

这是我的替代

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

！Greetings¡

Answer 40

使用ES6 / ES2015传播操作符（...），您可以按照以下方式进行操作。

＆＃13;

＆＃13;

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

＆＃13;

＆＃13;

＆＃13;

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

Answer 41

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

Answer 42

这是干净而有效的：

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

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

如果使用Babel安装管道运算符，它将变为：

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

Answer 43

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

Answer 44

无论您做什么都不使用usernames = [x["username"] for x in user_list] !!!

一些答案​​提到了reverse()，但没有提到reverse修改了原始数组，并且没有（像其他语言或框架一样）返回副本的事实。

reverse

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

Answer 45

通常，您不应该搞砸内置类型的原型，但这是一个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版本可以使用的属性，例如lastItem，但这由开发人员决定。

Answer 46

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

npm install array-prototype-last --save

使用

require('array-prototype-last');

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

[].last; //=> undefined 

Answer 47

arrow function通过不重复数组的名称，使表现最快的方法更简洁。

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

Answer 48

要获得简洁明了的解决方案，可以结合使用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);

Answer 49

带有-1的

Array.prototype.slice可用于创建仅包含原始数组的最后一项的新数组，然后可以使用Destructuring Assignment使用该新数组的第一项来创建变量

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

console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22

Answer 50

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

Array.from(myArray).pop()

所有浏览器（ES6）最受支持

Answer 51

简单答案

const array = [1,2,3]
array[array.length - 1]

Answer 52

使用reduceRight：

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

Answer 53

这是一个干净的原型扩展，可以简单实现Aaron Harun的答案：

(base) C:\Projects\Python\Tutorial>print(msg)
Unable to initialize device PRN

定义原型后，现在可以使用：

Array.prototype.i = function(val){
    if (val < 0) return this[this.length - Math.abs(val)]
    return this[val]
}

Answer 54

这会有用吗？

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

Answer 55

array.reverse()[0]

那很简单

Answer 56

要使用c＃访问数组中的最后一个元素，我们可以使用GetUpperBound（0）

（0），以防出现该一维数组

my_array[my_array.GetUpperBound(0)] //this is the last element in this one dim array

Answer 57

使用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。 List monster from (Learn You a Haskell)