├── .gitignore
├── README.md
└── ornekler
├── Makefile
├── build
├── 01_merhaba_dunya.js
├── 02_selamlama.js
├── 03_selamlama_props.js
├── 04_sayac.js
├── 05_sayac_gerisayim.js
└── 06_sayaclar.js
├── css
├── app.css
└── pure.css
├── index.html
├── libs
├── react.js
└── underscore.js
├── ornek1.html
├── ornek2.html
├── ornek3.html
├── ornek4.html
├── ornek5.html
├── ornek6.html
└── src
├── 01_merhaba_dunya.js
├── 02_selamlama.js
├── 03_selamlama_props.js
├── 04_sayac.js
├── 05_sayac_gerisayim.js
└── 06_sayaclar.js
/.gitignore:
--------------------------------------------------------------------------------
1 | .module-cache
2 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # React.js'e Giriş
2 |
3 | Sunumlar şu adreste: https://speakerdeck.com/ustun/react-dot-jse-giris
4 |
5 | React.js Facebook ve Instagram tarafından geliştirilmiş bir kullanıcı arayüzü
6 | kütüphanesidir. Kullanıcı arayüzü geliştirmede MVC, yani model-view-controller
7 | (model-görüntü-kontrolcü) tasarım deseni çok fazla kullanılır. React'in temel
8 | görevi buradaki View, yani görüntü kısmını düzenlemek olarak düşünülebilir; ama
9 | aslında sadece bir görüntü katmanından çok daha fazlasıdır.
10 |
11 | ## Tarihçe
12 |
13 | React'in tarihçesinden hızlıca bahsedecek olursak, Facebook Instagram'ı
14 | bünyesine kattığında Instagram'ın bir web sitesi yoktu, sadece mobil
15 | uygulamaları vardı. Bir web sitesi geliştirmek isteyen Instagram mühendisleri
16 | Facebook'un yorumlar, reklamlar gibi bazı bileşenlerinde kullandığı dahili
17 | kütüphaneyi kullanmak istedi. Yapılan çalışma sonucu kütüphanenin Facebook kod
18 | tabanındaki diğer bağımlılıkları kaldırıldı ve kütüphane 2013 Mayıs'ında
19 | JSConf'ta açık kaynak olarak dünyaya tanıtıldı.
20 |
21 | React.js'e ilk başta oldukça şüpheyle yaklaşıldı, hatta tanıtıldığı konferansta
22 | Facebook'un piyasadaki bütün bilinen doğruları sorguladığı, JS ile HTML'i çorba
23 | yaptığı şeklinde alay konusu bile oldu. Ancak sonraki dönemde bu kütüphanenin
24 | karmaşık sistemleri basitleştirdiği ve hızlandırdığı birçok firma tarafından
25 | fark edildi ve Netflix, Airbnb, Khan Academy gibi pek çok firma arayüzlerinde
26 | React.js'e geçti.
27 |
28 | ## Büyük Uygulamalarda Arayüz Geliştirmenin Zorlukları
29 |
30 | React'in temel hedefini şu şekilde özetleyebiliriz: Verinin zaman içerisinde
31 | değiştiği büyük uygulamaları basit ve hızlı bir şekilde geliştirmek.
32 |
33 | Çoğu durumda arayüz geliştirmek oldukça zordur, peki buradaki asıl zorluk nedir?
34 | Örneğin sunucu tabanlı bir web sistemi geliştirdiğimizi
35 | düşünelim. Veritabanından verileri çektik, daha sonra bir taslak, yani template
36 | aşamasından geçirip HTML çıktısını oluşturduk. Çoğu uygulamada, örneğin PHP'de,
37 | Django'da ya da Rails'te bu oldukça kolay bir işlemdir. Bu işlemi veriyi alan ve
38 | sonuç olarak HTML üreten bir fonksiyon olarak soyutlayabiliriz.
39 |
40 | Halbuki işler istemci tabanlı, yani clientside bir arayüz geliştirmeye
41 | geldiğinde oldukça zorlaşır. Buradaki zorluğun sebebi kullanılan dil olan
42 | JavaScript midir?
43 |
44 | Aslında birkaç yıl öncesine kadar çoğu kişinin kanısı bu yöndeydi. Bilindiği
45 | gibi JavaScript dili Brendan Eich tarafından yalnızca 10 gün içinde, deyim
46 | yerindeyse yangından mal kaçırırcasına tasarlanmış bir programlama dili. Bu
47 | nedenle dilde hala giderilmeye çalışılan bazı hatalar ve gariplikler var.
48 |
49 | Ancak Douglas Crockford'un JavaScript the Good Parts kitabında anlattığı üzere
50 | bu 10 gün içerisinde Brendan Eich, görüntü olarak C'ye benzese de altında bir
51 | Lisp yatan, çok esnek, fonksiyonel bir dil yaratmıştı. Zaten dildeki hatalar da
52 | CoffeeScript, ES6 gibi diller aracılığıyla ve underscore gibi fonksiyonel
53 | kütüphaneler sayesinde zaman içerisinde oldukça azaltıldı.
54 |
55 | Peki arayüz geliştirmedeki ana zorluk dil değilse nedir? Büyük uygulamaları
56 | incelediğimizde ve sunucuda oluşturulan arayüzleri tarayıcıdaki arayüzlerle
57 | karşılaştırdığımızda asıl zorluğun zaman içerisinde değişen veri yönetimi
58 | olduğunu görürüz. Sunucu taraflı bir uygulamayı düşünelim, veriyi veritabanından
59 | çektik, taslağa gönderdik. Bu esnada veriyi aslında değişmeyen bir yapı olarak
60 | düşünebiliriz.
61 |
62 | Ancak istemci tarafında işler bu şekilde ilerlemez. Diyelim kullanıcı tarayıcıyı
63 | açtı, uygulamayı başlattı; işte bu noktadan sonra uygulamadaki veri sürekli
64 | değişim halindedir ve uygulamadaki görüntü ile verinin senkronizasyon sorunu
65 | başlar. Hele aynı veri görüntünün birden fazla yerinde gösteriliyorsa işler daha
66 | da karmaşıklaşır.
67 |
68 | Örneğin bir chat uygulaması düşünelim. Şu an çevrimici olan arkadaşlarımızı ve
69 | toplam kaç arkadaşımızın çevrimiçi olduğunu göstersin. Diyelim ki bir
70 | arkadaşımız daha çevrimiçi hale geldi. Burada herhangi bir arayüz kütüphanesi
71 | kullanmıyorsak yapmamız gereken iki değişiklik var: Öncelikle yeni gelen
72 | arkadaşımızın ismini listeye eklemeli, daha sonra da tepedeki arkadaş sayısını
73 | bir artırmalıyız. Yani bir anlamda görüntüde kısmi bir değişiklik, bir yama
74 | yapmalıyız. Bu basit bir örnek gibi görünse de arayüz geliştirmedeki sorunların
75 | birçoğu işte bu veri ve görüntü arasındaki köşe kapmaca yüzünden yaşanmakta;
76 | veri değiştiğinde programcı görüntüdeki bir veri değiştirmeyi unutmakta.
77 |
78 | ## React'in Temel Felsefesi: Görüntüyü her seferinde yeniden oluşturmak
79 |
80 | İşte bu noktada React'in arayüz oluşturmadaki birinci ve temel felsefesi devreye
81 | giriyor: Verideki her değişimde görüntüyü yamamak yerine sil baştan
82 | oluşturalım. Yani görüntü yapacağımız değişiklikleri düşünmek yerine sadece
83 | veride bir değişiklik yapalım, görüntü sanki sayfayı yeniden yüklemişiz gibi
84 | sıfırdan oluşturulsun. Bu şekilde veri ve görüntü arasında hiçbir zaman bir
85 | anlaşmazlık olmasın.
86 |
87 | Tabii kulağa çok hoş geliyor, ama bu konuda kafanızda bazı soru işaretleri olmuş
88 | olabilir: Diyelim 100 kişilik bir listemiz var, veriye bir kişi daha ekledik,
89 | 101 kişilik yeni bir liste oluşturmamız gerekmekte. Bunu naif bir şekilde
90 | yaparsak, elimizde halihazırda bulunan 100 kişilik listeyi çöpe atacağız ve
91 | sıfırdan 101 kişilik bir liste oluşturacağız. Bu oldukça yavaş olmaz mı?
92 |
93 | React'in kütüphane olarak devreye girdiği yer tam da bu nokta. React, kullanıcı
94 | olarak sizin sadece veriye ve o verinin nasıl görüntüleneceğine odaklanmanızı
95 | sağlarken arkaplanda görüntüdeki değişimin en etkin biçimde yapılmasını
96 | sağlamakta. Yani 101 kişilik yeni listeyi oluştururken sizin yerinize görüntüde
97 | yapılması değişiklikleri hesaplamakta ve sadece bu değişiklikleri görüntüye
98 | uygulamakta. İşte React'in bunu yaparken kullandığı yönteme de sanal DOM
99 | (virtual DOM) diyoruz. React görüntü elemanlarını sanal DOM adı verilen bir veri
100 | yapısında tutuyor ve değişiklik olduğunda bu veri yapısını güncelleyerek
101 | görüntüde toplu değişiklikler yapiyor. Bu yöntemle React verideki değişiklikler
102 | sonucunda optimum olarak hangi HTML elemanlarının eklenip çıkarılacağına kendisi
103 | karar veriyor.
104 |
105 | Dolayısıyla React'in birinci temel kuralını şu şekilde özetleyebiliriz:
106 | Kullanıcı temel olarak arayüzün arkasındaki veri yapısına ve değişikliklerine
107 | odaklanmalı ve bu verinin nasıl görüntüleneceğini yalnızca bir kez tanımlamalı.
108 |
109 | ## React'in İkinci İlkesi: Bileşenler
110 |
111 | Şimdi gelelim React'in ikinci temel ilkesine. React'e göre arayüz geliştirirken
112 | temel hedefimiz aslında bileşen oluşturmak olmalı; yani elimizdeki arayüzü
113 | bileşenlere ayırmalı ve bileşenler cinsinden analiz etmeliyiz. Elimizde
114 | halihazırda bir HTML taslağı olduğu düşünelim, örneğin bir adres defteri. Bunu
115 | gerçekleştirmek için bunu küçük bileşenlere ayıralım. Örneğin tepedeki bileşen
116 | bir arama bileşeni, aşağıdaki her bir harfe ait kişiler bir `Sayfa` bileşeni,
117 | her bir adres satırı ise birer `Adres` bileşeni olarak düşünülebilir.
118 |
119 | İşte bu yaptığımız temelde bir soyutlama işlemi, elimizdeki küçük Lego
120 | bloklarından daha büyük Lego blokları yapıyoruz ve en nihayetinde en büyük Lego
121 | bloku olan uygulamamızı kuruyoruz.
122 |
123 | Bunu programlamada birden fazla cümleden fonksiyon oluşturmaya
124 | benzetebiliriz. Bu fonksiyonları kullanan yeni üst fonksiyonlar oluşturduğumuz
125 | gibi bileşenleri kullanan üst bileşenler oluşturabiliriz. Bu şekilde elimizde
126 | yeniden kullanılabilir (reusable), birbiri içine geçebilen (composable), nasıl
127 | kullanılacağı tanımlanmış küçük ve hatasız birimler oluşacak. React
128 | terminolojisinde temelde kullanılan bu yapıya component, yani bileşen denmekte.
129 |
130 | ### Basit Bir Bileşen: MerhabaDunya
131 |
132 | Bileşenlerin nasıl oluşturulduğuna ve kullanıldığına bir örnek verelim. Bir
133 | React component'i oluşturmak için `React.createClass` metodunu bir nesne
134 | (object) ile çağırıyoruz. Bileşenin nasıl görüneceğini de bu nesnenin `render`
135 | metodunda tanımlıyoruz. Mesela, `MerhabaDunya` adında bir bileşen tanımlayalım.
136 |
137 | ```js
138 | var MerhabaDunya = React.createClass({
139 | render: function () {
140 | return
Merhaba Dunya
;
141 | }
142 | })
143 | ```
144 |
145 | Burada React aslında sadece JavaScript dilini kullanıyor, herhangi bir taslak
146 | dili değil bu. Normal JavaScript'ten tek farkı JSX adında HTML sözdizimine
147 | benzeyen yapıları kullanmamıza izin vermesi. JSX isteğe bağlı kullanılan bir
148 | araç, tek yaptığı bu sözdizimi alıp bu etiketleri JavaScript fonksiyonlarına
149 | çevirmek. Yani `
Merhaba Dünya
` deyimini `React.createElement("div", null, "Merhaba Dünya")`
150 | fonksiyonuna dönüştürmekte.
151 |
152 | Bu bileşeni tanımladıktan sonra sayfamızda göstermek için sayfada halihazırda
153 | bulunan boş bir elemana monte etmemiz gerekmekte. Bunun için de `React.render`
154 | komutunu kullanmaktayız, örneğin bu bileşeni `body` elemanına monte etmek için
155 | `React.render(, document.body)` kullanıyoruz. Monte edeceğimiz
156 | eleman `body` yerine sayfada bulunan başka bir HTML elemanı da olabilirdi.
157 |
158 | Gördüğünüz gibi HTML'de tanımlı olan `div` bileşenini kullanarak `MerhabaDunya`
159 | adında yeni bir bileşen oluşturduk ve artık bunu sanki HTML'de bu şekilde bir
160 | bileşen varmış gibi kullanabilmekteyiz.
161 |
162 | ### Karmaşık Bir Bileşen: Selamlama
163 |
164 | Şimdi bu işlemi bir adım ileri götürelim, bu basit bileşeni kullanarak daha
165 | büyük bir bileşen oluşturalım. Örneğin, iki kere "Merhaba Dünya" diyecek bir
166 | `Selamlama` bileşeni oluşturalım. `Selamlama` adlı bileşeni oluşturmak için
167 | yapmamız gereken `React.createClass` içerisine `MerhabaDunya` bileşenini iki kez
168 | kullanan bir `render` metodu yazmak. Daha sonra `Selamlama` bileşenini yine
169 | `React.render` ile `body` elemanına monte edebiliriz.
170 |
171 | ```js
172 | var Selamlama = React.createClass({
173 | render: function () {
174 | return (
175 |
176 |
177 |
178 |
)
179 | }
180 | })
181 | ```
182 |
183 | Gördüğünüz gibi artık `MerhabaDunya` bileşenini başka bir bileşen içerisinde
184 | yeniden kullanabiliyoruz. Şimdi bunu bir adım ileri götürelim, diyelim ki
185 | `MerhabaDunya` bileşeni parametre olarak selamlayacağı kişinin ismini bir
186 | parametre olarak alsın ve bu kişinin ismini görüntülesin.
187 |
188 | Fonksiyonların giriş parametrelerine benzer bir şekilde React bileşenleri de
189 | `props` adında bir nesne içerisinde parametre kümesi alabilir ve bu
190 | parametrelere `props` üzerinden `render` metodunda erişebilir. `MerhabaDunya`
191 | bileşenini bu şekilde yeniden yazalım:
192 |
193 | ```js
194 | var MerhabaDunya = React.createClass({
195 | render: function () {
196 | return
Merhaba {this.props.isim}
197 | }
198 | })
199 | ```
200 |
201 | Buradaki { } (süslü parantezler) yine React'in JSX aracıyla JavaScript'e yaptığı
202 | bir ekleme, alt tarafta aslında parantezin icindekiler fonksiyon parametresine
203 | dönüşmekte. Yani `
Merhaba {this.props.isim}
` yerine `React.createElement("div", null,
204 | "Merhaba", this.props.isim)` de yazabilirdik.
205 |
206 | Şimdi de `Selamlama` bileşenimizi `MerhabaDunya` bileşenine isim parametresini aktaracak şekilde yeniden yazalım:
207 |
208 | ```js
209 | var Selamlama = React.createClass({
210 | render: function () {
211 | return
212 |
213 |
214 |
215 | }
216 | })
217 | ```
218 |
219 | İşte bu noktada artık `MerhabaDunya` adında yeniden kullanılabilir ve arayüzü,
220 | yani giriş degişkenleri tam olarak belirlenmiş bir çocuk bileşenimiz oldu.
221 |
222 | ### Veri değişimi
223 |
224 | React'in temel felsefesinden bahsederken React'in asıl öneminin verinin
225 | değiştiği uygulamaları yönetmek olduğunu söylemiştik. Şu ana kadar verdiğimiz
226 | örneklerde veri hep sabit olduğu için bunu henüz görmedik. Verideki değişimi
227 | örneklemek için bir Sayaç bileşeni düşünelim.
228 |
229 | Sayaç bileşenindeki değişkenleri düşünecek olursak tek değişkenimiz sayaç adında
230 | bir sayı. React'te bileşen ait değişkenler `state` adında bir nesnede
231 | toplanmakta. Yani nasıl ki `props` adında tepeden çocuk bileşene gönderilen
232 | parametrelerin toplandığı bir nesne var, çocuk bileşendeki değişimleri izlemek
233 | için de `state` adında bir nesne bulunmakta. Bu `state`'in ilk değerini vermek
234 | için yazmamız gereken bileşen metodu ise `getInitialState`. Bunu yaptıktan sonra
235 | artık bu state değişkenine `render` içerisinde erişebiliyoruz.
236 |
237 | ```js
238 | var Sayac = React.createClass({
239 | getInitialState: function () {
240 | return {sayac: 0};
241 | },
242 |
243 | render: function () {
244 |
Sayaca {this.state.sayac} kez tıkladınız
245 | }
246 | })
247 | ```
248 |
249 | Şimdi sayacı artıracak bir de düğme ekleyelim.
250 |
251 | ```js
252 | var Sayac = React.createClass({
253 | getInitialState: function () {
254 | return {sayaç: 0};
255 | },
256 |
257 | render: function () {
258 | return (
259 |
260 | Sayaca {this.state.sayac} kez tıkladınız
261 |
262 |
);
263 | }
264 | })
265 | ```
266 |
267 | Amacımız bu düğmeye her tıkladığımızda sayacı bir artırmak. Bunun için sayaç'a
268 | bir `onClick` handler fonksiyon eklememiz ve bu fonksiyonda `state`'teki sayacı
269 | bir artırmamız gerekmekte.
270 |
271 | ```js
272 | var Sayac = React.createClass({
273 |
274 | getInitialState: function () {
275 | return {sayac: 0};
276 | },
277 |
278 | artir: function () {
279 | // Buraya ne yazmalıyız?
280 | },
281 |
282 | render: function () {
283 | return (
284 |
285 | Sayaca {this.state.sayac} kez tıkladınız
286 |
287 |
;
288 | }
289 | })
290 | ```
291 |
292 | İşte burada React'in `state`'e diğer birçok kütüphaneye göre farklı bakış açısı
293 | devreye giriyor. React'te yapacağınız her veri değişimini mutlaka `setState`
294 | denilen bir metod üzerinden yapmanız gerekiyor, bu şekilde React sistemde bir
295 | şeylerin değiştiğini ve `render` metodunu yeniden çalıştırması gerektiğini
296 | anlıyor.
297 |
298 | ```js
299 | var Sayac = React.createClass({
300 | getInitialState: function () {
301 | return {sayac: 0};
302 | },
303 |
304 | artir: function () {
305 | var suAnkiSayac = this.state.sayac;
306 | this.setState({sayac: suAnkiSayac + 1});
307 | },
308 |
309 | render: function () {
310 | return (
311 |
312 | Sayaca {this.state.sayac} kez tıkladınız
313 |
314 |
)
315 | }
316 | })
317 | ```
318 |
319 | Örneğin AngularJS ile karşılaştıracak olursak AngularJS'te `setState` benzeri
320 | bir şey yok, doğrudan değişkeni değiştiriyorsunuz, bu nedenle AngularJS'in
321 | sayfada bir değişiklik olup olmadığını anlamak için sürekli digest loop
322 | (sindirim döngüsü) adı verilen kod parçası gerekmekte. Bu döngü de büyük
323 | uygulamalarda performans sorunlarına yol açıyor, sistemin neyi ne zaman
324 | değiştireceğini anlamayı güçleştiriyor.
325 |
326 | React'te ise `state` değişiklikleri `explicit`, yani açık seçik belirtilmiş
327 | durumda. React'in felsefesine göre veri değişiklikleri bir uygulamadaki en
328 | önemli zorluğu oluşturmakta, bu nedenle her türlü değişiklik mutlaka açık seçik
329 | `setState` üzerinden yapılmakta.
330 |
331 | Şimdi sayaç uygulamamızı biraz geliştirelim, örneğin 0'dan ileri doğru sayarken
332 | aynı zamanda da 10'dan 0'a doğru bir gerisayım yapsın; ama bu iki sayı birbiri
333 | ile tamamen bağlantılı olsun. Yani sayaca 3 kez tıklarsak "3 kez tıkladınız, 7
334 | kez daha tıklayın" desin. Şimdi burada kaç farklı değişken kullanmamız
335 | gerekmekte? İşte React uygulamaları geliştirirken kendimize sürekli sormamız
336 | gereken soru bu olacak: Veriyi nerede ve nasıl saklamalıyım?
337 |
338 | Bu uygulamada iki farklı veri görüntülenecek olsa da aslında kaynakta sadece tek
339 | sayaç değeri olduğunu görmeliyiz. Bu nedenle `state`'te sadece kaç kez
340 | tıklandığı değerini tutmamız yeterli. İşte React uygulamalarında sıklıkla
341 | düşünmemiz gereken önemli noktalardan biri de yine bu kaynak veri ve bu veriden
342 | oluşturulan işlenmiş veri konusu. Burada tek bir kaynak veri var; ancak iki
343 | farklı işlenmiş veri bulunmakta. `State`'te sadece kaynak veriyi tutmalı,
344 | işlenmiş verileri `render` metodunda anlık olarak hesaplatmalıyız.
345 |
346 | Bu değişiklikle Sayaç bileşenimizi yeniden yazalım:
347 |
348 | ```js
349 | var Sayac = React.createClass({
350 | getInitialState: function () {
351 | return {sayac: 0};
352 | },
353 |
354 | artir: function () {
355 | var suAnkiSayac = this.state.sayac;
356 | this.setState({sayac: suAnkiSayac + 1});
357 | },
358 |
359 | render: function () {
360 | return (
361 |
362 | Sayaca {this.state.sayac} kez tıkladınız.
363 | {10 - this.state.sayac} kez daha tıklamalısınız.
364 |
365 |
366 | );
367 | }
368 | })
369 | ```
370 |
371 | Gördüğünüz gibi `render` metodumuz görüntümüzün uygulamanın her anında nasıl
372 | görüneceği hakkında bize doğru bilgi veriyor. Yani render sadece ilk anda
373 | oluşturulan, sonra elle yama yapılması gereken bir görüntü sağlamıyor, her zaman
374 | doğru görüntü verecek bir sonuç veriyor.
375 |
376 | ### Ana Bileşen-Çocuk Bileşen Haberleşmesi
377 |
378 | Son olarak da çocuk bileşenlerin ana bileşen ile nasıl haberleşeceğine göz
379 | atalım. Burada da örneğin iki farklı sayacımız bulunsun, birine tıkladığımızda
380 | hem kendi değerini artırsın, hem de diğer sayacın değerini bir azaltsın. Şimdi
381 | burada düşünmemiz gereken konu şu: Veriyi, yani `state`'i nerede saklamalıyız?
382 | Çocuk bileşenlerin kendilerine ait birer `state`'i mi olsun, yoksa ana bileşen her
383 | iki `state`'i de kendisinde tutup bunları parametre olarak çocuklara mı aktarsın?
384 |
385 | Bu soruya döneceğiz, ama bir de chat uygulamasına dönüp aynı soruyu orada
386 | soralım: Burada arkadaş listesi hangi bileşende tutulmalı, ana bileşende mi,
387 | çevrimiçi sayısını gösteren bileşende mi, yoksa arkadaşların isimlerinin
388 | gösterildiği bileşende mi? Aynı veriye hem isim listesinde, hem de sayı
389 | bileşeninde gereksinim duyulduğu için bu verinin en tepede tutulup aşağıya doğru
390 | aktarılması en mantıklısı.
391 |
392 | Sayaç uygulamasına dönelim, burada da verinin ana bileşende tutulup çocuklara
393 | bir parametre olarak aktarılması daha mantıklı. Bunun bir güzel yanı da tüm
394 | değişkenlerin veritabanı mantığına benzer şekilde merkezi bir yerde
395 | toplanması. Bu sayede çocuk bileşenler verinin yönetimi konusuyla çok
396 | ilgilenmemekte, basit veri gösterici bileşenlere dönüşmekte.
397 |
398 | Peki bu durumda çocuk bileşenler verinin değişmesi gerektiğini ana bileşene
399 | nasıl haber verecek? İşte bu noktada parametre olarak çocuklara aktarılan
400 | callbackler ya da event handler'lar devreye giriyor. Çocuk bileşenlere ana
401 | bileşenden önemli bir olay olduğunda çalıştırması gereken kod bir parametre
402 | olarak aktarılıyor. Çocuk bileşen çalışacak kodun içeriğini bilmek zorunda
403 | değil, hatta bilmemesi daha da iyi, tek yapması gereken tepedeki bileşenden
404 | gelecek fonksiyonu çağırması gerektiği.
405 |
406 | Dolayısıyla React'teki veri akışını şu şekilde özetleyebiliriz: Veri tepeden
407 | aşağı doğru tek yönlü akar, aşağıdaki bileşenler değişiklikleri tepeye geri
408 | arama (callback) fonksiyonları ile haber verir, bu haber ile tepedeki bileşenler
409 | veriyi değiştirir ve yeni veriyi tepeden aşağı aktarır. React de veri
410 | değişikliğini fark ederek veri ile görüntüyü senkronize eder.
411 |
412 | Şimdi bu metodolojiyi kullanarak iki sayaçlı uygulamamızı yazalım, öncelikle
413 | görmemiz gereken artık sayaçların değerlerini `state`'ten değil `props`'tan
414 | aldıkları ve düğmelere tıklandığında tepeden hangi kod aktarılırsa onun
415 | çalıştırıldığı:
416 |
417 | ```js
418 | var Sayac = React.createClass({
419 |
420 | render: function () {
421 | return (
422 |
423 | Sayaca {this.props.sayac} kez tıkladınız.
424 | {10 - this.props.sayac} kez daha tıklamalısınız.
425 |
426 |