Деструктуризация массива в JavaScript - PullRequest
0 голосов
/ 06 сентября 2018

У меня есть этот код в моем приложении vue-js:

methods: {
    onSubmit() {
      ApiService.post('auth/sign_in', {
        email: this.email,
        password: this.password,
      })
        .then((res) => {
          saveHeaderToCookie(res.headers);
          this.$router.push({ name: 'about' });
        })
        .catch((res) => {
          this.message = res.response.data.errors[0];
          this.msgStatus = true;
          this.msgType = 'error';
        });
    },
  }

Во время работы Es-lint .. Я получил сообщение об ошибке «Использовать деструктуризацию массива» (предпочтение-деструктурирование) на this.message = res.response.data.errors[0]; вэта линия.Что такое деструктуризация массива и как это сделать? Пожалуйста, дайте мне представление об этом.Я исследовал это, но не мог понять это

Ответы [ 5 ]

0 голосов
/ 27 сентября 2018

Разрушение - это метод извлечения нескольких значений из данных, хранящихся в (возможно, вложенных) объектах и ​​массивах. Он может быть использован в местах, которые получают данные или в качестве значения объектов. Мы рассмотрим несколько примеров использования деструктуризации:

Разрушение массива

Деструктуризация массива работает для всех повторяемых значений

const iterable = ['a', 'b'];
const [x, y] = iterable;
// x = 'a'; y = 'b'

Разрушение помогает при обработке возвращаемых значений

const [all, year, month, day] =
/^(\d\d\d\d)-(\d\d)-(\d\d)$/
.exec('2999-12-31');

Разрушение объекта

const obj = { first: 'Jane', last: 'Doe' };
const {first: f, last: l} = obj;
// f = 'Jane'; l = 'Doe'

// {prop} is short for {prop: prop}
const {first, last} = obj;
// first = 'Jane'; last = 'Doe'

Примеры использования Разрушение

// Variable declarations:
const [x] = ['a'];
let [x] = ['a'];
var [x] = ['a'];

// Assignments:
[x] = ['a'];

// Parameter definitions:
function f([x]) { ··· }
f(['a']);


// OR USE IT IN A FOR-OF loop



const arr = ['a', 'b'];
for (const [index, element] of arr.entries()) {
    console.log(index, element);
}
// Output:
// 0 a
// 1 b

Шаблоны для разрушения

В любой деструктуре участвуют две стороны

  1. Источник деструктурирования: данные, подлежащие деструктурированию, например, справа от задания деструктуризации.
  2. Destructuring Target: шаблон, используемый для разрушения. Например, левая сторона задания по деструктуризации.

Целью уничтожения является один из трех паттернов:

  1. Цель назначения: обычно цель назначения - это переменная. Но в деструктивном задании у вас есть больше возможностей (например, х)
  2. Шаблон объекта: части шаблона объекта являются свойствами, значения свойств снова являются шаблонами (рекурсивно) (например, {first: «pattern», last: «pattern»})
  3. Шаблон Array: части шаблона Array являются элементами, элементы снова являются шаблонами (например, [«pattern», «pattern»])

Это означает, что вы можете вкладывать шаблоны произвольно глубоко:

const obj = { a: [{ foo: 123, bar: 'abc' }, {}], b: true };
const { a: [{foo: f}] } = obj; // f = 123

** Как шаблоны получают доступ к внутренностям значений? **

Шаблоны объектов приводят к разрушению источников до объектов до доступа к свойствам. Это означает, что он работает с примитивными значениями. Приведение к объекту выполняется с помощью ToObject (), который преобразует примитивные значения в объекты-обертки и оставляет объекты без изменений. Undefined или Null выдаст ошибку типа при обнаружении. Может использовать пустой шаблон объекта, чтобы проверить, является ли значение принудительным для объекта, как показано здесь:

({} = [true, false]); // OK, Arrays are coercible to objects
({} = 'abc'); // OK, strings are coercible to objects

({} = undefined); // TypeError
({} = null); // TypeError

Деструктуризация массива использует итератор для доступа к элементам источника. Таким образом, вы можете использовать Array-destructure для любого итеративного значения.

Примеры:

// Strings are iterable:
const [x,...y] = 'abc'; // x='a'; y=['b', 'c']


// set value indices
const [x,y] = new Set(['a', 'b']); // x='a'; y='b’;

Значение является итеративным, если у него есть метод, ключом которого является symbol.iterator, который возвращает объект. Деструктуризация массива генерирует ошибку TypeError, если значение, которое нужно деструктурировать, не повторяется

Пример:

let x;
[x] = [true, false]; // OK, Arrays are iterable
[x] = 'abc'; // OK, strings are iterable
[x] = { * [Symbol.iterator]() { yield 1 } }; // OK, iterable

[x] = {}; // TypeError, empty objects are not iterable
[x] = undefined; // TypeError, not iterable
[x] = null; // TypeError, not iterable


// TypeError is thrown even before accessing elements of the iterable which means you can use empty Array pattern [] to check if value is iterable
[] = {}; // TypeError, empty objects are not iterable
[] = undefined; // TypeError, not iterable
[] = null; // TypeError, not iterable

Можно установить значения по умолчанию

Значения по умолчанию могут быть установлены как запасной вариант

Пример: * 1 069 *

const [x=3, y] = []; // x = 3; y = undefined

Неопределенные значения триггеров по умолчанию

0 голосов
/ 06 сентября 2018

Помимо заданных назначений деструктурирования , вы можете взять деструктуризацию объекта для массива, если вы хотите использовать определенные элементы, такие как 11-й и 15-й элементы массива.

В этом случае вам необходимо использовать шаблон назначения свойства объекта [YDKJS: ES6 & Beyond] с новым именем переменной, поскольку вы не можете иметь переменные в виде чисел.

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
    { 11: a, 15: b } = array;

console.log(a, b);
0 голосов
/ 06 сентября 2018

Деструктурирование использует структурный синтаксис в левой части присваивания для назначения элементов структуры в правой части отдельным переменным. Например,

let array = [1, 2, 3, 4];
let [first, _, third] = array;

уничтожает массив [1, 2, 3] и назначает отдельные элементы first и third (_ является заполнителем, заставляя его пропустить второй элемент). Поскольку LHS короче RHS, 4 также игнорируется. Это эквивалентно:

let first = array[0];
let third = array[2];

Существует также назначение для разрушения объекта:

let object = {first: 1, second: 2, third: 3, some: 4};
let {first, third, fourth: some} = object;

что эквивалентно

let first = object.first;
let third = object.third;
let fourth = object.some;

Оператор спреда также разрешен:

let [first, ...rest] = [1, 2, 3];

назначит 1 на first, а [2, 3] на rest.

В вашем коде написано, что вы можете сделать это вместо этого:

[this.message] = res.response.data.errors;

В документации по prefer-destructuring изложено то, что он считает "правильным".

0 голосов
/ 06 сентября 2018

U может переписать эту строку как [this.message] = res.response.data.errors;, и ошибка es-lint исчезнет. Посмотрите этот пример для лучшего понимания

var x = {
  y: {
    z: {
      w: [3, 4]
    }
  }
};

function foo() {
  [this.a] = x.y.z.w
  console.log(this.a);
}
foo() // prints 3

Для получения дополнительной информации о деструктуризации массива, пожалуйста, см. Здесь

0 голосов
/ 06 сентября 2018

Всегда обращайте внимание на MDN, если вы хотите узнать о JavaScript. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Array_destructuring

Вот простой пример разрушения:

const [a, b] = ['a', 'b'];

Это сокращенное наименование, доступное с es6, которое позволяет назначать переменные более кратким способом.

Оригинальный способ будет выглядеть так:

const arr = ['a', 'b'];
const a = arr[0];
const b = arr[1];

И путь es6 будет таким:

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

Теперь, что касается ошибки eslint, я на самом деле не согласен с ней. Ваш код сам по себе должен быть в порядке. Таким образом, вы должны сообщить об ошибке в репозитории Eslint github, чтобы узнать, почему эта строка вызывает предупреждение «предпочитать-деструктурировать».

...