获取数组中的最后一项-Java 学习之路

777

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

30 回答

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

npm install array-prototype-last --save

用法

require('array-prototype-last');

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

[].last; //=> undefined

回复于 2024-05-03T18:21:19+08:00

2
您可以将 last() 函数添加到 Array 原型中 .
```
Array.prototype.last = function () {
    return this[this.length - 1];
};
```
回复于 2024-05-03T18:21:19+08:00

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

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

回复于 2024-05-03T18:21:19+08:00

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

回复于 2024-05-03T18:21:19+08:00

1
```
if(loc_array[loc_array.length-1] == 'index.html'){
 //do something
}else{
 //something else.
}
```
如果您的服务器为"index.html"和"inDEX.htML"提供相同的文件，您也可以使用： .toLowerCase() .

但是，如果可能的话，你可能想考虑做这个服务器端：它会更干净，适用于没有JS的人 .
回复于 2024-05-03T18:21:19+08:00
669
“最干净”的ES6方式（IMO）将是：
```
const foo = [1,2,3,4];
const bar = [...foo].pop();
```
如果我们没有使用扩展运算符，这可以避免像 .pop() 那样改变 foo .
那就是说，我也喜欢 foo.slice(-1)[0] 解决方案 .
回复于 2024-05-03T18:21:19+08:00

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

回复于 2024-05-03T18:21:19+08:00

8
```
const lastElement = myArray[myArray.length - 1];
```
从性能的角度来看，这是最好的选择（比arr.slice（-1）快〜1000倍） .
回复于 2024-05-03T18:21:19+08:00
2
您可以将新的property getter添加到prototype of Array，以便可以通过 Array 的所有实例访问它 .

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

最后，将其包装在检查 last -property是否仍为 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.
回复于 2024-05-03T18:21:19+08:00
7
你可以使用这种模式......
```
let [last] = arr.slice(-1);
```
虽然它读起来相当不错，但请记住它会创建一个新数组，因此它几乎永远不会成为应用程序的性能瓶颈 .
回复于 2024-05-03T18:21:19+08:00
27
两个选项是：
```
var last = arr[arr.length - 1]
```
要么
```
var last = arr.slice(-1)[0]
```
前者更快，但后者看起来更好

http://jsperf.com/slice-vs-length-1-arr
回复于 2024-05-03T18:21:19+08:00
90
我想如果你只想获得没有删除的元素，更简单的是使用这个：
```
arr.slice(-1)
```
顺便说一下......我没有检查性能，但我觉得写起来更简单干净
回复于 2024-05-03T18:21:19+08:00
17
使用Array.pop：
```
var lastItem = anArray.pop();
```
Important ：这将返回最后一个元素，并从数组中返回 removes
回复于 2024-05-03T18:21:19+08:00
56
@chaiguy发布的简短版本：
```
Array.prototype.last = function() {
    return this[this.length - 1];
}
```
读取-1索引已经返回 undefined .

EDIT:

目前，偏好似乎是使用模块并避免触及原型或使用全局命名空间 .
```
export function last(array) {
    return array[array.length - 1];
}
```
回复于 2024-05-03T18:21:19+08:00
37
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 autor）
回复于 2024-05-03T18:21:19+08:00
18
使用ES6 / ES2015扩展运算符（...），您可以采用以下方式 .
```
const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)
```
请注意，使用扩展运算符和反向我们没有改变原始数组，这是获取数组的最后一个元素的纯粹方法 .
回复于 2024-05-03T18:21:19+08:00

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

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

现在，让我们解决原始问题

grab 最后一个项目表单数组的第二个 . 如果loc_array中的最后一项是“index.html”，请 grab 第三项到最后一项 .

下一行完成了这项工作

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

回复于 2024-05-03T18:21:19+08:00

6
不确定是否有缺点，但这似乎很简洁：
```
arr.slice(-1)[0]
```
要么
```
arr.slice(-1).pop()
```
如果数组为空，则两者都将返回 undefined .
回复于 2024-05-03T18:21:19+08:00
837
如果想要一次性获得最后一个元素，他/她可以使用Array#splice()：
```
lastElement = document.location.href.split('/').splice(-1,1);
```
这里，不需要将split元素存储在数组中，然后到达最后一个元素 . 如果获得最后一个元素是唯一的目标，那么应该使用它 .

注意： This changes the original array 删除其最后一个元素 . 将 splice(-1,1) 视为弹出最后一个元素的 pop() 函数 .
回复于 2024-05-03T18:21:19+08:00
34
您也可以在不从URL中提取数组的情况下实现此问题

这是我的选择
```
var hasIndex = (document.location.href.search('index.html') === -1) ? doSomething() : doSomethingElse();
```
！问候
回复于 2024-05-03T18:21:19+08:00
5
jQuery整齐地解决了这个问题：
```
> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined
```
回复于 2024-05-03T18:21:19+08:00
173
这是干净和有效的：
```
let list = [ 'a', 'b', 'c' ]

(xs => xs[xs.length - 1])(list)
```
如果使用Babel安装管道运算符，它将变为：
```
list |> (xs => xs[xs.length - 1])
```
回复于 2024-05-03T18:21:19+08:00
10
我宁愿使用 array.pop() 而不是索引 .
```
while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));
```
通过这种方式，您始终可以获得index.html之前的元素（假设您的数组已将孤立的index.html作为一个项目） . Note: 但是你将丢失数组中的最后一个元素 .
回复于 2024-05-03T18:21:19+08:00
3
我通常使用underscorejs，你可以这样做
```
if (_.last(loc_array) === 'index.html'){
  etc...
}
```
对我来说更多语义比 loc_array.slice(-1)[0]
回复于 2024-05-03T18:21:19+08:00

121

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

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

回复于 2024-05-03T18:21:19+08:00

18
通过使用带负值的 slice 方法可以获得数组的最后一项 .

您可以在底部阅读更多相关信息here .
```
var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
  //your code...
}
```
使用pop（）会改变你的数组，这并不总是一个好主意 .
回复于 2024-05-03T18:21:19+08:00
1
另一个 ES6 唯一的选择是使用 Array.find(item, index)=> {...}) ，如下所示：
```
const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);
```
实用 Value 很小，贴出来显示索引也可用于您的过滤逻辑 .
回复于 2024-05-03T18:21:19+08:00
13
EDITED:

最近我想出了一个我现在认为最符合我需求的解决方案：
```
function w (anArray)
{ return (
  { last() {return anArray [anArray.length - 1]
  }
}        );
```
有了上面的定义，我现在可以说：
```
let last = w ([1,2,3]).last();
console.log(last) ; // -> 3
```
名称 "w" 代表"wrapper" . 您可以看到如何在此包装器之外轻松添加除'last()'之外的更多方法 .

我说“最适合我的需求”，因为这允许我轻松地将任何其他类似的“辅助方法”添加到任何JavaScript内置类型 . 我想到的是Lisp的car（）和cdr（） .
回复于 2024-05-03T18:21:19+08:00

以下是如何获得它对原始ARRAY没有影响

a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements

如果你使用pop（），它将 modify your array

a.pop();  // will return "abc" AND REMOVES IT from the array 
a.length; // returns 7

但你可以使用它，所以它在原始数组上有 no effect ：

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

回复于 2024-05-03T18:21:19+08:00

1
这个问题已经存在了很长时间，所以我很惊讶没有人提到在 pop() 之后将最后一个元素重新打开 .

arr.pop() 与 arr[arr.length-1] 完全一样有效，并且两者的速度与 arr.push() 相同 .

因此，你可以逃脱：
```
let thePop = arr.pop()
arr.push(thePop)
```
这可以减少到这个（相同的速度）：
```
arr.push(thePop = arr.pop())
```
这是 arr[arr.length-1] 的两倍慢，但你在任何一天都不值得 .

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

[方法] .............. [ETU 5 elems] ... [ETU 100万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 :)
```
最后三个选项，ESPECIALLY [...arr].pop() ，随着阵列大小的增加而变得非常糟糕 . 在没有我的机器内存限制的机器上， [...arr].pop() 可能保持类似120：1的比例 . 不过，没有人喜欢资源匮乏 .
回复于 2024-05-03T18:21:19+08:00

获取数组中的最后一项

30 回答

[方法] .............. [ETU 5 elems] ... [ETU 100万elems]

相关问题