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
*`render`: The render function for your component. React calls this function with the props and`ref`that your component received from its parent. The JSX you return will be the output of your component.
37
+
*`render`: Fungsi *render* untuk komponen Anda. React memanggil fungsi ini dengan *props* dan`ref`yang diterima komponen Anda dari induknya. JSX yang Anda kembalikan akan menjadi keluaran dari komponen Anda.
38
38
39
-
#### Returns {/*returns*/}
39
+
#### Mengembalikan {/*returns*/}
40
40
41
-
`forwardRef`returns a React component that you can render in JSX. Unlike React components defined as plain functions, a component returned by`forwardRef`is also able to receive a `ref` prop.
41
+
`forwardRef`mengembalikan komponen React yang dapat Anda *render* di JSX. Tidak seperti komponen React yang didefinisikan sebagai fungsi biasa, komponen yang dikembalikan oleh`forwardRef`juga dapat menerima *prop*`ref`.
42
42
43
-
#### Caveats {/*caveats*/}
43
+
#### Peringatan {/*caveats*/}
44
44
45
-
*In Strict Mode, React will**call your render function twice**in order to [help you find accidental impurities.](#my-initializer-or-updater-function-runs-twice)This is development-only behavior and does not affect production. If your render function is pure (as it should be), this should not affect the logic of your component. The result from one of the calls will be ignored.
45
+
*Dalam Mode Ketat, React akan**memanggil fungsi *render* Anda dua kali**untuk [membantu Anda menemukan ketidakmurnian yang tidak disengaja.](#my-initializer-or-updater-function-runs-twice)Ini adalah perilaku khusus pengembangan dan tidak mempengaruhi produksi. Jika fungsi *render* Anda murni (sebagaimana mestinya), hal ini tidak akan mempengaruhi logika komponen Anda. Hasil dari salah satu pemanggilan akan diabaikan.
46
46
47
47
48
48
---
49
49
50
50
### `render` function {/*render-function*/}
51
51
52
-
`forwardRef`accepts a render function as an argument. React calls this function with`props`and`ref`:
52
+
`forwardRef`menerima fungsi *render* sebagai argumen. React memanggil fungsi ini dengan`props`dan`ref`:
*`props`: The props passed by the parent component.
67
+
*`props`: *props* yang dioperkan oleh komponen induk.
68
68
69
-
*`ref`: The `ref`attribute passed by the parent component. The `ref`can be an object or a function. If the parent component has not passed a ref, it will be`null`. You should either pass the `ref`you receive to another component, or pass it to[`useImperativeHandle`.](/reference/react/useImperativeHandle)
69
+
*`ref`: Atribut `ref`yang dioper oleh komponen induk. `ref`dapat berupa objek atau fungsi. Jika komponen induk tidak mengoper *ref*, maka akan menjadi`null`. Anda harus mengoper `ref`yang Anda terima ke komponen lain, atau mengopernya ke[`useImperativeHandle`.](/reference/react/useImperativeHandle)
70
70
71
71
#### Returns {/*render-returns*/}
72
72
73
-
`forwardRef`returns a React component that you can render in JSX. Unlike React components defined as plain functions, the component returned by`forwardRef`is able to take a `ref` prop.
73
+
`forwardRef`mengembalikan komponen React yang dapat Anda *render* di JSX. Tidak seperti komponen React yang didefinisikan sebagai fungsi biasa, komponen yang dikembalikan oleh`forwardRef`dapat mengambil sebuah *prop*`ref`.
74
74
75
75
---
76
76
77
-
## Usage {/*usage*/}
77
+
## Penggunaan {/*usage*/}
78
78
79
-
### Exposing a DOM node to the parent component {/*exposing-a-dom-node-to-the-parent-component*/}
79
+
### Mengekspos DOM node ke komponen induk {/*exposing-a-dom-node-to-the-parent-component*/}
80
80
81
-
By default, each component's DOM nodes are private. However, sometimes it's useful to expose a DOM node to the parent--for example, to allow focusing it. To opt in, wrap your component definition into`forwardRef()`:
81
+
Secara *default*, setiap *DOM nodes* komponen bersifat privat. Namun, terkadang berguna untuk mengekspos *DOM node* ke induknya - misalnya, untuk memungkinkan pemfokusan. Untuk ikut serta, bungkus definisi komponen Anda ke dalam`forwardRef()`:
This `Form` component [passes a ref](/reference/react/useRef#manipulating-the-dom-with-a-ref) to `MyInput`. The `MyInput` component *forwards* that ref to the `<input>` browser tag. As a result, the `Form` component can access that `<input>` DOM node and call [`focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on it.
134
+
Komponen `MyInput` meneruskan *ref* tersebut ke tag peramban `<input>`. Hasilnya, komponen `Form` dapat mengakses *DOM node*`<input>` tersebut dan memanggil fungsi [`focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) di atasnya.
135
+
136
+
Perlu diingat bahwa mengekspos *ref* ke *DOM node* di dalam komponen Anda akan mempersulit untuk mengubah internal komponen Anda di kemudian hari. Anda biasanya akan mengekspos *DOM node* dari komponen tingkat rendah yang dapat digunakan kembali seperti tombol atau input teks, tetapi Anda tidak akan melakukannya untuk komponen tingkat aplikasi seperti avatar atau komentar.
135
137
136
-
Keep in mind that exposing a ref to the DOM node inside your component makes it harder to change your component's internals later. You will typically expose DOM nodes from reusable low-level components like buttons or text inputs, but you won't do it for application-level components like an avatar or a comment.
137
138
138
139
<Recipestitle="Examples of forwarding a ref">
139
140
140
-
#### Focusing a text input {/*focusing-a-text-input*/}
Clicking the button will focus the input. The`Form`component defines a ref and passes it to the `MyInput` component. The`MyInput`component forwards that ref to the browser `<input>`. This lets the `Form`component focus the`<input>`.
143
+
Mengeklik tombol akan memfokuskan input. Komponen`Form`mendefinisikan sebuah ref dan meneruskannya ke komponen `MyInput`. Komponen`MyInput`meneruskan *ref* tersebut ke tag peramban `<input>`. Hal ini memungkinkan komponen `Form`memfokuskan`<input>`.
143
144
144
145
<Sandpack>
145
146
@@ -191,9 +192,9 @@ input {
191
192
192
193
<Solution />
193
194
194
-
#### Playing and pausing a video {/*playing-and-pausing-a-video*/}
195
+
#### Memutar dan menjeda video {/*playing-and-pausing-a-video*/}
195
196
196
-
Clicking the button will call [`play()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play)and[`pause()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause)on a `<video>` DOM node. The `App` component defines a ref and passes it to the `MyVideoPlayer` component. The`MyVideoPlayer`component forwards that ref to the browser`<video>`node. This lets the `App` component play and pause the`<video>`.
197
+
Mengeklik tombol akan memanggil [`play()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play)dan[`pause()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause)pada *DOM node*`<video>`. Komponen `Aplikasi` mendefinisikan sebuah ref dan meneruskannya ke komponen `MyVideoPlayer`. Komponen`MyVideoPlayer`meneruskan *ref* tersebut ke *node*`<video>`pada peramban. Hal ini memungkinkan komponen `Aplikasi` memainkan dan menjeda`<video>`.
If that`MyInput`component forwards a ref to its `<input>`, a ref to`FormField`will give you that `<input>`:
272
+
Jika komponen`MyInput`meneruskan sebuah *ref* ke `<input>`, sebuah *ref* ke`FormField`akan memberi Anda `<input>` tersebut:
272
273
273
274
```js {2,5,10}
274
275
functionForm() {
@@ -289,8 +290,7 @@ function Form() {
289
290
}
290
291
```
291
292
292
-
The `Form` component defines a ref and passes it to `FormField`. The `FormField` component forwards that ref to `MyInput`, which forwards it to a browser `<input>` DOM node. This is how `Form` accesses that DOM node.
293
-
293
+
Komponen `Form` mendefinisikan sebuah *ref* dan meneruskannya ke `FormField`. Komponen `FormField` meneruskan *ref* tersebut ke `MyInput`, yang meneruskannya ke *DOM node*`<input>` peramban. Beginilah cara `Form` mengakses *DOM node* tersebut.
294
294
295
295
<Sandpack>
296
296
@@ -367,9 +367,10 @@ input, button {
367
367
368
368
---
369
369
370
-
### Exposing an imperative handle instead of a DOM node {/*exposing-an-imperative-handle-instead-of-a-dom-node*/}
370
+
### Mengekspos penanganan imperatif daripada DOM node {/*exposing-an-imperative-handle-instead-of-a-dom-node*/}
371
+
372
+
Daripada mengekspos seluruh *DOM node*, Anda dapat mengekspos objek khusus, yang disebut *imperative handle,* dengan sekumpulan metode yang lebih terbatas. Untuk melakukan ini, Anda harus mendefinisikan *ref* terpisah untuk menampung *DOM node*:
371
373
372
-
Instead of exposing an entire DOM node, you can expose a custom object, called an *imperative handle,* with a more constrained set of methods. To do this, you'd need to define a separate ref to hold the DOM node:
If some component gets a ref to `MyInput`, it will only receive your `{ focus, scrollIntoView }` object instead of the DOM node. This lets you limit the information you expose about your DOM node to the minimum.
408
+
Jika beberapa komponen mendapatkan referensi ke `MyInput`, komponen tersebut hanya akan menerima objek `{ focus, scrollIntoView }`, bukan *DOM node*. Hal ini memungkinkan Anda membatasi informasi yang Anda paparkan tentang *DOM node* seminimal mungkin.
408
409
409
410
<Sandpack>
410
411
@@ -463,25 +464,25 @@ input {
463
464
464
465
</Sandpack>
465
466
466
-
[Read more about using imperative handles.](/reference/react/useImperativeHandle)
467
+
[Baca lebih lanjut tentang menggunakan penanganan imperatif.](/reference/react/useImperativeHandle)
467
468
468
469
<Pitfall>
469
470
470
-
**Do not overuse refs.**You should only use refs for *imperative* behaviors that you can't express as props: for example, scrolling to a node, focusing a node, triggering an animation, selecting text, and so on.
471
+
**Jangan terlalu sering menggunakan refs.**Anda hanya boleh menggunakan *refs* untuk perilaku *imperatif* yang tidak dapat Anda ungkapkan sebagai *props*: misalnya, menggulir ke sebuah *node*, memfokuskan sebuah *node*, memicu sebuah animasi, memilih teks, dan sebagainya.
471
472
472
-
**If you can express something as a prop, you should not use a ref.**For example, instead of exposing an imperative handle like `{ open, close }`from a`Modal` component, it is better to take `isOpen`as a prop like`<Modal isOpen={isOpen} />`. [Effects](/learn/synchronizing-with-effects)can help you expose imperative behaviors via props.
473
+
**Jika Anda dapat mengekspresikan sesuatu sebagai *prop*, Anda tidak boleh menggunakan *ref*.**Sebagai contoh, daripada mengekspos penanganan imperatif seperti `{ open, close }`dari komponen`Modal`, lebih baik menggunakan `isOpen`sebagai *prop* seperti`<Modal isOpen={isOpen} />`. [Effects](/learn/synchronizing-with-effects)dapat membantu Anda mengekspos perilaku imperatif melalui *props*.
473
474
474
475
</Pitfall>
475
476
476
477
---
477
478
478
-
## Troubleshooting {/*troubleshooting*/}
479
+
## Pemecahan Masalah {/*troubleshooting*/}
479
480
480
-
### My component is wrapped in `forwardRef`, but the `ref`to it is always`null` {/*my-component-is-wrapped-in-forwardref-but-the-ref-to-it-is-always-null*/}
481
+
### Komponen saya dibungkus dengan `forwardRef`, tetapi `ref`ke komponen tersebut selalu`null` {/*my-component-is-wrapped-in-forwardref-but-the-ref-to-it-is-always-null*/}
481
482
482
-
This usually means that you forgot to actually use the `ref`that you received.
483
+
Hal ini biasanya berarti bahwa Anda lupa menggunakan `ref`yang Anda terima.
483
484
484
-
For example, this component doesn't do anything with its`ref`:
485
+
Sebagai contoh, komponen ini tidak melakukan apa pun dengan`ref`-nya:
If`showInput`is`false`, then the ref won't be forwarded to any node, and a ref to`MyInput`will remain empty. This is particularly easy to miss if the condition is hidden inside another component, like`Panel`in this example:
524
+
Jika`showInput`bernilai`false`, maka *ref* tidak akan diteruskan ke *node* mana pun, dan *ref* ke`MyInput`akan tetap kosong. Hal ini sangat mudah terlewatkan jika kondisi tersebut tersembunyi di dalam komponen lain, seperti`Panel`pada contoh ini:
0 commit comments