解构以获取 es6中数组的最后一个元素

在咖啡手稿中，这一点很简单:

coffee> a = ['a', 'b', 'program']
[ 'a', 'b', 'program' ]
coffee> [_..., b] = a
[ 'a', 'b', 'program' ]
coffee> b
'program'

Es6允许类似的东西吗？

> const [, b] = [1, 2, 3]
'use strict'
> b  // it got the second element, not the last one!
2
> const [...butLast, last] = [1, 2, 3]
SyntaxError: repl: Unexpected token (1:17)
> 1 | const [...butLast, last] = [1, 2, 3]
|                  ^
at Parser.pp.raise (C:\Users\user\AppData\Roaming\npm\node_modules\babel\node_modules\babel-core\node_modules\babylon\lib\parser\location.js:24:13)

当然，我可以做到这一点，es5的方式-

const a = b[b.length - 1]

但是，这可能有点容易因为一个错误而出错。股市崩盘只会是破产过程中的最后一件事吗？

141948 次浏览
小开
最佳答案

这在 ES6/2015中是不可能的，因为标准并没有对此做出规定。

正如你在 说明书中看到的，FormalParameterList可以是:

  • FunctionRestParameter
  • 一个 FormalsList(参数列表)
  • 先是 FormalsList然后是 FunctionRestParameter

不提供后跟参数的 FunctionRestParameter。

小开

我相信 ES6至少可以帮助解决这个问题:

[...arr].pop()

假设您的数组(arr)不是未定义的，并且是可迭代的元素(是的，甚至字符串也可以工作! !)，它应该返回最后一个元素。.即使对于空数组，它也不会改变它。但它创建了一个中间数组。.但这应该不会花费太多。

你的例子会是这样的:

  console.log(  [...['a', 'b', 'program']].pop() );

小开

您可以解构反向数组以接近您想要的结构。

const [a, ...rest] = ['a', 'b', 'program'].reverse();
  

document.body.innerHTML =
"<pre>"
+ "a: " + JSON.stringify(a) + "\n\n"
+ "rest: " + JSON.stringify(rest.reverse())
+ "</pre>";

小开 

console.log('last', [1, 3, 4, 5].slice(-1));
console.log('second_to_last', [1, 3, 4, 5].slice(-2));

小开

不一定是最有效的方式，但根据具体情况，一种相当优雅的方式是:

const myArray = ['one', 'two', 'three'];
const theOneIWant = [...myArray].pop();


console.log(theOneIWant); // 'three'
console.log(myArray.length); //3

小开

这应该会奏效:

const [lastone] = myArray.slice(-1);
小开 

const arr = ['a', 'b', 'c']; // => [ 'a', 'b', 'c' ]


const {
[arr.length - 1]: last
} = arr;


console.log(last); // => 'c'

小开

另一种方法是:

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

小开

毫无疑问，问题是关于用于 JavaScript 数组的 解体，我们知道通过使用解构赋值不可能得到 Array 的最后一项，有一种方法可以做到 永恒不变，参见下面的代码:

const arr = ['a', 'b', 'c', 'last'];


~~~
const arrLength = arr.length - 1;


const allExceptTheLast = arr.filter( (_, index) => index !== arrLength );
const [ theLastItem ] = arr.filter( (_, index) => index === arrLength );

我们不对 arr变量进行变异，但仍然将除最后一个项目之外的所有数组成员作为数组，并将最后一个项目单独存在。

小开 
let a = [1,2,3]
let [b] = [...a].reverse()
小开

不破坏方式，但可以帮助。根据 javascript 文档和反向方法可以尝试这样:

const reversed = array1.reverse();
let last_item = reversed[0]
小开

使用数组解构: “捕获”array、“ spliced”数组(arrMinusEnd)和“ poped”/“ sliced”元素(endItem)。

var [array, arrMinusEnd, endItem] =
["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]
.reduce(
(acc, cv, idx, arr) => {
if(idx<arr.length-1) acc[1].push(cv);
else {
acc[0]=arr;
acc[2]=cv;
};
return acc;
},
[null,[],[]]
)
;


console.log("array=");
console.log(array);
console.log("arrMinusEnd=");
console.log(arrMinusEnd);
console.log("endItem=\""+endItem+"\"");
.as-console-wrapper { max-height: 100% !important; top: 0; }

小开

获取数组的最后一个元素:

const [last,] = ['a', 'b', 'program'].reverse();
小开

您可以进一步破坏数组的 ...rest数组作为 Object，以获得其 length支撑，并为最后一个索引构建一个 计算道具名称计算道具名称。

这甚至适用于参数破坏:

const a = [1, 2, 3, 4];


// Destruct from array ---------------------------
const [A_first, ...{length: l, [l - 1]: A_Last}] = a;
console.log('A: first: %o; last: %o', A_first, A_Last);     // A: first: 1; last: 4


// Destruct from fn param(s) ---------------------
const fn = ([B_first, ...{length: l, [l - 1]: B_Last}]) => {
console.log('B: first: %o; last: %o', B_first, B_Last);   // B: first: 1; last: 4
};


fn(a);

小开

您可以尝试使用应用于数组的对象 解体来提取 length，然后获取最后一项: 例如:

const { length, 0: first, [length - 1]: last } = ['a', 'b', 'c', 'd']


// length = 4
// first = 'a'
// last = 'd'

更新

另一个方法 Array.prototype.at

At ()方法接受一个整数值并返回该索引处的项，允许正整数和负整数..。

const last = ['a', 'b', 'c', 'd'].at(-1)
// 'd'
小开

这是我能想到的最简单易懂的方法:

    const first = [...arr];
const last = first.pop();
const others = first.join(', ');

提交答案