Cosa fanno questi tre punti in React?


898

Che cosa fa ...questo codice React (usando JSX) e come si chiama?

<Modal {...this.props} title='Modal heading' animation={false}>

6
C'è una lettura semplice e comprensibile disponibile qui sulla sintassi diffusa - codeburst.io/javascript-es6-the-spread-syntax-f5c35525f754
Gautam

5
NOTA: l' ...operatore si comporta diversamente in contesti diversi. In questo contesto, è l'operatore "spread" descritto di seguito da @TJ Crowder. In un contesto diverso questo potrebbe anche essere l'operatore "resto" descritto di seguito da @Tomas Nikodym.
doub1ejack,

Risposte:


1066

Questa è la notazione di diffusione di proprietà . È stato aggiunto in ES2018 (la diffusione per array / iterabili era precedente, ES2015), ma è stata supportata a lungo nei progetti React tramite transpilation (come " attributi di diffusione JSX " anche se è possibile farlo anche altrove, non solo attributi ).

{...this.props} distribuisce le proprietà "proprie" enumerabili propscome proprietà discrete Modalsull'elemento che si sta creando. Ad esempio, se this.propscontenuto a: 1e b: 2, quindi

<Modal {...this.props} title='Modal heading' animation={false}>

sarebbe lo stesso di

<Modal a={this.props.a} b={this.props.b} title='Modal heading' animation={false}>

Ma è dinamico, quindi propssono incluse tutte le proprietà "proprie" .

Poiché childrenè una proprietà "propria" in props, spread la includerà. Quindi, se il componente in cui questo appare aveva elementi figlio, verranno passati a Modal. Mettere elementi figlio tra il tag di apertura e quelli di chiusura è solo zucchero sintattico - il buon tipo - per mettere una childrenproprietà nel tag di apertura. Esempio:

La notazione diffusa è utile non solo per quel caso d'uso, ma per creare un nuovo oggetto con la maggior parte (o tutte) le proprietà di un oggetto esistente - che si presenta molto quando si aggiorna lo stato, poiché non è possibile modificarlo direttamente:

this.setState(prevState => {
    return {foo: {...prevState.foo, a: "updated"}};
});

Che sostituisce this.state.foocon un nuovo oggetto con tutte le stesse proprietà footranne la aproprietà, che diventa "updated":


1
Fa mettere un elemento figlio tra l'apertura e la chiusura tag sostituiscono la childrenproprietà o sono combinati?
anddero,

3
@anddero - Questa è una domanda molto interessante. Per quanto posso vedere, non è coperto da [la documentazione di children. La sperimentazione mi dice che i bambini che fornisci tramite un attributo chiamato childrensono sostituiti da quelli specificati tra i tag iniziale e finale, ma se si tratta di un comportamento indefinito, sarei sicuro di non fare affidamento su di esso.
TJ Crowder,

333

Come sapete ...sono chiamati Attributi distesi che il nome rappresenta consente di espandere un'espressione.

var parts = ['two', 'three'];
var numbers = ['one', ...parts, 'four', 'five']; // ["one", "two", "three", "four", "five"]

E in questo caso (lo semplificherò).

//just assume we have an object like this:
var person= {
    name: 'Alex',
    age: 35 
}

Questo:

<Modal {...person} title='Modal heading' animation={false} />

è uguale a

<Modal name={person.name} age={person.age} title='Modal heading' animation={false} />

Quindi in breve, è una scorciatoia ordinata , possiamo dire .


157

I tre punti rappresentano lo Spread Operator in ES6. Ci permette di fare alcune cose in Javascript:

  1. Matrici concatenate

    var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
    var racingGames = ['Need For Speed', 'Gran Turismo', 'Burnout'];
    var games = [...shooterGames, ...racingGames];
    
    console.log(games)  // ['Call of Duty', 'Far Cry', 'Resident Evil',  'Need For Speed', 'Gran Turismo', 'Burnout']
  2. Distruzione di un array

      var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
      var [first, ...remaining] = shooterGames;
      console.log(first); //Call of Duty
      console.log(remaining); //['Far Cry', 'Resident Evil']
  3. Combinazione di due oggetti

    var myCrush = {
      firstname: 'Selena',
      middlename: 'Marie'
    };
    
    var lastname = 'my last name';
    
    var myWife = {
      ...myCrush,
      lastname
    }
    
    console.log(myWife); // {firstname: 'Selena',
                         //   middlename: 'Marie',
                         //   lastname: 'my last name'}

C'è un altro uso per i tre punti che è noto come Parametri di riposo e rende possibile prendere tutti gli argomenti in una funzione come un array.

  1. Argomenti delle funzioni come array

     function fun1(...params) { 
    
     }  

37
Questa è un'ottima risposta a causa di tutti gli esempi chiari per ogni caso d'uso. Grazie per aver dedicato del tempo a scrivere tutto questo.
il ciad

2
Indica i parametri di riposo prima dell'esempio per maggiore chiarezza
j obe,

2
votato, questo è quello che stavo cercando
Csaba

2
Onestamente questa dovrebbe essere la risposta accettata. +1
I_am_learning_now

1
non solo la migliore risposta anche la più divertente, 'Selana Marie la tua prima cotta: D'
Andaç Temel

57

I tre punti in JavaScript sono operatori spread / rest .

Operatore di diffusione

La sintassi diffusa consente di espandere un'espressione in punti in cui sono previsti più argomenti.

myFunction(...iterableObj);

[...iterableObj, 4, 5, 6]

[...Array(10)]

Parametri di riposo

La sintassi del parametro rest è utilizzata per funzioni con numero variabile di argomenti.

function(a, b, ...theArgs) {
  // ...
}

L'operatore spread / rest per array è stato introdotto in ES6. Esiste una proposta State 2 per le proprietà di diffusione / riposo degli oggetti.

TypeScript supporta anche la sintassi diffusa e può traspilarla in versioni precedenti di ECMAScript con problemi minori .


Spread / rest ora è Stage4, finito. Penso che sia incluso in ES9 / 2018 github.com/tc39/proposal-object-rest-spread/blob/master/…
SeanMC

32

Questa è una caratteristica di ES6, che viene utilizzata anche in React. Guarda l'esempio seguente:

function Sum(x,y,z) {
   return x + y + z;
}
console.log(Sum(1,2,3)); //6

In questo modo va bene se abbiamo un massimo di 3 parametri. Ma cosa succede se dobbiamo aggiungere ad esempio 110 parametri. Dobbiamo definirli tutti e aggiungerli uno per uno?

Naturalmente c'è un modo più semplice di fare, che si chiama SPREAD . Invece di passare tutti quei parametri che scrivi:

function (...numbers){} 

Non abbiamo idea di quanti parametri abbiamo, ma sappiamo che ce ne sono molti. Basato su ES6, possiamo riscrivere la funzione sopra come sotto e usare la diffusione e la mappatura tra di loro per renderlo facile come un gioco da ragazzi:

let Sum = (...numbers) => {
return numbers.reduce((prev, current) => prev + current );
}
console.log(Sum(1, 2, 3, 4, 5, 6, 7, 8, 9));//45

17

Sta solo definendo oggetti di scena in modo diverso in JSX !

Sta usando l' ...operatore di array e oggetti in ES6 (oggetto uno non ancora completamente supportato), quindi sostanzialmente se definisci già i tuoi oggetti di scena, puoi passarli al tuo elemento in questo modo.

Quindi nel tuo caso, il codice dovrebbe essere qualcosa del genere:

function yourA() {
  const props = {name='Alireza', age='35'};
  <Modal {...props} title='Modal heading' animation={false} />
}

così gli oggetti di scena che hai definito, ora separati e possono essere riutilizzati se necessario.

È uguale a:

function yourA() {
  <Modal name='Alireza' age='35' title='Modal heading' animation={false} />
}

Queste sono le citazioni del team React sull'operatore spread in JSX:

Attributi di diffusione JSX Se si conoscono in anticipo tutte le proprietà che si desidera posizionare su un componente, è facile usare JSX:

var component = <Component foo={x} bar={y} />;

Il muting Props è male
Se non sai quali proprietà vuoi impostare, potresti essere tentato di aggiungerle all'oggetto in seguito:

var component = <Component />;
component.props.foo = x; // bad
component.props.bar = y; // also bad

Questo è un anti-pattern perché significa che non possiamo aiutarti a controllare i propTypes giusti fino a molto tempo dopo. Ciò significa che gli errori propTypes finiscono con una traccia di stack criptico.

Gli oggetti di scena dovrebbero essere considerati immutabili. La mutazione dell'oggetto di scena da qualche altra parte potrebbe causare conseguenze inaspettate, quindi idealmente sarebbe un oggetto congelato a questo punto.

Attributi di diffusione
Ora puoi usare una nuova funzionalità di JSX chiamata attributi di diffusione:

var props = {};
    props.foo = x;
    props.bar = y;
    var component = <Component {...props} />;

Le proprietà dell'oggetto che si passa vengono copiate sui puntelli del componente.

Puoi usarlo più volte o combinarlo con altri attributi. L'ordine delle specifiche è importante. Gli attributi successivi hanno la precedenza su quelli precedenti.

var props = { foo: 'default' };
var component = <Component {...props} foo={'override'} />;
console.log(component.props.foo); // 'override'

Cos'è la strana ... notazione?
L'operatore ... (o operatore di diffusione) è già supportato per le matrici in ES6. Esiste anche una proposta ECMAScript per le proprietà Rest of Object e Spread. Stiamo sfruttando questi standard supportati e in via di sviluppo per fornire una sintassi più pulita in JSX.


15

Per coloro che provengono dal mondo Python, JSX Spread Attributes sono equivalenti a Unpacking Argument Lists (l' **operatore Python ).

Sono consapevole che questa è una domanda JSX, ma a volte lavorare con le analogie aiuta a farlo più velocemente.


10

L' ...operatore di diffusione viene utilizzato per reagire a:

fornire un modo accurato per passare oggetti di scena da componenti padre a figlio. ad es. dati questi oggetti di scena in un componente genitore,

this.props = {
  username: "danM",
  email: "dan@mail.com"
}

potrebbero essere passati nel modo seguente al bambino,

<ChildComponent {...this.props} />

che è simile a questo

<ChildComponent username={this.props.username} email={this.props.email} />

ma molto più pulito.


9

Tre punti ...rappresentano gli operatori sparsi o i parametri di riposo ,

Consente l'espressione di una matrice o una stringa o qualsiasi cosa che può essere iterante da espandere in luoghi in cui sono previsti zero o più argomenti per chiamate di funzione o elementi per matrice.

  • Unire due matrici

var arr1 = [1,2,3];
var arr2 = [4,5,6];

arr1 = [...arr1, ...arr2];
console.log(arr1);  //[1, 2, 3, 4, 5, 6]

  • Copia array:

var arr = [1, 2, 3];
var arr2 = [...arr];

console.log(arr); //[1, 2, 3]

Nota: la sintassi di diffusione raggiunge effettivamente un livello di profondità durante la copia di un array. Pertanto, potrebbe non essere adatto per la copia di array multidimensionali, come mostrato nell'esempio seguente (è lo stesso con Object.assign () e la sintassi diffusa).

  • Aggiungi i valori di un array all'altro a un indice specifico, ad es. 3:

var arr1 = [4,5]
var arr2 = [1,2,3,...arr1,6]
console.log(arr2);	// [1, 2, 3, 4, 5, 6]

  • Quando si chiama un costruttore con nuovo:

var dateFields = [1970, 0, 1];  // 1 Jan 1970
var d = new Date(...dateFields);

console.log(d);

  • Diffuso in oggetti letterali:

var obj1 = { foo: 'bar', x: 42 };
var obj2 = { foo: 'baz', y: 13 };

var clonedObj = { ...obj1 };
console.log(clonedObj);	//{foo: "bar", x: 42}

var mergedObj = { ...obj1, ...obj2 };
console.log(mergedObj);	//{foo: "baz", x: 42, y: 13}

Si noti che la fooproprietà di obj1 è stata sovrascritta dalla fooproprietà obj2

  • Come sintassi dei parametri di riposo che ci consente di rappresentare un numero indefinito di argomenti come una matrice:

function sum(...theArgs) {
  return theArgs.reduce((previous, current) => {
    return previous + current;
  });
}

console.log(sum(1, 2, 3));	//6
console.log(sum(1, 2, 3, 4));	//10

Nota: la sintassi di diffusione (diversa dal caso delle proprietà di diffusione) può essere applicata solo agli oggetti iterabili: Pertanto, verrà visualizzato l'errore seguente

var obj = {'key1': 'value1'};
var array = [...obj]; // TypeError: obj is not iterable

Riferimento 1

reference2


5

Complimenti a Brandon Morelli. Ha spiegato perfettamente qui , ma i collegamenti potrebbero morire, quindi sto solo incollando il contenuto di seguito:

La sintassi di diffusione è semplicemente tre punti: ... consente a un iterabile di espandersi nei punti in cui sono previsti 0+ argomenti. Le definizioni sono difficili senza contesto. Esploriamo alcuni casi d'uso diversi per capire cosa significa questo.

Esempio n. 1 - Inserimento di array Dai un'occhiata al codice qui sotto. In questo codice, non utilizziamo la sintassi di diffusione:

var mid = [3, 4];
var arr = [1, 2, mid, 5, 6];

console.log(arr);

Sopra, abbiamo creato un array chiamato mid. Quindi creiamo un secondo array che contiene il nostro midarray. Infine, disconnettiamo il risultato. Cosa ti aspetti arrdi stampare? Fai clic su Esegui sopra per vedere cosa succede. Ecco l'output:

[1, 2, [3, 4], 5, 6]

È questo il risultato che ti aspettavi? Inserendo l' midarray arrnell'array, abbiamo finito con un array all'interno di un array. Va bene se quello era l'obiettivo. Ma cosa succede se si desidera un solo array con i valori da 1 a 6? Per fare ciò, possiamo usare la sintassi di diffusione! Ricorda, la sintassi diffusa consente agli elementi del nostro array di espandersi. Vediamo il codice qui sotto. Tutto è uguale, tranne per il fatto che ora stiamo usando la sintassi di diffusione per inserire l' midarray arrnell'array:

var mid = [3, 4];
var arr = [1, 2, ...mid, 5, 6];

console.log(arr);

E quando premi il pulsante Esegui, ecco il risultato:

[1, 2, 3, 4, 5, 6]

Eccezionale! Ricordi la definizione di sintassi diffusa che hai appena letto sopra? Ecco dove entra in gioco. Come puoi vedere, quando creiamo l' arrarray e utilizziamo l'operatore spread midsull'array, invece di essere semplicemente inserito, l' midarray si espande. Questa espansione significa che ogni singolo elemento middell'array viene inserito nel filearr nell'array. Invece di array nidificati, il risultato è un singolo array di numeri che vanno da 1 a 6.

Esempio n. 2 - Math JavaScript ha un oggetto matematico incorporato che ci permette di fare dei divertenti calcoli matematici. In questo esempio vedremo Math.max(). Se non hai familiarità,Math.max() restituisce il massimo di zero o più numeri. Ecco alcuni esempi:

Math.max();
// -Infinity
Math.max(1, 2, 3);
// 3
Math.max(100, 3, 4);
// 100

Come puoi vedere, se vuoi trovare il valore massimo di più numeri, Math.max()richiede più parametri. Sfortunatamente non puoi semplicemente usare un singolo array come input. Prima della sintassi diffusa, il modo più semplice da usare Math.max()su un array è usare.apply()

var arr = [2, 4, 8, 6, 0];

function max(arr) {
  return Math.max.apply(null, arr);
}

console.log(max(arr));

Funziona, è davvero fastidioso. Ora dai un'occhiata a come facciamo la stessa cosa esatta con la sintassi di diffusione:

var arr = [2, 4, 8, 6, 0];
var max = Math.max(...arr);

console.log(max);

Invece di dover creare una funzione e utilizzare il metodo apply per restituire il risultato di Math.max() , abbiamo bisogno solo di due righe di codice! La sintassi di diffusione espande i nostri elementi dell'array e immette ciascun elemento nel nostro array individualmente nel Math.max()metodo!

Esempio n. 3 - Copia di un array In JavaScript, non puoi semplicemente copiare un array impostando una nuova variabile uguale a quella già esistente. Considera il seguente esempio di codice:

var arr = ['a', 'b', 'c'];
var arr2 = arr;

console.log(arr2);

Quando premi Esegui, otterrai il seguente output:

['a', 'b', 'c']

Ora, a prima vista, sembra che abbia funzionato - sembra che abbiamo copiato i valori di arr in arr2. Ma non è quello che è successo. Vedi, quando si lavora con oggetti in javascript (le matrici sono un tipo di oggetto) assegniamo per riferimento, non per valore. Ciò significa che arr2 è stato assegnato allo stesso riferimento di arr. In altre parole, tutto ciò che facciamo per arr2 influenzerà anche l'array arr originale (e viceversa). Dai un'occhiata qui sotto:

var arr = ['a', 'b', 'c'];
var arr2 = arr;

arr2.push('d');

console.log(arr);

Sopra, abbiamo inserito un nuovo elemento d in arr2. Tuttavia, quando disconnettiamo il valore di arr, vedrai che il valore d è stato aggiunto anche a quell'array:

['a', 'b', 'c', 'd']

Non c'è bisogno di temere però! Possiamo usare l'operatore di diffusione! Considera il codice qui sotto. È quasi come sopra. Invece, abbiamo usato l'operatore spread all'interno di una coppia di parentesi quadre:

var arr = ['a', 'b', 'c'];
var arr2 = [...arr];

console.log(arr2);

Premi run e vedrai l'output previsto:

['a', 'b', 'c']

Sopra, i valori di matrice in arr si espandono per diventare singoli elementi che sono stati quindi assegnati a arr2. Ora possiamo cambiare l'array arr2 quanto vorremmo senza conseguenze sull'array arr originale:

var arr = ['a', 'b', 'c'];
var arr2 = [...arr];

arr2.push('d');

console.log(arr);

Ancora una volta, il motivo per cui funziona è perché il valore di arr viene espanso per riempire le parentesi della nostra definizione di array arr2. Pertanto, stiamo impostando arr2 per eguagliare i singoli valori di arr anziché il riferimento a arr come abbiamo fatto nel primo esempio.

Esempio di bonus - String to Array Come esempio finale divertente, puoi usare la sintassi spread per convertire una stringa in un array. Usa semplicemente la sintassi di diffusione all'interno di una coppia di parentesi quadre:

var str = "hello";
var chars = [...str];

console.log(chars);


4

I tre punti (...)sono chiamati operatore di diffusione, e questo è concettualmente simile all'operatore di diffusione di array ES6, JSX sfrutta questi standard supportati e sviluppa al fine di fornire una sintassi più pulita in JSX

Le proprietà di diffusione negli inizializzatori di oggetti copiano le proprietà enumerabili proprie da un oggetto fornito sull'oggetto appena creato.

let n = { x, y, ...z };
n; // { x: 1, y: 2, a: 3, b: 4 }

Riferimento:

1) https://github.com/sebmarkbage/ecmascript-rest-spread#spread-properties

2) https://facebook.github.io/react/docs/jsx-spread.html


3
Questa è una proposta per operatore di diffusione su oggetti in ECMAScript. La domanda riguardava l'operatore di diffusione JSX. Non sono uguali anche se funzionano allo stesso modo.
Ivarni,

1
@ivarni Grazie per avermi portato nel contesto, dammi un minuto, aggiornerò la risposta in base al contesto della domanda
Sviluppatore

@ivarni Aggiorna la risposta in base al contesto, spero che questo si adatti al contesto
Sviluppatore

"I tre punti (...) sono chiamati operatore di diffusione" Solo in modo errato. :-) Diffusione e riposo non sono operatori e non possono esserlo, perché un operatore deve produrre un singolo valore di risultato. Diffusione e riposo sono sintassi primaria, non operatori.
TJ Crowder,

2

Il significato di ... dipende da dove lo usi nel codice,

  1. Utilizzato per diffondere / copiare l'array / oggetto - Aiuta a copiare array / oggetto e anche aggiungere nuovi valori di array / aggiungere nuove proprietà all'oggetto, che è facoltativo.

const numbers = [1,2,3];
const newNumbers = [...numbers, 4];
console.log(newNumbers) //prints [1,2,3,4] 

const person = {
 name: 'Max'
};

const newPerson = {...person, age:28};
console.log(newPerson); //prints {name:'Max', age:28}

  1. Utilizzato per unire gli argomenti della funzione in un singolo array : è quindi possibile utilizzare le funzioni dell'array su di esso.

const filter = (...args) => {
   return args.filter(el => el ===1);
}

console.log(filter(1,2,3)); //prints [1] 


2

Questo è un operatore di diffusione ...

Ad esempio se si dispone di un array first=[1,2,3,4,5]e un altro second=[6,7,8].

[...first, ...second] //result is [1,2,3,4,5,6,7,8]

Lo stesso può essere fatto anche con oggetti json.


2

In breve, i tre punti ...sono un operatore di diffusione in ES6 (ES2015). L'operatore di diffusione recupererà tutti i dati.

let a = [1, 2, 3, 4];
let b = [...a, 4, 5, 6];
let c = [7,8,...a];


console.log(b);

Darà il risultato [1,2,3,4,5,6]

console.log(c);

Darà il risultato [7,8,1,2,3,4]


1

Di solito è chiamato operatore di diffusione, è utilizzato per espandersi ovunque sia richiesto

esempio

const SomeStyle = {
   margin:10,
   background:#somehexa
}

puoi usarlo ovunque tu ne abbia bisogno di più sulla sintassi di spread spread operator .


1

Diffondere gli attributi utilizzati per passare le proprietà multiple in modo semplice

{... this.props} detiene la proprietà di this.props

Uso di {...} Spread Operator con i puntelli sottostanti

this.props = 
 { 
    firstName: 'Dan', 
    lastName: 'Abramov', 
    city: 'New York',
    country: 'USA' 
}

Senza {...} diffusione

<Child 
  firstName={this.props.firstName}
  lastName={this.props.lastName}
  city={this.props.city}
  country={this.props.country}

> 

Con {...} Diffusione

<Child { ...this.props } />

Tweet di Dan Abramov sull'operatore Spread (Creatore di Redux)


1

... questa sintassi fa parte di ES6 e non è qualcosa che puoi usare solo in React. Può essere usata in due modi diversi; come operatore di diffusione O come parametro di riposo. Puoi trovare ulteriori informazioni da questo articolo: https://www.techiediaries.com/react-spread-operator-props-setstate/

quello che hai menzionato nella domanda è qualcosa del genere, supponiamo che sia così,

    function HelloUser() {
      return <Hello Name="ABC" City="XYZ" />;
    }

con l'uso dell'operatore spread puoi passare oggetti di scena al componente in questo modo.

     function HelloUser() {
       const props = {Name: 'ABC', City: 'XYZ'};
       return <Hello {...props} />;
     }

0

È pratica comune passare oggetti di scena in un'applicazione React. In questo modo siamo in grado di applicare i cambiamenti di stato al componente figlio indipendentemente dal fatto che sia puro o impuro (apolide o con stato). Ci sono momenti in cui l'approccio migliore, quando si passa in oggetti di scena, è passare in proprietà singolari o in un intero oggetto di proprietà. Con il supporto per gli array in ES6 ci è stata data la notazione "..." e con questo siamo ora in grado di ottenere il passaggio di un intero oggetto a un bambino.

Il tipico processo di passaggio di oggetti di scena a un bambino si nota con questa sintassi:

var component = <Component foo={x} bar={y} />;

Questo va bene quando il numero di oggetti di scena è minimo ma diventa ingestibile quando i numeri di oggetti di scena diventano troppo alti. Un problema con questo metodo si verifica quando non si conoscono le proprietà necessarie all'interno di un componente figlio e il metodo JavaScript tipico consiste nell'impostare semplicemente tali proprietà e collegarle all'oggetto in un secondo momento. Ciò causa problemi con il controllo propType e gli errori di tracciamento dello stack criptico che non sono utili e causano ritardi nel debug. Di seguito è riportato un esempio di questa pratica e cosa non fare:

var component = <Component />;
component.props.foo = x; // bad
component.props.bar = y;

Lo stesso risultato può essere raggiunto ma con un successo più appropriato facendo questo:

var props = {};
props.foo = x;
props.bar = y;
var component = Component(props); // Where did my JSX go?

Ma non usa JSX spread o JSX, quindi per ricollegarlo all'equazione ora possiamo fare qualcosa del genere:

var props = {};
props.foo = x;
props.bar = y;
var component = <Component {...props} />;

Le proprietà incluse in "... oggetti di scena" sono foo: x, bar: y. Questo può essere combinato con altri attributi per sovrascrivere le proprietà di "... props" usando questa sintassi:

var props = { foo: 'default' };
var component = <Component {...props} foo={'override'} />;
console.log(component.props.foo); // 'override'

Inoltre, possiamo copiare gli altri oggetti di proprietà l'uno sull'altro o combinarli in questo modo:

var oldObj = { foo: 'hello', bar: 'world' };
var newObj = { ...oldObj, foo: 'hi' };
console.log(newObj.foo); // 'hi';
console.log(newObj.bar); // 'world';

O unisci due oggetti diversi come questo (questo non è ancora disponibile in tutte le versioni di reazione):

var ab = { ...a, ...b }; // merge(a, b)

Un altro modo di spiegarlo, secondo il sito di reazione / documentazione di Facebook è:

Se hai già "oggetti di scena" come oggetto e vuoi passarlo in JSX, puoi usare "..." come operatore SPREAD per passare l'intero oggetto oggetti di scena. I seguenti due esempi sono equivalenti:

function App1() {
  return <Greeting firstName="Ben" lastName="Hector" />;
}



function App2() {
  const props = {firstName: 'Ben', lastName: 'Hector'};
  return <Greeting {...props} />;
}

Gli attributi di diffusione possono essere utili quando si creano contenitori generici. Tuttavia, possono anche rendere disordinato il codice rendendo semplice il passaggio di molti oggetti di scena irrilevanti ai componenti a cui non importa. Questa sintassi dovrebbe essere usata con parsimonia.


0

Si chiama operatore di diffusione. Ad esempio let hello = {name: '', msg: ''} let hello1 = {... hello} Ora le proprietà dell'oggetto hello vengono copiate in hello1.


0

Si chiama sintassi di spread in JavaScript.

Usa per distruggere un array o un oggetto in JavaScript.

esempio:

const objA = { a: 1, b: 2, c: 3 }
const objB = { ...objA, d: 1 }
/* result of objB will be { a: 1, b: 2, c: 3, d: 1 } */
console.log(objB)

const objC = { ....objA, a: 3 }
/* result of objC will be { a: 3, b: 2, c: 3, d: 1 } */
console.log(objC)

Puoi fare lo stesso risultato con Object.assign() funzione in javascript.

Riferimento: sintassi diffusa



0

L'operatore spread (triplo operatore) introduce in ecama script 6 (ES6) .Ecama script (ES6) è un wrapper di javascript.

diffondere le proprietà enumerabili dell'operatore nei puntelli. this.props = {firstName: 'Dan', lastName: 'Abramov', città: 'New York', nazione: 'USA'}

{... this.props} = {firstName: 'Dan', lastName: 'Abramov', città: 'New York', nazione: 'USA'}

Ma l'operatore di diffusione della funzione principale viene utilizzato per un tipo di riferimento.

For example
let person= {
    name: 'Alex',
    age: 35 
}
person1= person;

person1.name = "Raheel";

console.log( person.name); // output: Raheel

Questo si chiama tipo di riferimento, un oggetto influenza altri oggetti perché sono condivisibili in memoria. Se si ottiene valore in modo indipendente, si intende sia la memoria di diffusione sia l'operatore di diffusione.

 let person= {
        name: 'Alex',
        age: 35 
    }
person2 = {...person};

person2.name = "Shahzad";

console.log(person.name); // output: Alex

0

se hai una matrice di elementi e vuoi visualizzare gli elementi che usi solo ... arrayemaments e itererà su tutti gli elementi


0

...(tre punti in Javascript) si chiama Spread Syntax o Spread Operator. Ciò consente di espandere un iterabile come un'espressione di matrice o una stringa o un oggetto espressione di ovunque venga posizionata. Questo non è specifico di React. È un operatore Javascript.

Tutte queste risposte qui sono utili, ma voglio elencare i casi d'uso più utilizzati della sintassi diffusa (Operatore di diffusione).

1. Combine array (array concatenati)

Esistono diversi modi per combinare le matrici , ma l'operatore di diffusione consente di posizionarle in qualsiasi punto di una matrice. Se desideri combinare due array e posizionare elementi in qualsiasi punto all'interno dell'array, puoi fare come segue:

var arr1 = ['two', 'three'];
var arr2 = ['one', ...arr1, 'four', 'five'];

// arr2 = ["one", "two", "three", "four", "five"]

2. Copia di array

Quando volevamo una copia di un array, avevamo il metodo Array.prototypr.slice () . Ma puoi fare lo stesso con l'operatore di diffusione.

var arr = [1,2,3];
var arr2 = [...arr];
// arr2 = [1,2,3]

3. Chiamare le funzioni senza applicare

In ES5, per passare un array di due numeri alla doStuff()funzione, si utilizza spesso il metodo Function.prototype.apply () come segue:

function doStuff (x, y, z) { }
var args = [0, 1, 2];

// Call the function, passing args
doStuff.apply(null, args);

Tuttavia, utilizzando l'operatore spread, è possibile passare un array nella funzione.

doStuff(...args);

4. Matrici di distruzione

Puoi usare la destrutturazione e l'operatore di riposo insieme per estrarre le informazioni in variabili come preferisci:

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }

5. Argomenti delle funzioni come parametri di riposo

ES6 ha anche i tre punti (...) che è un parametro di riposo che raccoglie tutti gli argomenti rimanenti di una funzione in un array.

function f(a, b, ...args) {
  console.log(args);
}

f(1,2,3,4,5);
// [ 3, 4, 5 ]

6. Utilizzo delle funzioni matematiche

Qualsiasi funzione in cui spread viene utilizzato come argomento può essere utilizzata da funzioni che possono accettare un numero qualsiasi di argomenti.

let numbers = [9, 4, 7, 1];
Math.min(...numbers); // 1

7. Combinazione di due oggetti

È possibile utilizzare l'operatore diffusione per combinare due oggetti. Questo è un modo semplice e pulito per farlo.

var carType = {
  model: 'Toyota',
  yom: '1995'
};

var carFuel = 'Petrol';

var carData = {
  ...carType,
  carFuel
}

console.log(carData); 
// {
//  model: 'Toyota',
//  yom: '1995',
//  carFuel = 'Petrol'
// }

8. Separare una stringa in caratteri separati

È possibile utilizzare l'operatore spread per distribuire una stringa in caratteri separati.

let chars = ['A', ...'BC', 'D'];
console.log(chars); // ["A", "B", "C", "D"]

Puoi pensare a più modi per utilizzare Spread Operator. Quello che ho elencato qui sono i casi d'uso più comuni.


-1

Questa è una nuova funzionalità di ES6 / Harmony. Si chiama Spread Operator. Ti consente di separare le parti costituenti di un array / oggetto, oppure di prendere più elementi / parametri e incollarli insieme. Ecco un esempio:

let array = [1,2,3]
let array2 = [...array]
// array2 is now filled with the items from array

E con un oggetto / chiavi:

// lets pass an object as props to a react component
let myParameters = {myKey: 5, myOtherKey: 7}
let component = <MyComponent {...myParameters}/>
// this is equal to <MyComponent myKey=5 myOtherKey=7 />

La cosa davvero interessante è che puoi usarlo per indicare "il resto dei valori".

const myFunc = (value1, value2, ...values) {
    // Some code
}

myFunc(1, 2, 3, 4, 5)
// when myFunc is called, the rest of the variables are placed into the "values" array

-3

Questi sono chiamati spread. Proprio come suggerisce il nome. Significa che sta mettendo qualunque valore in quell'array o oggetti.

Ad esempio :

let a = [1, 2, 3];
let b = [...a, 4, 5, 6];
console.log(b);
> [1, 2, 3, 4, 5, 6]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.