Question

在coffeescript中，这很简单：

codetools

es6是否允许类似的东西？

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

当然我可以用es5方式做到 -

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

但也许这有点容易因一个错误而消失。 splat只能是解构中的最后一件事吗？

Answer 1

const [last] = [1, 3, 4, 5].slice(-1)
const [second_to_last] = [1, 3, 4, 5].slice(-2)

Answer 2

在ES6 / 2015中无法实现。该标准并没有提供它。

正如您在the spec中所看到的，FormalParameterList可以是：

a FunctionRestParameter
a FormalsList（参数列表）
一个FormalsList，然后是FunctionRestParameter

未提供FunctionRestParameter后跟参数。

Answer 3

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

[...arr].pop()

鉴于你的数组（arr）没有未定义和一个可迭代的元素（是的，甚至字符串工作!!），它应该返回最后一个元素..对于空数组，它也不会改变它。它创建了一个中间数组，但不应该花费太多。

您的示例将如下所示：

[...['a', 'b', 'program']].pop() -> 'program'

Answer 4

你可以对反转的数组进行解构以接近你想要的结果。

＆＃13;

const [a, ...rest] = ['a', 'b', 'program'].reverse();
  
document.body.innerHTML = 
    "<pre>"
    + "a: " + JSON.stringify(a) + "\n\n"
    + "rest: " + JSON.stringify(rest.reverse())
    + "</pre>";

＆＃13;

Answer 5

另一种方法是：

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

Answer 6

不一定是最有效的方式。但根据具体情况，一个非常优雅的方式是：

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

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

Answer 7

没有破坏性的方式，但可以提供帮助。根据javascript文档和反向方法，可以尝试以下方法：

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

Answer 8

我的建议是：

const [last] = [1,2,3,4,5].slice(-1)
console.log(last)

或第一个和最后一个：

const [first, last] = [...a.slice(0,1), ...a.slice(-1)]

Answer 9

这应该有效：

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

Answer 10

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

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

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

Answer 11

您可以尝试此技巧：

import React from 'react';
import ReactDOM from 'react-dom';
import expect from 'expect';
import TestRegisterPage from '../components/RegisterPage';
import { App } from '../App';
import { configure } from 'enzyme';
import { Link } from 'react-router-dom';
import { MemoryRouter } from 'react-router'
import Adapter from 'enzyme-adapter-react-16';
import { mount, shallow } from 'enzyme';
import { PropTypes } from 'prop-types';
import renderer from 'react-test-renderer';
import {spy} from 'sinon';
import { Provider } from 'react-redux';
import { store } from '../helpers';
import configureStore from 'redux-mock-store';

const middlewares = [];
const mockStore = configureStore(middlewares);
configure({ adapter: new Adapter() });
let mockedStore = mockStore({});
export const CustomProvider = ({ children }) => {
  return (
    <Provider store={store}>
      <MemoryRouter>
        {children}
      </MemoryRouter>
    </Provider>
  );
};

describe("Test RegisterPage component", () => {
  it('check route, dispatch and store setup for component', () => {
    const wrapper = mount(
      <CustomProvider>
        <TestRegisterPage dispatch={spy()} />
      </CustomProvider>
      {
        context: {store: mockedStore},
        childContextTypes: {store: PropTypes.object.isRequired}
      }
    );

    const inst = wrapper.children();
    let uname = inst.find('.username');
    let pwd = inst.find('.password');
    uname.simulate('change', { target: { value: "demo_username" } });
    pwd.simulate('change', { target: { value: "demo_password" } });
    wrapper.update();
    expect(wrapper).toBeTruthy();
  });
});

Answer 12

当然，这个问题是关于JavaScript数组的Destructuring，而且我们知道无法通过使用解构分配获得数组的最后一项，有一种方法可以做到不可变，请参见以下内容：

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变量进行突变，但除最后一项外，其余所有数组成员均作为数组，并且最后一项单独存在。

Answer 13

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

Answer 14

使用数组解构：“捕获” array，“ splice d”数组（arrMinusEnd）和“ pop ed” /“ slice d”元素（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; }

Answer 15

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

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

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

15 个答案: