React'teki bu üç nokta ne yapıyor?


897

Ne gelmez ...kodu ve ne (JSX kullanarak) denir React bu yapmak?

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

6
Orada yayılım sözdizimi üzerinde basit ve anlaşılır bir okuma var - codeburst.io/javascript-es6-the-spread-syntax-f5c35525f754
Gautam

5
NOT / BILGI: ...operatör farklı bağlamlarda farklı davranır. Bu bağlamda, @TJ Crowder tarafından aşağıda açıklanan "yayma" operatörüdür. Farklı bir bağlamda bu, @Tomas Nikodym tarafından aşağıda açıklanan "dinlenme" operatörü de olabilir.
doub1ejack

Yanıtlar:


1064

Bu mülkiyet yayılım gösterimi . ES2018'de eklendi (diziler / yinelenebilirler için yayılma daha erkendi, ES2015), ancak React projelerinde transpilasyon yoluyla uzun bir süre desteklendi ( yalnızca öznitelikleri değil, başka bir yerde de yapabilmenize rağmen " JSX yayılma öznitelikleri " ).

{...this.props} dışarı yayılır "kendi" enumerable özellikleri propsüzerinde ayrık özellikler olarak Modaloluşturduğunuz eleman. Örneğin, eğer this.propsiçerdiği a: 1ve b: 2daha sonra,

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

ile aynı olurdu

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

Ancak dinamiktir, dolayısıyla "kendi" özellikleri ne olursa olsun propsdahil edilir.

Yana childrenbir "kendi" özelliktir props, yayılmış bunu içerecektir. Görünen bileşenin alt öğeleri varsa, bunlar aktarılacaktır Modal. Açılış etiketi ile kapanış etiketleri arasına alt öğe koymak, açılış etiketine bir childrenözellik koymak için sadece sözdizimsel şekerdir . Misal:

Forma notasyonu, yalnızca bu kullanım durumu için değil, mevcut bir nesnenin özelliklerinin çoğuna (veya tümüne) sahip yeni bir nesne oluşturmak için kullanışlıdır - durumu güncellediğinizde çok fazla gelir, çünkü durumu değiştiremezsiniz direkt olarak:

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

Bu cümledeki this.state.fooolarak aynı özelliklere sahip yeni bir nesne ile foohariç aolur özelliği, "updated":


1
Açıklık arasındaki bir alt öğesi koyarak ve etiketleri kapanış mu geçersizchildren özelliği veya bunlar birleştirilir?
anddero

3
@anddero - Bu çok ilginç bir soru. Bildiğim kadarıyla gördüğünüz gibi, bu oluyor belgelerinde [kapsamında değildir ait children. Deneme, adı verilen bir özellik aracılığıyla sağladığınız çocuklara childrenbaşlangıç ​​ve bitiş etiketleri arasında belirttiğiniz (ler) e göre daha üstün olduklarını söylüyor, ancak tanımlanmamış bir davranışsa, buna güvenmediğinizden emin olurum.
TJ Crowder

332

Bildiğiniz gibi adın temsil ettiği Spread Attributes... denir , ifadenin genişletilmesine izin verir.

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

Ve bu durumda (basitleştireceğim).

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

Bu:

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

eşittir

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

Kısacası, düzgün bir kısa yol diyebiliriz .


155

Üç nokta ES6'daki Forma Operatörünü temsil eder . Javascript'te birkaç şey yapmamızı sağlar:

  1. Dizileri bitiştir

    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. Bir diziyi yok etme

      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. İki nesneyi birleştirme

    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'}

Dinlenme Parametreleri olarak bilinen üç nokta için başka bir kullanım daha vardır ve tüm bağımsız değişkenleri tek bir dizi olarak bir işleve almayı mümkün kılar.

  1. Dizi bağımsız değişkenleri

     function fun1(...params) { 
    
     }  

36
Bu, her kullanım durumu için tüm açık örnekler nedeniyle harika bir cevaptır. Tüm bunları yazmak için zaman ayırdığınız için teşekkür ederiz.
Çad

2
Daha fazla netlik için örnekten önce dinlenme parametrelerinden
bahsedin

2
upvoted, aradığım bu
Csaba

2
Dürüst olmak gerekirse bu kabul edilen cevap olmalıdır. +1
I_am_learning_now

1
sadece en iyi cevap değil, en komik olanı, 'Selana Marie ilk aşkınız: D'
Andaç Temel

56

JavaScript'teki üç nokta yayma / dinlenme operatörüdür .

Forma operatörü

Yayılma sözdizimi bir ifade birden argümanlar beklenen yerlerde genişletilmiş sağlar.

myFunction(...iterableObj);

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

[...Array(10)]

Dinlenme parametreleri

Geri kalan parametre söz dizimi bağımsız değişken sayıda fonksiyonlar için kullanılır.

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

Diziler için yayılma / dinlenme operatörü ES6'da tanıtıldı. Nesne yayma / dinlenme özellikleri için bir Durum 2 önerisi vardır .

TypeScript ayrıca forma sözdizimini destekler ve bunu küçük sorunlarla eski ECMAScript sürümlerine aktarabilir .


Spread / rest artık Stage4, bitti. Bence ES9 / 2018'de github.com/tc39/proposal-object-rest-spread/blob/master/…
SeanMC

32

Bu, React'te de kullanılan ES6'nın bir özelliğidir. Aşağıdaki örneğe bakın:

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

Bu şekilde en fazla 3 parametremiz varsa sorun yoktur. Ancak, örneğin 110 parametre eklememiz gerekirse. Hepsini tanımlamalı ve teker teker eklemeli miyiz?

Tabii ki SPREAD adı verilen daha kolay bir yol var . Yazdığınız tüm parametreleri iletmek yerine:

function (...numbers){} 

Kaç parametreye sahip olduğumuz hakkında hiçbir fikrimiz yok, ancak bunların yığınları olduğunu biliyoruz. ES6'ya dayanarak, yukarıdaki işlevi aşağıdaki gibi yeniden yazabilir ve bir pasta parçası kadar kolay hale getirmek için aralarındaki yayılma ve eşlemeyi kullanabiliriz:

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

17

Sadece sizin için JSX'te sahne farklı bir şekilde tanımlamak !

Kullanıyor ...böylece temelde zaten sahne tanımlarsanız, kendi elemana bu şekilde geçebilir (nesne bir henüz tam olarak desteklenmemektedir) ES6 içinde dizi ve nesne operatörü.

Yani sizin durumunuzda, kod şöyle olmalıdır:

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

böylece tanımladığınız, şimdi ayrılmış ve gerekirse yeniden kullanılabilir sahne.

Şuna eşittir:

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

Bunlar React ekibinden JSX'teki forma operatörünün alıntıları:

JSX Spread Nitelikleri Bir bileşene önceden yerleştirmek istediğiniz tüm özellikleri biliyorsanız, JSX'i kullanmak kolaydır:

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

Sahne Değişimi Kötüdür
Hangi özellikleri ayarlamak istediğinizi bilmiyorsanız, bunları daha sonra nesneye eklemeniz cazip olabilir:

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

Bu bir anti-kalıptır, çünkü daha sonraya kadar doğru propTiplerini kontrol etmenize yardımcı olamayacağımız anlamına gelir. Bu, propTypes hatalarınızın şifreli yığın izlemesi ile sonuçlandığı anlamına gelir.

Sahne sabit değildir. Sahne nesnesini başka bir yerde değiştirmek, beklenmedik sonuçlara neden olabilir, bu yüzden ideal olarak bu noktada donmuş bir nesne olacaktır.

Spread Nitelikleri
Artık JSX'in spread nitelikleri adlı yeni bir özelliğini kullanabilirsiniz:

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

İlettiğiniz nesnenin özellikleri, bileşenin sahne kısımlarına kopyalanır.

Bunu birden çok kez kullanabilir veya diğer özelliklerle birleştirebilirsiniz. Şartname sırası önemlidir. Daha sonraki öznitelikler öncekileri geçersiz kılar.

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

Tuhaf ... gösterimde ne var?
... operatörü (veya yayılma operatörü) zaten ES6'daki diziler için desteklenmektedir. Ayrıca Nesne Dinlenme ve Yayılma Özellikleri için bir ECMAScript teklifi vardır. JSX'te daha temiz bir sözdizimi sağlamak için bu desteklenen ve gelişen standartlardan yararlanıyoruz.


15

Python dünyasından gelenler için JSX Spread Attributes, Argüman Listelerinin Paketinden** Çıkarılmasına (Python -operator) eşdeğerdir.

Bunun bir JSX sorusu olduğunun farkındayım, ancak analojilerle çalışmak bazen daha hızlı elde etmeye yardımcı olur.


10

...Tepki olarak (yayılma operatörü) kullanılır:

destekleri ebeveynlerden alt bileşenlere geçirmek için düzgün bir yol sağlar. örneğin, bu bileşenler bir üst bileşende verildiğinde,

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

çocuğa aşağıdaki şekilde aktarılabilir,

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

buna benzer

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

ama çok daha temiz.


9

Üç nokta Forma Operatörlerini veya Dinlenme Parametrelerini... temsil eder ,

Bir dizi ifadesinin veya dizenin veya yinelenebilecek herhangi bir şeyin , işlev çağrıları için sıfır veya daha fazla bağımsız değişkenin veya dizi öğelerinin beklendiği yerlerde genişletilmesine izin verir .

  • İki diziyi birleştir

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

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

  • Dizi kopyalanıyor:

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

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

Not: Bir diziyi kopyalarken yayılım sözdizimi etkili bir şekilde bir düzey derine gider. Bu nedenle, aşağıdaki örnekte gösterildiği gibi çok boyutlu dizileri kopyalamak uygun olmayabilir (Object.assign () ve spread sözdizimi ile aynıdır).

  • Bir dizinin değerlerini belirli bir dizinde diğerine ekleyin, örneğin 3:

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

  • Bir kurucuyu yenisiyle çağırırken:

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

console.log(d);

  • Nesne değişmezlerine yayıldı:

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}

fooObj1 fooözelliğinin üzerine obj2 özelliğinin üzerine yazıldığını unutmayın

  • Dizi olarak belirsiz sayıda argümanı temsil etmemizi sağlayan bir rest parametre sözdizimi olarak:

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

Not: Spread sözdizimi (spread özellikleri durumu hariç) yalnızca yinelenebilir nesnelere uygulanabilir: Bu nedenle aşağıdakiler hata verir

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

REFERENCE1

Referans2


5

Brandon Morelli için Kudos. Burada mükemmel bir şekilde açıkladı , ancak bağlantılar ölebilir, bu yüzden sadece aşağıdaki içeriği yapıştırıyorum:

... Forma sözdizimi sadece üç noktadır : 0+ argümanın beklendiği yerlerde genişleyebilir bir yinelenebilir. Tanımlar bağlamsızdır. Bunun ne anlama geldiğini anlamaya yardımcı olacak bazı farklı kullanım örneklerini inceleyelim.

Örnek 1 - Dizileri Ekleme Aşağıdaki koda bir göz atın. Bu kodda forma sözdizimini kullanmıyoruz:

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

console.log(arr);

Yukarıda, adlı bir dizi oluşturduk mid. Daha sonra dizimizi içeren ikinci bir dizi oluştururuz mid. Son olarak, sonucu kapatıyoruz. Ne arryazdırmayı umuyorsunuz? Ne olduğunu görmek için yukarıdaki çalıştır'ı tıklayın. İşte çıktı:

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

Beklediğiniz sonuç bu mu? midDiziyi diziye ekleyerek, arrbir dizinin içindeki bir diziyi bulduk. Amaç bu olsaydı sorun değil. Peki ya 1'den 6'ya kadar değerleri olan tek bir dizi istiyorsanız? Bunu başarmak için forma sözdizimini kullanabiliriz! Unutmayın, yayılma sözdizimi dizimizin öğelerinin genişlemesine izin verir. Aşağıdaki koda bakalım. Her şey aynı - ancak middiziyi diziye eklemek için forma sözdizimini kullanmamız dışında arr:

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

console.log(arr);

Ve çalıştır düğmesine bastığınızda sonuç şöyle:

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

Müthiş! Yukarıda okuduğunuz yayılım sözdizimi tanımını hatırlıyor musunuz? İşte burada devreye giriyor. Gördüğünüz gibi, arrdiziyi oluşturup dizide forma operatörünü midkullandığımızda, sadece eklenmek yerine middizi genişler. Bu genişletme, middizideki her öğenin diziye eklendiği anlamına gelir arr. İç içe diziler yerine, sonuç 1 ile 6 arasında değişen tek bir sayı dizisidir.

Örnek 2 - Matematik JavaScript, bazı eğlenceli matematik hesaplamaları yapmamızı sağlayan yerleşik bir matematik nesnesine sahiptir. Bu örnekte bakacağız Math.max(). Bilmiyorsanız, Math.max()en büyük sıfır veya daha fazla sayıyı döndürür. İşte birkaç örnek:

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

Gördüğünüz gibi, birden fazla sayının maksimum değerini bulmak istiyorsanız, birden Math.max()fazla parametre gerektirir. Maalesef giriş olarak tek bir dizi kullanamazsınız. Forma sözdiziminden önce, Math.max()bir dizide kullanmanın en kolay yolu.apply()

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

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

console.log(max(arr));

İşe yarıyor, gerçekten sinir bozucu. Şimdi aynı sözdizimini forma sözdiziminde nasıl yaptığımıza bir göz atın:

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

console.log(max);

Bir işlev oluşturmak ve sonucunu döndürmek için uygula yöntemini kullanmak zorunda kalmak yerine, Math.max()yalnızca iki kod satırına ihtiyacımız var! Forma sözdizimi dizi öğelerimizi genişletir ve dizimizdeki her öğeyi tek tek Math.max()yönteme girer !

Örnek 3 - Diziyi Kopyalama JavaScript'te, varolan diziye eşit yeni bir değişken ayarlayarak bir diziyi kopyalayamazsınız. Aşağıdaki kod örneğini düşünün:

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

console.log(arr2);

Çalıştır'a bastığınızda, aşağıdaki çıktıyı alırsınız:

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

Şimdi, ilk bakışta, işe yaramış gibi görünüyor - arr değerlerini arr2'ye kopyaladık gibi görünüyor. Ama olan bu değil. Javascript'teki nesnelerle çalışırken (diziler bir nesne türüdür), değere göre değil referans olarak atadığımızı görürsünüz. Bu, arr2'nin arr ile aynı referansa atandığı anlamına gelir. Başka bir deyişle, arr2'ye yaptığımız her şey orijinal arr dizisini de etkiler (ve tersi de geçerlidir). Aşağıya bir göz atın:

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

arr2.push('d');

console.log(arr);

Yukarıda, yeni bir d öğesini arr2'ye ittik. Ancak, arr değerini çıkardığımızda, d değerinin de bu diziye eklendiğini göreceksiniz:

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

Yine de korkmaya gerek yok! Forma operatörünü kullanabiliriz! Aşağıdaki kodu düşünün. Neredeyse yukarıdakiyle aynı. Bunun yerine, forma operatörünü bir çift köşeli parantez içinde kullandık:

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

console.log(arr2);

Hit run ve beklenen çıktıyı göreceksiniz:

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

Yukarıda, arr içindeki dizi değerleri, daha sonra arr2'ye atanan ayrı elemanlar olacak şekilde genişletildi. Artık arr2 dizisini, orijinal arr dizisinde hiçbir sonuç vermeden istediğimiz kadar değiştirebiliriz:

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

arr2.push('d');

console.log(arr);

Yine, bu çalışmanın nedeni, arr değerinin, arr2 dizi tanımımızın parantezlerini dolduracak şekilde genişletilmesidir. Böylece, ilk örnekte yaptığımız gibi arr değerine referans yapmak yerine arr2 değerini arr değerlerine eşit olacak şekilde ayarlıyoruz.

Bonus Örnek - Diziye Dizgi Eğlenceli bir son örnek olarak, bir dizeyi diziye dönüştürmek için forma sözdizimini kullanabilirsiniz. Bir çift köşeli parantez içindeki forma sözdizimini kullanmanız yeterlidir:

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

console.log(chars);


4

Üç nokta (...)forma operatörü olarak adlandırılır ve bu kavramsal olarak ES6 dizi forma operatörüne benzer, JSX, JSX'te daha temiz bir sözdizimi sağlamak için bu desteklenen ve gelişen standartlardan yararlanır

Nesne başlatıcılarındaki yayılma özellikleri, kendi numaralandırılabilir özelliklerini sağlanan bir nesneden yeni oluşturulan nesneye kopyalar.

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

Referans:

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

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


3
Bu, ECMAScript'teki nesneler üzerine yayılan operatör için bir tekliftir. Soru JSX spread operatörü hakkındaydı. Aynı şekilde çalışsalar da aynı değiller.
ivarni

1
@ivarni Beni içeriğe getirdiğin için teşekkürler, bana bir dakika ver, cevabı soru bağlamına göre güncelleyecek
Geliştirici

@ivarni Cevabı içeriğe göre güncelleyin, umarım bu içeriğe uyar
Geliştirici

"Üç nokta (...) forma operatörü olarak adlandırılır" Sadece yanlış. :-) Yayılma ve dinlenme operatörler değildir ve olamazlar çünkü bir operatör tek bir sonuç değeri üretmek zorundadır. Yayılma ve dinlenme, operatörler değil birincil sözdizimidir.
TJ Crowder

2

Anlamı ... kodda nerede kullandığınıza bağlıdır,

  1. Dizi / nesneyi yaymak / kopyalamak için kullanılır - Dizi / nesneyi kopyalamaya ve ayrıca yeni dizi değerleri eklemeye / isteğe bağlı olarak nesneye yeni özellikler eklemeye yardımcı olur.

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. İşlev bağımsız değişkenlerini tek bir dizide birleştirmek için kullanılır - Ardından dizi işlevlerini kullanabilirsiniz.

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

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


2

Bu bir yayılmış operatör ...

Örneğin, bir diziniz first=[1,2,3,4,5]ve başka bir diziniz varsa second=[6,7,8].

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

Aynı şey json nesneleri için de yapılabilir.


2

Kısacası, üç nokta ...ES6'da (ES2015) bir spread operatörüdür. Spread operatörü tüm verileri getirecektir.

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


console.log(b);

Sonuç verecek [1,2,3,4,5,6]

console.log(c);

Sonuç verecek [7,8,1,2,3,4]


1

Genellikle yayılma operatörü olarak adlandırılır, gerektiğinde genişletmek için kullanılır

misal

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

forma operatörü Spread sözdizimi hakkında daha fazla gereksinim duyduğunuz her yerde kullanabilirsiniz .


1

Birden Çok Özelliği Basit Bir Şekilde Geçirmek için Kullanılan Spread Nitelikleri

{... this.props}, this.props'un mülkünü elinde tutuyor

Aşağıdaki sahne ile {...} Spread Operator kullanımı

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

{...} Yayılmadan

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

> 

{...} Spread ile

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

Dan Abramov'un Forma operatörü (Creaux of Redux) hakkında Tweet


1

... bu sözdizimi ES6'nın bir parçasıdır ve yalnızca React'de kullanabileceğiniz bir şey değildir. İki farklı şekilde kullanılabilir; Bir yayılma operatörü olarak VEYA bir dinlenme olarak parameter.You bu makaleden daha bulabilirsiniz: https://www.techiediaries.com/react-spread-operator-props-setstate/

soruda bahsettiğiniz şey böyle bir şey, diyelim ki böyle,

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

forma operatörünü kullanarak sahne elemanlarını bu gibi bileşene aktarabilirsiniz.

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

0

Bir React uygulamasında destekleri aktarmak yaygın bir uygulamadır. Bunu yaparken saf veya Saf (vatansız veya durum bilgisi olan) olup olmadığına bakılmaksızın çocuk bileşenine durum değişiklikleri uygulayabiliriz. En iyi yaklaşımın, desteklerden geçerken, tekil özelliklerde veya özelliklerin tüm nesnesinde geçmek olduğu zamanlar vardır. ES6'daki dizileri destekleyerek bize "..." gösterimi verildi ve bununla artık tüm nesneyi bir çocuğa geçirmeyi başarabiliyoruz.

Bu sözdiziminde sahne donanımını bir çocuğa geçirme işlemi tipik olarak belirtilir:

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

Sahne sayısı çok az olduğunda kullanmak iyidir, ancak pervane numaraları çok daha fazla olduğunda yönetilemez hale gelir. Bir alt bileşen içinde gereken özellikleri bilmediğinizde ve tipik JavaScript yöntemi bu özellikleri basitçe ayarlamak ve nesneye daha sonra bağlamak olduğunda bu yöntemle ilgili bir sorun oluşur. Bu, yardımcı olmayan ve hata ayıklamada gecikmelere neden olan propType denetimi ve şifreli yığın izleme hatalarıyla ilgili sorunlara neden olur. Aşağıda bu uygulamanın bir örneği ve ne yapılmaması gerektiği açıklanmaktadır:

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

Aynı sonuç elde edilebilir, ancak bunu yaparak daha uygun bir başarı elde edilir:

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

Ancak JSX yayılmasını veya JSX'i kullanmaz, bu yüzden bunu tekrar denkleme dönüştürmek için şimdi böyle bir şey yapabiliriz:

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

"... sahne" lerde bulunan özellikler foo: x, bar: y şeklindedir. Bu, bu sözdizimini kullanarak "... sahne" nin özelliklerini geçersiz kılmak için diğer özelliklerle birleştirilebilir:

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

Ayrıca, diğer özellik nesnelerini birbirine kopyalayabilir veya bunları bu şekilde birleştirebiliriz:

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

Veya bunun gibi iki farklı nesneyi birleştirin (bu henüz tüm reaksiyon sürümlerinde mevcut değildir):

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

Facebook'un tepki / dokümanlar sitesine göre bunu açıklamanın başka bir yolu:

Zaten bir nesne olarak "sahne" varsa ve bunu JSX'te geçirmek istiyorsanız, tüm sahne nesnesini geçirmek için SPREAD operatörü olarak "..." kullanabilirsiniz. Aşağıdaki iki örnek eşdeğerdir:

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



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

Genel özellikler, genel kapsayıcılar oluştururken yararlı olabilir. Ancak, onlar umursamayan bileşenlere çok alakasız sahne geçmeyi kolaylaştırarak kodunuzu dağınık hale getirebilirler. Bu sözdizimi az kullanılmalıdır.


0

Onun yayılma operatörü. Örneğin, merhaba = {name: '', msg: ''} merhaba1 = {... merhaba} Şimdi merhaba nesne özellikleri merhaba1'e kopyalanır.


0

Javascript'te forma sözdizimi denir.

Javascript'te bir dizi veya nesneyi yok etmek için kullanılır.

misal:

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)

Object.assign()Javascript işleviyle aynı sonucu yapabilirsiniz .

Referans: Spread sözdizimi



0

yayılma operatörü (üçlü operatör) ecama script 6 (ES6) tanıtmak.Ecama script (ES6) javascript bir sarıcıdır.

sahne operatörü numaralandırılabilir özellikleri yaymak. this.props = {firstName: 'Dan', lastName: 'Abramov', şehir: 'New York', ülke: 'ABD'}

{... this.props} = {firstName: 'Dan', lastName: 'Abramov', şehir: 'New York', ülke: 'ABD'}

Ancak ana özellik yayma işleci bir referans türü için kullanılır.

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

person1.name = "Raheel";

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

Buna referans türü denir, bir nesne diğer nesneleri etkiler çünkü bellekte paylaşılabilir. Eğer değer bağımsız olarak ortalama yayılmış bellek elde ediyorsanız her iki yayılma operatörünü de kullanın.

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

person2.name = "Shahzad";

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

0

bir dizi öğeniz varsa ve sadece kullandığınız öğeleri görüntülemek istiyorsanız ... arrayemaments ve tüm öğeler üzerinde yinelenir


0

...(Javascript'te üç nokta) Spread Sözdizimi veya Spread Operatörü olarak adlandırılır. Bu, dizi ifadesi veya dize gibi bir yinelenebilir öğenin genişletilmesine veya bir nesne ifadesinin yerleştirildiği her yerde genişletilmesine olanak tanır . Bu, React'e özgü değildir. Bir Javascript işleci.

Buradaki tüm cevaplar faydalıdır, ancak Spread Sözdiziminin (Spread Operator) en çok kullanılan pratik Kullanım Durumlarını listelemek istiyorum .

1. Dizileri Birleştir (Dizileri Birleştir)

Orada bir olan diziler birleştirmek için çeşitli şekillerde , ama yayılması operatörü Bir dizide bir herhangi bir yerde bu yerleştirmek için izin verir. İki diziyi birleştirmek ve öğeleri dizinin herhangi bir yerine yerleştirmek isterseniz, aşağıdaki işlemleri yapabilirsiniz:

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

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

2. Dizileri Kopyalama

Bir dizinin bir kopyasını istediğimizde, Array.prototypr.slice () yöntemini kullanırdık. Ancak, aynı işlemi forma operatörü ile de yapabilirsiniz.

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

3. Arama Fonksiyonları Uygulanmadan

ES5'te, doStuff()işleve iki sayıdan oluşan bir dizi iletmek için genellikle Function.prototype.apply () yöntemini aşağıdaki gibi kullanırsınız:

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

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

Ancak, yayma işlecini kullanarak, bir diziyi işleve geçirebilirsiniz.

doStuff(...args);

4. Yıkım Dizileri

Bilgileri istediğiniz gibi değişkenlere çıkarmak için yıkım ve dinlenme operatörünü birlikte kullanabilirsiniz:

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. Dinlenme Parametreleri Olarak İşlev Bağımsız Değişkenleri

ES6 ayrıca, bir işlevin kalan tüm bağımsız değişkenlerini bir diziye toplayan bir dinlenme parametresi olan üç noktaya (...) sahiptir.

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

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

6. Matematik İşlevlerini Kullanma

Spread'in argüman olarak kullanıldığı herhangi bir fonksiyon, herhangi bir sayıda argümanı kabul edebilen fonksiyonlar tarafından kullanılabilir.

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

7. İki Nesnenin Birleştirilmesi

İki nesneyi birleştirmek için forma operatörünü kullanabilirsiniz. Bu, bunu yapmanın kolay ve temiz bir yoludur.

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

var carFuel = 'Petrol';

var carData = {
  ...carType,
  carFuel
}

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

8. Bir Dizeyi Ayrı Karakterlere Ayırma

Bir dizeyi ayrı karakterlere yaymak için forma operatörünü kullanabilirsiniz.

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

Forma Operatörünü kullanmanın daha fazla yolunu düşünebilirsiniz. Burada listelediğim, popüler kullanım durumları.


-1

Bu, ES6 / Harmony'deki yeni bir özelliktir. Buna Spread Operator denir. Bir dizinin / nesnenin kurucu kısımlarını ayırmanıza veya birden fazla öğe / parametre almanıza ve bunları yapıştırmanıza izin verir. İşte bir örnek:

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

Ve bir nesne / anahtarlarla:

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

Gerçekten harika olan şey, "değerlerin geri kalanı" için kullanabilirsiniz.

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

Bunlara spreadler denir. Tam adından da anlaşılacağı gibi. Bu, bu dizi veya nesnelerde değeri ne olursa olsun koyuyor demektir.

Gibi :

let a = [1, 2, 3];
let b = [...a, 4, 5, 6];
console.log(b);
> [1, 2, 3, 4, 5, 6]
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.