You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
On the server, call`renderToString`to render your app to HTML.
29
+
Di server, panggil`renderToString`untuk me-*render* aplikasi Anda ke HTML.
30
30
31
31
```js
32
32
import { renderToString } from'react-dom/server';
33
33
34
34
consthtml=renderToString(<App />);
35
35
```
36
36
37
-
On the client, call[`hydrateRoot`](/reference/react-dom/client/hydrateRoot)to make the server-generated HTML interactive.
37
+
Di klien, panggil[`hydrateRoot`](/reference/react-dom/client/hydrateRoot)untuk membuat HTML yang dibuat server interaktif.
38
38
39
-
[See more examples below.](#usage)
39
+
[Lihat lebih banyak contoh di bawah.](#usage)
40
40
41
-
#### Parameters {/*parameters*/}
41
+
#### Parameter {/*parameters*/}
42
42
43
-
*`reactNode`: A React node you want to render to HTML. For example, a JSX node like `<App />`.
43
+
*`reactNode`: Node React yang ingin Anda render ke HTML. Contohnya, sebuah elemen JSX seperti `<App />`
44
44
45
-
#### Returns {/*returns*/}
45
+
#### Kembalian {/*returns*/}
46
46
47
-
An HTML string.
47
+
Sebuah *string* HTML.
48
48
49
-
#### Caveats {/*caveats*/}
49
+
#### Peringatan {/*caveats*/}
50
50
51
-
*`renderToString`has limited Suspense support. If a component suspends, `renderToString`immediately sends its fallback as HTML.
51
+
*`renderToString`memiliki dukungan *Suspense* yang terbatas. Jika komponen ditangguhkan, `renderToString`secara langsung mengirimkan kembaliannya sebagai HTML.
52
52
53
-
*`renderToString`works in the browser, but using it in the client code is [not recommended.](#removing-rendertostring-from-the-client-code)
53
+
*`renderToString`bekerja di peramban, tapi menggunakannya di kode klien [tidak direkomendasikan.](#removing-rendertostring-from-the-client-code)
54
54
55
55
---
56
56
57
-
## Usage {/*usage*/}
57
+
## Penggunaan {/*usage*/}
58
58
59
-
### Rendering a React tree as HTML to a string {/*rendering-a-react-tree-as-html-to-a-string*/}
59
+
### Me-render pohon React sebagai HTML menjadi string {/*rendering-a-react-tree-as-html-to-a-string*/}
60
60
61
-
Call`renderToString`to render your app to an HTML string which you can send with your server response:
61
+
Panggil`renderToString`untuk me-*render* aplikasi Anda ke *string* HTML yang dapat Anda kirim dengan respons server Anda:
62
62
63
63
```js {5-6}
64
64
import { renderToString } from'react-dom/server';
65
65
66
-
//The route handler syntax depends on your backend framework
66
+
//Sintaksis pengendali rute bergantung pada framework backend Anda
67
67
app.use('/', (request, response) => {
68
68
consthtml=renderToString(<App />);
69
69
response.send(html);
70
70
});
71
71
```
72
72
73
-
This will produce the initial non-interactive HTML output of your React components. On the client, you will need to call [`hydrateRoot`](/reference/react-dom/client/hydrateRoot)to *hydrate* that server-generated HTML and make it interactive.
73
+
Ini akan menghasilkan output HTML non-interaktif awal dari komponen React Anda. Pada klien, Anda perlu memanggil [`hydrateRoot`](/reference/react-dom/client/hydrateRoot)untuk *menghidrasi* HTML yang dihasilkan server dan membuatnya interaktif.
74
74
75
75
76
76
<Pitfall>
77
77
78
-
`renderToString`does not support streaming or waiting for data. [See the alternatives.](#alternatives)
78
+
`renderToString`tidak mendukung *streaming* atau menunggu data. [Lihat beberapa alternatifnya.](#alternatives)
79
79
80
80
</Pitfall>
81
81
82
82
---
83
83
84
-
## Alternatives {/*alternatives*/}
84
+
## Alternatif {/*alternatives*/}
85
85
86
-
### Migrating from`renderToString`to a streaming method on the server {/*migrating-from-rendertostring-to-a-streaming-method-on-the-server*/}
86
+
### Migrasi dari`renderToString`ke metode streaming di server {/*migrating-from-rendertostring-to-a-streaming-method-on-the-server*/}
87
87
88
-
`renderToString`returns a string immediately, so it does not support streaming or waiting for data.
88
+
`renderToString`mengembalikan *string* dengan seketika, sehingga tidak mendukung *streaming* atau menunggu data.
89
89
90
-
When possible, we recommend using these fully-featured alternatives:
90
+
Saat memungkinkan, kami merekomendasikan untuk menggunakan alternatif yang berfitur lengkap ini:
91
91
92
-
*If you use Node.js, use[`renderToPipeableStream`.](/reference/react-dom/server/renderToPipeableStream)
93
-
*If you use Deno or a modern edge runtime with [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API), use[`renderToReadableStream`.](/reference/react-dom/server/renderToReadableStream)
92
+
*Jika Anda menggunakan Node.js, gunakan[`renderToPipeableStream`.](/reference/react-dom/server/renderToPipeableStream)
93
+
*Jika Anda menggunakan Deno atau *edge runtime* modern dengan [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams*API), gunakan[`renderToReadableStream`.](/reference/react-dom/server/renderToReadableStream)
94
94
95
-
You can continue using`renderToString`if your server environment does not support streams.
95
+
Anda dapat terus menggunakan`renderToString`jika *environment* server Anda tidak mendukung *streaming*.
96
96
97
97
---
98
98
99
-
### Removing`renderToString`from the client code {/*removing-rendertostring-from-the-client-code*/}
99
+
### Menghapus`renderToString`dari kode klien {/*removing-rendertostring-from-the-client-code*/}
100
100
101
-
Sometimes, `renderToString`is used on the client to convert some component to HTML.
101
+
Terkadang, `renderToString`digunakan pada klien untuk mengkonversi beberapa komponen ke HTML.
102
102
103
103
```js {1-2}
104
-
// 🚩 Unnecessary: using renderToString on the client
104
+
// 🚩 Tidak perlu: menggunakan renderToString pada klien
105
105
import { renderToString } from'react-dom/server';
106
106
107
107
consthtml=renderToString(<MyIcon />);
108
-
console.log(html); //For example, "<svg>...</svg>"
108
+
console.log(html); //Contohnya, "<svg>...</svg>"
109
109
```
110
110
111
-
Importing`react-dom/server`**on the client**unnecessarily increases your bundle size and should be avoided. If you need to render some component to HTML in the browser, use[`createRoot`](/reference/react-dom/client/createRoot)and read HTML from the DOM:
111
+
Mengimpor`react-dom/server`**pada klien**meningkatkan ukuran bundel Anda secara tidak perlu dan harus dihindari. Jika Anda perlu me-*render* beberapa komponen ke HTML di peramban, gunakan[`createRoot`](/reference/react-dom/client/createRoot)dan baca HTML dari DOM:
The[`flushSync`](/reference/react-dom/flushSync)call is necessary so that the DOM is updated before reading its [`innerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML) property.
125
+
Memanggil[`flushSync`](/reference/react-dom/flushSync)diperlukan agar DOM diperbarui sebelum membaca [`innerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Elemen/innerHTML).
126
126
127
127
---
128
128
129
-
## Troubleshooting {/*troubleshooting*/}
129
+
## Penyelesaian Masalah {/*troubleshooting*/}
130
130
131
-
### When a component suspends, the HTML always contains a fallback {/*when-a-component-suspends-the-html-always-contains-a-fallback*/}
131
+
### Saat komponen ditangguhkan, HTML selalu berisi fallback {/*when-a-component-suspends-the-html-always-contains-a-fallback*/}
132
132
133
-
`renderToString`does not fully support Suspense.
133
+
`renderToString`tidak sepenuhnya mendukung *Suspense*.
134
134
135
-
If some component suspends (for example, because it's defined with [`lazy`](/reference/react/lazy) or fetches data), `renderToString` will not wait for its content to resolve. Instead, `renderToString` will find the closest [`<Suspense>`](/reference/react/Suspense) boundary above it and render its `fallback` prop in the HTML. The content will not appear until the client code loads.
136
-
137
-
To solve this, use one of the [recommended streaming solutions.](#migrating-from-rendertostring-to-a-streaming-method-on-the-server) They can stream content in chunks as it resolves on the server so that the user sees the page being progressively filled in before the client code loads.
135
+
Jika beberapa komponen ditangguhkan (misalnya, karena ditentukan dengan [`lazy`](/reference/react/lazy) atau mengambil data), `renderToString` tidak akan menunggu kontennya diselesaikan. Sebagai gantinya, `renderToString` akan menemukan batas [`<Suspense>`](/reference/react/Suspense) terdekat di atasnya dan merender prop `fallback` di HTML. Konten tidak akan muncul hingga kode klien dimuat.
138
136
137
+
Untuk mengatasinya, gunakan salah satu [solusi *streaming* yang disarankan.](#migrating-from-rendertostring-to-a-streaming-method-on-the-server) Mereka dapat melakukan *streaming* konten dalam potongan-potongan saat diselesaikan di server sehingga pengguna melihat halaman diisi secara progresif sebelum kode klien dimuat.
0 commit comments