DéCONSTRUCTION JavaScript et affectation: simplifier le code et améliorer la lisibilité

L'affectation déconstruite de JavaScript vous permet d'extraire des éléments individuels d'un tableau ou d'un objet en utilisant la syntaxe concise et de les attribuer à des variables, de simplifier le code et de le rendre plus clair et plus facile à lire.

La déconstruction et l'attribution sont largement utilisées, y compris le traitement des réponses d'API, la programmation fonctionnelle et dans les cadres et les bibliothèques tels que React. Il peut également être utilisé pour les objets et les tableaux imbriqués, les paramètres de fonction par défaut, l'échange de valeurs de variable, le renvoi plusieurs valeurs à partir d'une fonction, des boucles de boucles et du traitement d'expression régulière.

Lorsque vous utilisez des affectations déconstruites, vous devez faire attention aux points suivants: vous ne pouvez pas démarrer une instruction avec des accolades bouclées, car elle ressemble à un bloc de code. Pour éviter les erreurs, déclarez la variable ou utilisez des supports si la variable est déclarée. Veillez également à éviter de mélanger les variables déclarées et non déclarées.

Comment utiliser l'affectation de déconstruction

déconstruire le tableau

Supposons que nous ayons un tableau:

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

La déconstruction fournit une alternative plus facile et moins sujette aux erreurs à l'extraction de chaque élément:

const [one, two, three] = myArray;

// one = 'a', two = 'b', three = 'c'

Vous pouvez ignorer certaines valeurs en omettant le nom de la valeur lors de l'attribution, par exemple:

const [one, , three] = myArray;

// one = 'a', three = 'c'

ou utilisez l'opérateur de repos (...) pour extraire les éléments restants:

const [one, ...two] = myArray;

// one = 'a', two = ['b', 'c']

déconstruire l'objet

La déconstruction s'applique également aux objets:

const myObject = {
  one:   'a',
  two:   'b',
  three: 'c'
};
// ES6 解構示例
const {one, two, three} = myObject;
// one = 'a', two = 'b', three = 'c'

Dans cet exemple, la variable nomme que les un, les deux et trois correspondent au nom de la propriété de l'objet. Nous pouvons également attribuer des attributs aux variables de n'importe quel nom, par exemple:

const myObject = {
  one:   'a',
  two:   'b',
  three: 'c'
};

// ES6 解構示例
const {one: first, two: second, three: third} = myObject;

// first = 'a', second = 'b', third = 'c'

déconstruire des objets imbriqués

Les objets imbriqués plus complexes peuvent également être référencés, par exemple:

const meta = {
  title: 'Destructuring Assignment',
  authors: [
    {
      firstname: 'Craig',
      lastname: 'Buckler'
    }
  ],
  publisher: {
    name: 'SitePoint',
    url: 'https://www.sitepoint.com/'
  }
};

const {
    title: doc,
    authors: [{ firstname: name }],
    publisher: { url: web }
  } = meta;

/*
  doc   = 'Destructuring Assignment'
  name  = 'Craig'
  web   = 'https://www.sitepoint.com/'
*/

Cela semble un peu compliqué, mais rappelez-vous que dans toutes les affectations déconstruites:

• Le c?té gauche de l'affectation est la cible de déconstruction - le modèle qui définit la variable attribuée
• à droite de l'affectation se trouve la source déconstruite - un tableau ou un objet contenant les données extraites

Précautions

Il y a d'autres choses à noter. Tout d'abord, vous ne pouvez pas démarrer l'instruction avec des accolades bouclées, car elle ressemble à un bloc de code, par exemple:

// 這會失敗
{ a, b, c } = myObject;

Vous devez déclarer des variables, par exemple:

// 這可以工作
const { a, b, c } = myObject;

ou utilisez des supports si la variable a été déclarée, par exemple:

// 這可以工作
({ a, b, c } = myObject);

Vous devez également veiller à éviter de mélanger les variables déclarées et non déclarées, telles que:

// 這會失敗
let a;
let { a, b, c } = myObject;

// 這可以工作
let a, b, c;
({ a, b, c } = myObject);

Ce qui précède est la connaissance de base de la déconstruction. Alors, dans quelles circonstances cela fonctionne-t-il? Je suis content que vous ayez posé cette question.

cas d'utilisation déconstruit

instruction plus simple

Les variables peuvent être déclarées sans définir explicitement chaque valeur, par exemple:

// ES5
var a = 'one', b = 'two', c = 'three';

// ES6
const [a, b, c] = ['one', 'two', 'three'];

Authentique, la version déconstruite est plus longue. C'est plus facile à lire, bien que ce ne soit pas le cas pour plus d'articles.

échange de valeur de variable

Les valeurs d'échange nécessitent une troisième variable temporaire, mais l'utilisation de la déconstruction est beaucoup plus facile:

var a = 1, b = 2;

// 交換
let temp = a;
a = b;
b = temp;

// a = 2, b = 1

// 使用解構賦值交換
[a, b] = [b, a];

// a = 1, b = 2

Vous n'êtes pas limité à deux variables;

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

Paramètres de fonction par défaut

Supposons que nous ayons une fonction Prettyprint () pour sortir notre méta-objet:

const [one, two, three] = myArray;

// one = 'a', two = 'b', three = 'c'

S'il n'y a pas de déconstruction, vous devez analyser cet objet pour vous assurer que des valeurs par défaut appropriées sont disponibles, par exemple:

const [one, , three] = myArray;

// one = 'a', three = 'c'

Maintenant, nous pouvons attribuer des valeurs par défaut à n'importe quel paramètre, par exemple:

const [one, ...two] = myArray;

// one = 'a', two = ['b', 'c']

Mais nous pouvons utiliser la déconstruction pour extraire des valeurs et attribuer des valeurs par défaut si nécessaire:

const myObject = {
  one:   'a',
  two:   'b',
  three: 'c'
};
// ES6 解構示例
const {one, two, three} = myObject;
// one = 'a', two = 'b', three = 'c'

Je ne sais pas si c'est plus facile à lire, mais c'est évidemment plus court.

Renvoie plusieurs valeurs de la fonction

La fonction

ne peut renvoyer qu'une seule valeur, mais cela peut être un objet complexe ou un tableau multidimensionnel. La déconstruction de l'affectation rend cela plus pratique, par exemple:

const myObject = {
  one:   'a',
  two:   'b',
  three: 'c'
};

// ES6 解構示例
const {one: first, two: second, three: third} = myObject;

// first = 'a', second = 'b', third = 'c'

pour la boucle

Considérez un tableau d'informations sur le livre:

const meta = {
  title: 'Destructuring Assignment',
  authors: [
    {
      firstname: 'Craig',
      lastname: 'Buckler'
    }
  ],
  publisher: {
    name: 'SitePoint',
    url: 'https://www.sitepoint.com/'
  }
};

const {
    title: doc,
    authors: [{ firstname: name }],
    publisher: { url: web }
  } = meta;

/*
  doc   = 'Destructuring Assignment'
  name  = 'Craig'
  web   = 'https://www.sitepoint.com/'
*/

ES6 est similaire à for-in, sauf qu'il extrait chaque valeur au lieu de l'index / clé, par exemple:

// 這會失敗
{ a, b, c } = myObject;

L'attribution de déconstruction fournit d'autres améliorations, telles que:

// 這可以工作
const { a, b, c } = myObject;

Traitement d'expression régulière

Les fonctions d'expression régulières (telles que la correspondance) renvoient un tableau de correspondances, qui peut constituer la source des affectations déconstruites:

// 這可以工作
({ a, b, c } = myObject);

lecture complémentaire

• Affectation de déconstruction - MDN
• y a-t-il une perte de performance dans les affectations déconstruites à l'aide de JavaScript - reddit
• pour ... de la déclaration - mdn

Des questions fréquemment posées sur l'attribution de la déconstruction ES6 (FAQ)

(La partie FAQ est omise ici parce que la longueur est trop longue et ne correspond pas à l'objectif pseudo-original. Le contenu de la partie FAQ est fortement co?ncide -Originalité pour être trop faible.)

En effectuant des ajustements de déclaration, du remplacement des synonymes et de la réorganisation des paragraphes du texte d'origine, le traitement pseudo-original du texte d'origine est terminé et le format d'origine et l'emplacement de l'image sont conservés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!