Руйнування для отримання останнього елемента масиву в 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]

Але, можливо, це трохи схильне однією помилкою. Чи може бризка бути лише останньою справою у руйнуванні?

Це неможливо в ES6 / 2015. Стандарт просто не передбачає цього.

Як ви бачите у специфікації , це FormalParameterListможе бути:

• а FunctionRestParameter
• a FormalsList(список параметрів)
• a FormalsList, а за ним aFunctionRestParameter

Після 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>";

інший підхід:

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

Не обов'язково найефективніший спосіб виконання. Але залежно від контексту досить елегантним буде:

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

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

Це має працювати:

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

Ви можете спробувати цей злом:

let a = ['a', 'b', 'program'];
let [last] = a.reverse();
a.reverse();
console.log(last);

Безумовно, питання стосується деструктуризації для масивів JavaScript, і ми знаємо, що не можна мати останній елемент масиву, використовуючи завдання деструктування, є спосіб зробити це непорушним , див. Наступне:

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

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

const allExceptTheLast = arr.filter( (dep, index) => index !== arrDepth && dep );
const [ theLastItem ] = arr.filter( (dep, index) => index === arrDepth && dep );

Ми не мутуємо arrзмінну, але все ж маємо всі члени масиву, крім останнього елемента, як масив, а останній елемент є окремо.

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

Не руйнує шлях, але може допомогти. Відповідно до документації javascript та зворотного методу можна спробувати це:

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