Review on api/refs-api

Author: GuiDevloper

src/api/refs-api.md

@@ -1,10 +1,10 @@
 # Refs
 
-> Esta seção usa a sintaxe [single-file component](../guide/single-file-component.html) para os exemplos de código
+> Esta seção usa a sintaxe [componente single-file](../guide/single-file-component.html) para os exemplos de código
 
 ## `ref`
 
-Assume um valor interno e retorna um objeto "ref" reativo e mutável. O objeto "ref" tem uma única propriedade `.value` que aponta para o valor interno
+Assume um valor interno e retorna um objeto referência (ref) reativo e mutável. O objeto referência tem uma única propriedade `.value` que aponta para o valor interno.
 
 **Exemplo:**
 
@@ -16,7 +16,7 @@ count.value++
 console.log(count.value) // 1
 ```
 
-Se um objeto for atribuído como um valor "ref", o objeto se tornará profundamente reativo pelo método [reativo](./basic-reactivity.html#reactive).
+Se um objeto for atribuído como um valor de `ref`, o objeto se tornará profundamente reativo pelo método [`reactive`](./basic-reactivity.html#reactive).
 
 **Tipando:**
 
@@ -28,15 +28,15 @@ interface Ref<T> {
 function ref<T>(value: T): Ref<T>
 ```
 
-Às vezes, podemos precisar especificar tipos complexos para o valor interno de um "ref". Podemos fazer isso de forma sucinta passando um argumento genérico ao chamar `ref` para substituir a inferência padrão:
+Às vezes, podemos precisar especificar tipos complexos para o valor interno de uma referência. Podemos fazer isso de forma sucinta passando um argumento genérico ao chamar `ref` para substituir a inferência padrão:
 
 ```ts
-const foo = ref<string | number>('foo') // tipo foo: Ref<string | number>
+const foo = ref<string | number>('foo') // tipo de foo: Ref<string | number>
 
 foo.value = 123 // ok!
 ```
 
-Se o tipo da "generic" for desconhecido, é recomendado converter `ref` em` Ref<T>`:
+Se o tipo do genérico for desconhecido, é recomendado converter `ref` em ` Ref<T>`:
 
 ```js
 function useState<State extends string>(initial: State) {
@@ -47,17 +47,17 @@ function useState<State extends string>(initial: State) {
 
 ## `unref`
 
-Retorna o valor interno se o argumento for um [`ref`](#ref), caso contrário, retorna o próprio argumento. Esta é uma "sugar function" para `val = isRef(val) ? val.value : val`.
+Retorna o valor interno se o argumento for um [`ref`](#ref), caso contrário, retorna o próprio argumento. Esta é uma _sugar function_ para `val = isRef(val) ? val.value : val`.
 
 ```js
 function useFoo(x: number | Ref<number>) {
-  const unwrapped = unref(x) // unwrapped é garantido ser number agora
+  const unwrapped = unref(x) // unwrapped é garantido ser número agora
 }
 ```
 
 ## `toRef`
 
-Pode ser usado para criar um [`ref`](#ref) para uma propriedade em um objeto reativo de origem. O "ref" pode então ser passado, mantendo a conexão reativa com sua propriedade de origem.
+Pode ser usado para criar um [`ref`](#ref) de uma propriedade originária de um objeto reativo. A referência pode então ser transmitida, mantendo a conexão reativa com sua propriedade de origem.
 
 ```js
 const state = reactive({
@@ -74,7 +74,7 @@ state.foo++
 console.log(fooRef.value) // 3
 ```
 
-`toRef` é útil quando você deseja passar o "ref" de um objeto para uma função de composição:
+`toRef` é útil quando você deseja passar a referência de uma propriedade para uma função de composição:
 
 ```js
 export default {
@@ -104,15 +104,15 @@ Tipo de stateAsRefs:
 }
 */
 
-// O ref e a propriedade original estão "vinculados"
+// A referência e a propriedade original estão "vinculadas"
 state.foo++
 console.log(stateAsRefs.foo.value) // 2
 
 stateAsRefs.foo.value++
 console.log(state.foo) // 3
 ```
 
-`toRefs` é útil ao retornar um objeto reativo de uma função de composição para que o componente de consumo possa desestruturar/espalhar o objeto retornado sem perder a reatividade:
+`toRefs` é útil ao retornar um objeto reativo de uma função de composição para que o componente consumidor possa desestruturar/espalhar o objeto retornado sem perder a reatividade:
 
 ```js
 function useFeatureX() {
@@ -123,13 +123,13 @@ function useFeatureX() {
 
   // lógica operando no estado
 
-  // converter para "refs" ao retornar
+  // converter para referências ao retornar
   return toRefs(state)
 }
 
 export default {
   setup() {
-    // pode-se desestruturar sem perder a reatividade
+    // pode desestruturar sem perder a reatividade
     const { foo, bar } = useFeatureX()
 
     return {
@@ -142,13 +142,13 @@ export default {
 
 ## `isRef`
 
-Verifica se um valor é um objeto "ref".
+Verifica se um valor é um objeto referência.
 
 ## `customRef`
 
-Cria uma "ref" personalizada com controle explícito sobre seu rastreamento de dependência e acionamento de atualizações. Ele espera uma função de fábrica, que recebe as funções `track` e` trigger` como argumentos e deve retornar um objeto com `get` e` set`.
+Cria uma referência personalizada com controle explícito sobre seu rastreamento de dependência e acionamento de atualizações. Ele espera uma função fábrica, que recebe as funções `track` e` trigger` como argumentos e deve retornar um objeto com `get` e` set`.
 
-- Exemplo usando uma "ref" personalizada para implementar debounce (prática que visa diminuir a quantidade de eventos disparados) com `v-model`:
+- Exemplo usando uma referência personalizada para implementar _debounce_ (prática que visa diminuir a quantidade de eventos disparados) com `v-model`:
 
   ```html
   <input v-model="text" />
@@ -177,7 +177,7 @@ Cria uma "ref" personalizada com controle explícito sobre seu rastreamento de d
   export default {
     setup() {
       return {
-        text: useDebouncedRef('hello')
+        text: useDebouncedRef('olá')
       }
     }
   }
@@ -199,17 +199,17 @@ type CustomRefFactory<T> = (
 
 ## `shallowRef`
 
-Cria uma "ref" que rastreia sua própria mutação `.value`, mas não torna seu valor reativo.
+Cria uma referência que rastreia a mutação do seu próprio `.value`, mas não torna seu valor reativo.
 
 ```js
 const foo = shallowRef({})
-// mutating the ref's value is reactive
+// alterar o valor da referência é reativo
 foo.value = {}
-// but the value will not be converted.
+// mas o "value" não será convertido.
 isReactive(foo.value) // false
 ```
 
-**Veja também**: [Criação de valores reativos autônomos como `refs`](../guide/reactivity-fundamentals.html#creating-standalone-reactive-values-as-refs)
+**Veja também**: [Criação de Valores Reativos Avulsos como `refs`](../guide/reactivity-fundamentals.html#criacao-de-valores-reativos-avulsos-como-refs)
 
 ## `triggerRef`
 
@@ -220,16 +220,16 @@ const shallow = shallowRef({
   greet: 'Olá, mundo!'
 })
 
-// Mostra "Olá, mundo!" uma vez para a primeira execução
+// Mostra "Olá, mundo!" só na primeira execução
 watchEffect(() => {
   console.log(shallow.value.greet)
 })
 
-// Isso não acionará o efeito porque o "ref" é shallow
+// Isso não acionará o efeito porque a referência é rasa (shallow)
 shallow.value.greet = 'Olá, universo!'
 
 // Mostra "Olá, universo!"
 triggerRef(shallow)
 ```
 
-**Veja também:** [Computado e Assistido - watchEffect](./computed-watch-api.html#watcheffect)
+**Veja também:** [Computado e Observado - watchEffect](./computed-watch-api.html#watcheffect)