﻿1
00:00:01,270 --> 00:00:04,633
‫-: Baiklah, sekarang mari kita benar-benar bekerja dengan stream.

2
00:00:06,140 --> 00:00:09,363
‫Dan lagi, mulai dengan membuat file baru.

3
00:00:13,160 --> 00:00:16,370
‫Baiklah. Sekarang katakanlah bahwa

4
00:00:16,370 --> 00:00:20,440
‫untuk beberapa alasan dalam aplikasi kita, kita perlu membaca file teks

5
00:00:20,440 --> 00:00:23,800
‫besar dari sistem file, dan kemudian mengirimkannya ke klien.

6
00:00:23,800 --> 00:00:25,640
‫Jadi bagaimana kita melakukannya?

7
00:00:25,640 --> 00:00:28,650
‫Ada banyak cara dan kita akan menjelajahi beberapa

8
00:00:28,650 --> 00:00:31,630
‫di antaranya mulai dari yang paling

9
00:00:31,630 --> 00:00:35,320
‫dasar dan terus berlanjut ke cara terbaik untuk melakukan ini.

10
00:00:35,320 --> 00:00:39,090
‫Oke, jadi yang pertama adalah membutuhkan paket

11
00:00:39,090 --> 00:00:43,220
‫sistem file seperti sebelumnya, dan juga modul HTTP.

12
00:00:46,810 --> 00:00:49,600
‫Sekarang saya akan menunjukkan trik yang bagus, jadi

13
00:00:49,600 --> 00:00:52,183
‫mari kita buat server seperti ini.

14
00:00:53,770 --> 00:00:58,770
‫Jadi, membutuhkan paket HTTP, dan kemudian dari sini kita

15
00:00:59,530 --> 00:01:04,530
‫bisa langsung memanggil createServer. Jadi seperti ini.

16
00:01:05,550 --> 00:01:09,720
‫Oke, jadi hasil dari membutuhkan HTTP, adalah objek HTTP

17
00:01:09,720 --> 00:01:13,700
‫dan di sana kita bisa menggunakan createServer.

18
00:01:13,700 --> 00:01:16,690
‫Persis seperti ini, lalu simpan ke dalam variabel.

19
00:01:16,690 --> 00:01:19,620
‫Jadi itu adalah cara lain untuk membuat server baru

20
00:01:19,620 --> 00:01:21,943
‫dengan menulis kode yang lebih sedikit.

21
00:01:24,530 --> 00:01:29,530
‫Oke dan seperti sebelumnya mari kita daftar ke acara

22
00:01:29,970 --> 00:01:34,970
‫permintaan, dan tentukan panggilan balik kami di sini.

23
00:01:38,550 --> 00:01:41,190
‫Jadi, solusi pertama yang akan kita gunakan

24
00:01:41,190 --> 00:01:43,600
‫adalah yang termudah dan paling mudah.

25
00:01:43,600 --> 00:01:46,690
‫Yaitu dengan hanya membaca file ke dalam variabel, dan

26
00:01:46,690 --> 00:01:49,350
‫kemudian setelah selesai, kirimkan ke klien

27
00:01:49,350 --> 00:01:52,020
‫dengan cara yang sudah kita ketahui cara melakukannya.

28
00:01:52,020 --> 00:01:54,660
‫Jadi itu sangat sederhana, dan izinkan saya menulis

29
00:01:54,660 --> 00:01:58,410
‫komentar di sini untuk itu. Jadi solusi

30
00:01:58,410 --> 00:02:03,410
‫satu, dan fs. readFile lalu file pengujian kami lagi.

31
00:02:09,100 --> 00:02:12,720
‫Dan kemudian setelah itu siap, kami memanggil fungsi panggilan balik kami

32
00:02:12,720 --> 00:02:15,270
‫di mana kami memiliki akses ke data.

33
00:02:15,270 --> 00:02:17,703
‫Tapi pertama-tama mari kita tangani kesalahannya.

34
00:02:20,930 --> 00:02:24,880
‫Jadi misalnya jika file tersebut tidak ada, dan dalam hal

35
00:02:24,880 --> 00:02:28,250
‫ini kita cukup mencatat kesalahan ke konsol.

36
00:02:28,250 --> 00:02:32,340
‫Tetapi sebaliknya, kami hanya mengirim data ini kembali ke klien.

37
00:02:32,340 --> 00:02:35,280
‫Jadi kami menggunakan objek respons seperti yang kami

38
00:02:35,280 --> 00:02:40,280
‫lakukan sebelumnya berkali-kali, dan kemudian . akhir dan data.

39
00:02:40,610 --> 00:02:44,010
‫Jadi, selamatkan, dan itu adalah solusi pertama

40
00:02:44,010 --> 00:02:46,363
‫dan paling sederhana, bukan?

41
00:02:47,450 --> 00:02:50,460
‫Tapi sebelum kita bisa menguji ini, kita juga

42
00:02:51,470 --> 00:02:55,433
‫harus benar-benar memulai server, kan? Jadi kami menggunakan mendengarkan untuk melakukan itu.

43
00:02:56,770 --> 00:03:01,603
‫Dan portnya, sama seperti sebelumnya, lalu localhost dan

44
00:03:03,440 --> 00:03:05,253
‫fungsi callback kita.

45
00:03:12,960 --> 00:03:15,353
‫Oke, jadi mari kita lihat apakah ini benar-benar berfungsi.

46
00:03:24,080 --> 00:03:27,880
‫Dan tentu saja tidak, karena saya sebenarnya tidak

47
00:03:27,880 --> 00:03:29,023
‫memulai aplikasi.

48
00:03:31,260 --> 00:03:33,810
‫Jadi sekarang dikatakan mendengarkan, dan sekarang mari kita lihat apa

49
00:03:33,810 --> 00:03:34,853
‫yang terjadi di sini.

50
00:03:35,730 --> 00:03:39,565
‫Dan ini dia. Jadi file ini sangat

51
00:03:39,565 --> 00:03:42,960
‫besar, memiliki Node.js. js adalah yang terbaik

52
00:03:42,960 --> 00:03:46,080
‫yang ditulis di dalamnya seperti 10.000 kali atau sesuatu, jadi

53
00:03:46,080 --> 00:03:49,760
‫butuh banyak waktu sampai dimuat seluruhnya. Dan kami tidak terlalu tertarik

54
00:03:49,760 --> 00:03:53,010
‫untuk memuat semuanya, jadi mari hentikan ini di sini, dan

55
00:03:53,010 --> 00:03:56,430
‫kembali ke kode kita. Jadi ini berfungsi dengan baik,

56
00:03:56,430 --> 00:03:59,480
‫solusi yang kami miliki di sini dalam kasus ini,

57
00:03:59,480 --> 00:04:01,970
‫tetapi masalahnya adalah bahwa dengan solusi ini,

58
00:04:01,970 --> 00:04:04,660
‫node sebenarnya harus memuat seluruh file ke dalam

59
00:04:04,660 --> 00:04:07,610
‫memori, karena hanya setelah itu siap, ia kemudian dapat

60
00:04:07,610 --> 00:04:10,890
‫mengirim data itu . Sekarang ini adalah masalah ketika

61
00:04:10,890 --> 00:04:14,120
‫file besar, dan juga ketika ada banyak permintaan yang masuk

62
00:04:14,120 --> 00:04:17,240
‫ke server Anda. Karena proses

63
00:04:17,240 --> 00:04:21,464
‫simpul akan sangat cepat kehabisan sumber daya dan aplikasi

64
00:04:21,464 --> 00:04:25,740
‫Anda akan berhenti bekerja, semuanya akan macet, dan pengguna Anda

65
00:04:25,740 --> 00:04:28,940
‫tidak akan senang, percayalah. Jadi solusi ini di

66
00:04:28,940 --> 00:04:31,500
‫sini berfungsi ketika kita hanya membuat sesuatu yang

67
00:04:31,500 --> 00:04:33,990
‫kecil secara lokal untuk diri kita sendiri, misalnya.

68
00:04:33,990 --> 00:04:37,030
‫Tetapi dalam aplikasi siap produksi, Anda tidak dapat menggunakan

69
00:04:37,030 --> 00:04:41,270
‫potongan kode seperti ini. Oke? Jadi mari kita beralih ke

70
00:04:41,270 --> 00:04:44,070
‫solusi kedua kami. Dan dalam

71
00:04:44,070 --> 00:04:46,933
‫solusi itu, kami benar-benar akan menggunakan stream.

72
00:04:48,760 --> 00:04:52,420
‫Oke, jadi mari kita komentari bagian ini,

73
00:04:52,420 --> 00:04:55,890
‫dan beralih ke solusi nomor dua.

74
00:04:55,890 --> 00:04:58,270
‫Dan idenya di sini adalah bahwa

75
00:04:58,270 --> 00:05:03,000
‫kita sebenarnya tidak perlu membaca data ini dari file menjadi variabel, bukan?

76
00:05:03,000 --> 00:05:05,860
‫Kami tidak membutuhkan variabel ini. Jadi, alih-alih membaca

77
00:05:05,860 --> 00:05:09,310
‫data ke dalam variabel, dan harus menyimpan variabel itu ke

78
00:05:09,310 --> 00:05:12,710
‫dalam memori, kita hanya akan membuat aliran yang dapat dibaca.

79
00:05:12,710 --> 00:05:15,490
‫Kemudian saat kami menerima setiap potongan data,

80
00:05:15,490 --> 00:05:17,920
‫kami mengirimkannya ke klien sebagai

81
00:05:17,920 --> 00:05:20,440
‫respons yang merupakan aliran yang dapat ditulis.

82
00:05:20,440 --> 00:05:22,963
‫Sekarang izinkan saya menunjukkan kepada Anda bagaimana kita dapat menggunakan stream.

83
00:05:24,570 --> 00:05:28,823
‫Jadi kami membuat variabel, sebut saja readable di sini, dan

84
00:05:30,025 --> 00:05:33,437
‫kemudian dari sistem file lagi, kami menggunakan createReadStream

85
00:05:39,450 --> 00:05:44,450
‫Kemudian ini tentu saja kecil. Dan sekarang nama file yang

86
00:05:44,820 --> 00:05:49,820
‫kita coba baca. Jadi itu sekali lagi, file-test. txt.

87
00:05:50,580 --> 00:05:54,130
‫Oke, sempurna. Jadi ini sekarang membuat aliran dari

88
00:05:54,130 --> 00:05:57,090
‫data yang ada di file teks ini, yang kemudian dapat

89
00:05:57,090 --> 00:06:00,540
‫kita konsumsi sepotong demi sepotong. Jadi potongan demi potongan.

90
00:06:00,540 --> 00:06:03,350
‫Dan bagaimana kita melakukannya? Nah, ingat

91
00:06:03,350 --> 00:06:06,600
‫dari kuliah terakhir, bahwa setiap kali ada bagian

92
00:06:06,600 --> 00:06:10,020
‫data baru yang dapat kita konsumsi, aliran yang dapat

93
00:06:10,020 --> 00:06:13,070
‫dibaca memancarkan peristiwa data. Oke, jadi kita bisa

94
00:06:13,070 --> 00:06:15,313
‫menyimaknya, seperti yang kita pelajari di acara kuliah.

95
00:06:17,220 --> 00:06:22,220
‫Sangat mudah dibaca. pada, data, dan kemudian fungsi panggilan balik kami.

96
00:06:23,690 --> 00:06:26,910
‫Dan dalam fungsi panggilan balik kami, kami memiliki akses ke bagian

97
00:06:26,910 --> 00:06:28,993
‫data itu, jadi ke bagian itu.

98
00:06:30,160 --> 00:06:32,660
‫Biarkan saya menyebutnya chunk di sini dalam

99
00:06:33,540 --> 00:06:37,100
‫fungsi callback kami dan sekarang kami dapat menangani bagian data ini.

100
00:06:37,100 --> 00:06:39,060
‫Dan apa yang akan kita

101
00:06:39,060 --> 00:06:42,010
‫lakukan dengan potongan data ini, dengan potongan ini, adalah untuk

102
00:06:42,010 --> 00:06:45,210
‫benar-benar menulisnya ke aliran yang dapat ditulis, yang merupakan responsnya.

103
00:06:45,210 --> 00:06:50,210
‫Jadi, res. menulis, potongan ini. Oke?

104
00:06:51,250 --> 00:06:54,080
‫Jadi sekali lagi ingat bahwa respons ini adalah

105
00:06:54,080 --> 00:06:57,760
‫aliran yang dapat ditulis. Jadi seperti yang saya

106
00:06:57,760 --> 00:07:01,540
‫sebutkan di video sebelumnya, kan? Jadi sekarang kita dapat

107
00:07:01,540 --> 00:07:06,110
‫menggunakan metode tulis untuk mengirim setiap bagian data ke dalam aliran itu.

108
00:07:06,110 --> 00:07:08,920
‫Oke, dan dengan ini secara efektif

109
00:07:08,920 --> 00:07:12,230
‫kami mengalirkan konten dari file langsung ke klien.

110
00:07:12,230 --> 00:07:14,300
‫Oke, Anda mengerti perbedaannya?

111
00:07:14,300 --> 00:07:17,710
‫Jadi sebelumnya, kami menulis semuanya sekaligus ke dalam variabel, dan

112
00:07:17,710 --> 00:07:21,000
‫setelah itu siap, kami kemudian mengirim seluruh data itu

113
00:07:21,000 --> 00:07:23,927
‫kembali ke klien. Tetapi dalam

114
00:07:23,927 --> 00:07:26,370
‫situasi ini, dengan arus, itu berbeda.

115
00:07:26,370 --> 00:07:29,730
‫Kami mengalirkan file secara efektif, jadi kami

116
00:07:29,730 --> 00:07:32,670
‫membaca satu bagian file, dan segera

117
00:07:32,670 --> 00:07:37,440
‫setelah itu tersedia, kami mengirimkannya langsung ke klien, menggunakan metode tulis

118
00:07:37,440 --> 00:07:40,990
‫dari aliran respons. Kemudian ketika potongan

119
00:07:40,990 --> 00:07:44,290
‫berikutnya tersedia maka potongan itu akan dikirim,

120
00:07:44,290 --> 00:07:48,390
‫dan sampai seluruh file dibaca dan dialirkan ke klien.

121
00:07:48,390 --> 00:07:51,650
‫Oke, jadi sekarang tinggal menyelesaikan, kita juga harus

122
00:07:51,650 --> 00:07:54,680
‫menangani event ketika semua data sudah terbaca.

123
00:07:54,680 --> 00:07:57,430
‫Jadi ketika streaming pada dasarnya selesai membaca data

124
00:07:57,430 --> 00:07:58,263
‫dari file.

125
00:07:59,580 --> 00:08:03,113
‫Jadi pada kasus itu, acara akhir akan dipancarkan,

126
00:08:05,810 --> 00:08:10,040
‫dan segera setelah itu terjadi apa yang akan kita lakukan

127
00:08:10,040 --> 00:08:15,040
‫adalah melakukan res. akhir, oke? Dan kami menggunakan

128
00:08:16,430 --> 00:08:21,220
‫yang ini sebelumnya, jadi memanggil akhiri respons, kami melakukannya sebelumnya, kan?

129
00:08:21,220 --> 00:08:25,000
‫Dan sekarang, sebenarnya lebih masuk akal, karena sekali lagi, responsnya

130
00:08:25,000 --> 00:08:28,540
‫juga merupakan aliran, dan metode akhir memberi sinyal bahwa

131
00:08:28,540 --> 00:08:31,820
‫tidak ada lagi data yang akan ditulis ke aliran

132
00:08:31,820 --> 00:08:34,090
‫yang dapat ditulis ini, oke?

133
00:08:34,090 --> 00:08:39,080
‫Jadi di sini yang kami lakukan hanyalah menggunakan res. diakhiri dengan data di

134
00:08:39,080 --> 00:08:41,970
‫dalamnya. Jadi kami tidak melakukan

135
00:08:41,970 --> 00:08:44,490
‫streaming, yang kami lakukan hanyalah mengirim beberapa data.

136
00:08:44,490 --> 00:08:46,470
‫Sekarang dalam kasus ini, kami tidak

137
00:08:46,470 --> 00:08:50,000
‫meneruskan apa pun ke metode akhir ini, karena kami sudah mengirim

138
00:08:50,000 --> 00:08:52,930
‫semua data menggunakan res. menulis, potongan demi

139
00:08:52,930 --> 00:08:55,550
‫potongan, dan ketika aliran yang dapat dibaca

140
00:08:55,550 --> 00:08:59,220
‫selesai membaca filenya, yang harus kita lakukan adalah memberi sinyal

141
00:08:59,220 --> 00:09:03,330
‫bahwa kita siap menggunakan res. berakhir seperti ini, oke?

142
00:09:03,330 --> 00:09:07,910
‫Jadi kita selalu perlu menggunakan data ini dan acara akhir ini di sini satu

143
00:09:07,910 --> 00:09:11,160
‫demi satu seperti ini. Karena jika

144
00:09:11,160 --> 00:09:14,030
‫tidak, respon sebenarnya tidak akan pernah

145
00:09:14,030 --> 00:09:17,340
‫benar-benar dikirim ke klien. Oke, jadi tanpa bagian ini

146
00:09:17,340 --> 00:09:20,230
‫di sini, seluruh solusi ini tidak akan benar-benar berfungsi, oke?

147
00:09:20,230 --> 00:09:25,000
‫Jadi sekarang mari kita tutup yang ini, mulai

148
00:09:25,000 --> 00:09:30,000
‫lagi, dan baca lagi, dan jadi Anda melihat bahwa itu

149
00:09:30,880 --> 00:09:35,670
‫benar-benar berfungsi lagi, oke? Sekarang kali ini tanpa masalah yang kami

150
00:09:35,670 --> 00:09:39,400
‫miliki dengan solusi pertama. Mari kita hentikan ini di sini,

151
00:09:39,400 --> 00:09:41,770
‫dan kembali ke kode kita, karena saya ingin

152
00:09:41,770 --> 00:09:44,260
‫menunjukkan kepada Anda sekarang, bahwa ada peristiwa lain yang

153
00:09:44,260 --> 00:09:47,403
‫dapat kita dengarkan di aliran yang dapat dibaca, yaitu peristiwa kesalahan.

154
00:09:49,240 --> 00:09:54,240
‫Sangat mudah dibaca. on('error') dan dalam fungsi panggilan balik

155
00:09:55,000 --> 00:09:57,733
‫ini kita memiliki akses ke objek kesalahan.

156
00:09:58,810 --> 00:10:03,683
‫Oke jadi dalam hal ini kami akan mencatat kesalahan ini

157
00:10:05,970 --> 00:10:10,593
‫ke konsol, dan kemudian mengirim hasil file tidak ditemukan.

158
00:10:14,400 --> 00:10:17,283
‫Dan kita juga bisa mengatur kode status menjadi

159
00:10:20,160 --> 00:10:23,772
‫error, jadi 500 misalnya. Jadi biasanya otomatis di

160
00:10:23,772 --> 00:10:28,020
‫set ke 200 yang artinya oke, tapi dalam hal ini server

161
00:10:28,020 --> 00:10:31,420
‫kita error, artinya kita ingin mengirim kembali kode 500.

162
00:10:31,420 --> 00:10:36,213
‫Baiklah, jadi sekarang mari...

163
00:10:37,390 --> 00:10:39,313
‫Sebenarnya saya harus berhenti ini lagi.

164
00:10:45,520 --> 00:10:46,970
‫Jadi mari kita lihat apa yang terjadi sekarang.

165
00:10:53,001 --> 00:10:54,870
‫Oh kita sudah memiliki kesalahan di

166
00:10:54,870 --> 00:10:57,790
‫sini, res. status bukan fungsi. Dan

167
00:10:57,790 --> 00:11:00,872
‫ya, sebenarnya statusCode-nya. Jadi begini cara

168
00:11:00,872 --> 00:11:05,100
‫Anda menulisnya dalam express, jadi saya sudah terbiasa menulis begitu

169
00:11:05,100 --> 00:11:10,100
‫banyak, jadi express adalah simpul. js framework yang akan kita gunakan

170
00:11:10,370 --> 00:11:12,150
‫di sisa kursus dan

171
00:11:12,150 --> 00:11:15,060
‫secara ekspres Anda melakukannya seperti ini, dan

172
00:11:15,060 --> 00:11:18,420
‫itulah masalahnya. Jadi saya sudah agak terlalu

173
00:11:18,420 --> 00:11:19,673
‫terbiasa menulis ekspres.

174
00:11:22,460 --> 00:11:26,470
‫Jadi mari kita kembali, dan ya jadi sekarang kita melihat file tidak

175
00:11:26,470 --> 00:11:31,090
‫ditemukan, dan jika kita membuka alat dev, Anda melihat 500 kode kesalahan yang baru saja

176
00:11:31,090 --> 00:11:34,823
‫kita kirim sebelumnya, dan jika kita pergi ke tab jaringan, mari

177
00:11:36,440 --> 00:11:39,840
‫kita coba lagi, Anda memiliki kode status di sini juga.

178
00:11:39,840 --> 00:11:43,990
‫Jadi seperti yang kita lihat di salah satu video sebelumnya di

179
00:11:43,990 --> 00:11:47,130
‫bagian lain sebenarnya. Jadi beginilah cara kami

180
00:11:47,130 --> 00:11:49,343
‫memeriksa hal-hal semacam ini di tab jaringan.

181
00:11:52,530 --> 00:11:57,343
‫Baiklah, jadi mari kita perbaiki di sini, simpan, dan oke

182
00:11:58,300 --> 00:12:03,300
‫jadi ini bekerja dengan sempurna tetapi masih ada masalah dengan pendekatan

183
00:12:03,550 --> 00:12:06,240
‫ini yang baru saja saya tunjukkan

184
00:12:06,240 --> 00:12:09,360
‫kepada Anda. Dan masalahnya adalah

185
00:12:09,360 --> 00:12:12,240
‫aliran kami yang dapat dibaca, jadi aliran

186
00:12:12,240 --> 00:12:16,100
‫yang kami gunakan untuk membaca file dari disk, jauh lebih

187
00:12:16,100 --> 00:12:19,310
‫cepat daripada mengirimkan hasilnya dengan aliran respons yang

188
00:12:19,310 --> 00:12:22,910
‫dapat ditulis melalui jaringan. Dan ini akan membanjiri aliran

189
00:12:22,910 --> 00:12:27,360
‫respons, yang tidak dapat menangani semua data yang masuk ini dengan begitu cepat.

190
00:12:27,360 --> 00:12:29,920
‫Dan masalah ini disebut tekanan balik.

191
00:12:29,920 --> 00:12:33,510
‫Dan itu adalah masalah nyata yang bisa terjadi dalam situasi nyata.

192
00:12:33,510 --> 00:12:37,140
‫Jadi dalam kasus ini, tekanan balik terjadi ketika

193
00:12:37,140 --> 00:12:41,130
‫respons tidak dapat mengirim data secepat yang diterimanya dari

194
00:12:41,130 --> 00:12:43,620
‫file, apakah itu masuk akal?

195
00:12:43,620 --> 00:12:46,050
‫Jadi kita harus memperbaiki solusi itu,

196
00:12:46,050 --> 00:12:48,793
‫dan menghasilkan solusi yang lebih baik lagi.

197
00:12:50,130 --> 00:12:52,813
‫Jadi, kami akan membuat solusi

198
00:12:55,120 --> 00:12:57,527
‫tiga, dan itu sebenarnya

199
00:12:57,527 --> 00:13:01,150
‫yang terakhir, Oke? Jadi tidak ada solusi lebih dari tiga.

200
00:13:01,150 --> 00:13:05,000
‫Jadi rahasianya di sini adalah benar-benar menggunakan operator pipa yang

201
00:13:05,000 --> 00:13:07,405
‫saya sebutkan di video terakhir, oke?

202
00:13:07,405 --> 00:13:12,405
‫Jadi operator pipa tersedia di semua aliran yang dapat dibaca, dan ini

203
00:13:12,960 --> 00:13:16,760
‫memungkinkan kita untuk menyalurkan output dari aliran yang

204
00:13:16,760 --> 00:13:20,660
‫dapat dibaca langsung ke input aliran yang dapat ditulis, oke?

205
00:13:20,660 --> 00:13:24,010
‫Dan itu kemudian akan memperbaiki masalah tekanan balik

206
00:13:24,010 --> 00:13:27,340
‫karena secara otomatis akan menangani kecepatan pada

207
00:13:27,340 --> 00:13:31,260
‫dasarnya data yang masuk, dan kecepatan data yang keluar.

208
00:13:31,260 --> 00:13:35,603
‫Oke, jadi mari kita dapatkan aliran yang dapat dibaca di sini.

209
00:13:38,290 --> 00:13:41,290
‫Oke, jadi itu adalah aliran yang dapat dibaca,

210
00:13:41,290 --> 00:13:45,253
‫dan sekarang yang harus kita lakukan adalah mengambil aliran yang dapat

211
00:13:46,280 --> 00:13:50,650
‫dibaca, menggunakan metode pipa di atasnya, dan kemudian memasukkan aliran yang dapat

212
00:13:50,650 --> 00:13:53,900
‫ditulis dan itulah jawabannya. Dan itu sebenarnya.

213
00:13:53,900 --> 00:13:57,460
‫Itu saja yang harus kita lakukan untuk solusi ini, oke?

214
00:13:57,460 --> 00:13:59,960
‫Jadi selalu berfungsi seperti ini, izinkan

215
00:13:59,960 --> 00:14:04,960
‫saya menulisnya di sini sebagai komentar. Jadi pada dasarnya kita membutuhkan sumber yang dapat

216
00:14:06,040 --> 00:14:09,310
‫dibaca, oke jadi sekali lagi ini hanya untuk menjelaskannya kepada Anda,

217
00:14:09,310 --> 00:14:12,330
‫kemudian kita dapat menggunakan pipa di atasnya, dan di sini

218
00:14:12,330 --> 00:14:17,010
‫kita harus meletakkan tujuan yang dapat ditulis. Jadi, dari sinilah data kita

219
00:14:17,010 --> 00:14:19,980
‫berasal, dan itu harus berupa aliran yang dapat

220
00:14:19,980 --> 00:14:24,980
‫dibaca, dan data itu kemudian dapat kita salurkan ke tujuan yang dapat ditulis.

221
00:14:25,060 --> 00:14:29,520
‫Jadi dalam hal ini tujuan kita adalah responnya, oke?

222
00:14:29,520 --> 00:14:32,790
‫Sekarang aliran ini sebenarnya bisa menjadi aliran dupleks atau

223
00:14:32,790 --> 00:14:35,790
‫transformasi juga, tetapi yang penting adalah kita dapat

224
00:14:35,790 --> 00:14:38,930
‫menulis ke aliran. Dan respon tentu

225
00:14:38,930 --> 00:14:42,553
‫saja adalah aliran seperti itu. Jadi kita tentu bisa

226
00:14:42,553 --> 00:14:45,560
‫menulis ke respon yang akan dikirim ke klien, oke?

227
00:14:45,560 --> 00:14:48,890
‫Jadi operator pipa secara otomatis memecahkan masalah

228
00:14:48,890 --> 00:14:51,860
‫tekanan balik yang kami alami sebelumnya.

229
00:14:51,860 --> 00:14:54,720
‫Dan ini juga merupakan solusi yang jauh

230
00:14:54,720 --> 00:14:58,000
‫lebih elegan dan mudah. Jadi apa yang kami

231
00:14:58,000 --> 00:15:01,020
‫lakukan di sini sebelumnya hanya untuk menunjukkan kepada

232
00:15:01,020 --> 00:15:05,290
‫Anda semua cara di mana kami dapat menggunakan metode dan peristiwa aliran

233
00:15:05,290 --> 00:15:08,520
‫untuk membuat solusi semacam ini dan tentu saja mereka

234
00:15:08,520 --> 00:15:12,044
‫memiliki banyak kasus penggunaan, tetapi dalam masalah seperti ini, pipa

235
00:15:12,044 --> 00:15:16,060
‫operator sebenarnya adalah solusi terbaik. Di balik layar sebenarnya ia melakukan sesuatu

236
00:15:16,060 --> 00:15:17,950
‫seperti ini di sini, tetapi sekali

237
00:15:17,950 --> 00:15:20,880
‫lagi dengan cara yang jauh lebih mudah bagi kita untuk

238
00:15:20,880 --> 00:15:23,000
‫menulis, karena ia menangani semua hal secara

239
00:15:23,000 --> 00:15:26,500
‫internal di belakang layar. Jadi saya percaya bahwa pipa

240
00:15:26,500 --> 00:15:30,370
‫di sini sebenarnya adalah cara termudah untuk mengonsumsi dan menulis aliran,

241
00:15:30,370 --> 00:15:33,410
‫kecuali tentu saja, seperti yang saya sebutkan, kami membutuhkan

242
00:15:33,410 --> 00:15:36,670
‫solusi yang lebih khusus. Dan kemudian, kita harus

243
00:15:36,670 --> 00:15:39,910
‫menggunakan alat yang lebih rumit ini seperti kejadian dan

244
00:15:39,910 --> 00:15:43,633
‫metode yang saya tunjukkan sebelumnya. Baiklah, jadi untuk

245
00:15:45,270 --> 00:15:50,270
‫menyelesaikannya, mari keluar dari proses di sini, mulai lagi, dan tentu

246
00:15:50,370 --> 00:15:54,350
‫saja, lihat apakah itu masih berfungsi, yang berhasil.

247
00:15:54,350 --> 00:15:58,340
‫Jadi, pekerjaan kita selesai di sini. Jadi kita sudah selesai dengan

248
00:15:58,340 --> 00:16:01,343
‫kuliah ini, dan siap untuk langsung ke yang berikutnya.

