Review on api/basic-reactivity

Author: GuiDevloper

src/api/basic-reactivity.md

@@ -1,6 +1,6 @@
 # API's Básicas de Reatividade
 
-> Esta seção usa sintaxe de [componente de arquivo único](../guide/single-file-component.html) para exemplos de código
+> Esta seção usa sintaxe de [Componente Single-File](../guide/single-file-component.html) para exemplos de código
 
 ## `reactive`
 
@@ -10,17 +10,17 @@ Retorna uma cópia reativa do objeto.
 const obj = reactive({ count: 0 })
 ```
 
-A conversão reativa é "profunda" - ela afeta todas as propriedades aninhadas. Na implementação baseada em [ES2015 Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy), o proxy retornado **não** é igual ao objeto original. Recomenda-se trabalhar exclusivamente com o proxy reativo e evitar depender do objeto original.
+A conversão reativa é "profunda" - ela afeta todas as propriedades aninhadas. Na implementação baseada no [Proxy da ES2015](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy), o *proxy* retornado **não** é igual ao objeto original. Recomenda-se trabalhar exclusivamente com o *proxy* reativo e evitar depender do objeto original.
 
-**Digitando:**
+**Tipagem:**
 
 ```ts
 function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
 ```
 
 ## `readonly`
 
-Captura um objeto (reativo ou simples) ou uma [ref](./refs-api.html#ref) e retorna um proxy somente leitura para o original. Um proxy somente leitura é profundo: qualquer propriedade aninhada acessada também será somente leitura
+Captura um objeto (reativo ou simples) ou um [ref](./refs-api.html#ref) e retorna um *proxy* somente leitura para o original. Um *proxy* somente leitura é profundo: qualquer propriedade aninhada acessada também será somente leitura.
 
 ```js
 const original = reactive({ count: 0 })
@@ -30,22 +30,22 @@ const copy = readonly(original)
 watchEffect(() => {
   // realizando o rastreamento da reatividade
   console.log(copy.count)
-})
+})  
 
-// a mutação do "original" fará com que os observadores confiem na cópia
+// a mutação do "original" executará observadores confiando na cópia
 original.count++
 
-// alterar a cópia irá falhar e resultará em um aviso
-copy.count++ // warning!
+// a mutação da cópia falhará e resultará em um aviso
+copy.count++ // aviso!
 ```
 
 ## `isProxy`
 
-Verifica se um objeto é um proxy criado por [`reactive`](#reactive) ou [`readonly`](#readonly).
+Verifica se um objeto é um *proxy* criado por [`reactive`](#reactive) ou [`readonly`](#readonly).
 
 ## `isReactive`
 
-Verifica se um objeto é um proxy reativo criado por [`reactive`](#reactive).
+Verifica se um objeto é um *proxy* reativo criado por [`reactive`](#reactive).
 
 ```js
 import { reactive, isReactive } from 'vue'
@@ -59,7 +59,7 @@ export default {
 }
 ```
 
-Ele também retorna `true` se o proxy é criado por [`readonly`](#readonly), mas está envolvendo outro proxy criado por [`reactive`](#reactive).
+Ele também retorna `true` se o *proxy* foi criado por [`readonly`](#readonly), mas está envolvendo outro *proxy* criado por [`reactive`](#reactive).
 
 ```js{7-15}
 import { reactive, isReactive, readonly } from 'vue'
@@ -68,13 +68,13 @@ export default {
     const state = reactive({
       name: 'John'
     })
-    // proxy "readonly"(somente de leitura) criado a partir de um objeto simples
+    // proxy "readonly" (somente leitura) criado de um objeto simples
     const plain = readonly({
       name: 'Mary'
     })
     console.log(isReactive(plain)) // -> false
 
-    // proxy "readonly"(somente de leitura) criado a partir de um proxy "reactive"
+    // proxy "readonly" (somente leitura) criado de um proxy "reactive"
     const stateCopy = readonly(state)
     console.log(isReactive(stateCopy)) // -> true
   }
@@ -83,11 +83,11 @@ export default {
 
 ## `isReadonly`
 
-Verifica se um objeto é um proxy somente de leitura criado por [`readonly`](#readonly).
+Verifica se um objeto é um *proxy* somente leitura criado por [`readonly`](#readonly).
 
 ## `toRaw`
 
-Retorna o objeto bruto original de um proxy [`reactive`](#reactive) ou [`readonly`](#readonly). Esta é uma "válvula de escape" que pode ser usada para ler temporariamente sem incorrer em acesso de proxy/sobrecarga de rastreamento ou gravação sem acionar alterações. **Não** é recomendado manter uma referência persistente ao objeto original. Use com cuidado
+Retorna o objeto bruto (*raw*) original de um *proxy* [`reactive`](#reactive) ou [`readonly`](#readonly). Esta é uma "válvula de escape" que pode ser usada para ler temporariamente sem incorrer em acesso de *proxy*/sobrecarga de rastreamento ou gravação sem acionar alterações. **Não** é recomendado manter uma referência persistente ao objeto original. Use com cuidado.
 
 ```js
 const foo = {}
@@ -98,7 +98,7 @@ console.log(toRaw(reactiveFoo) === foo) // true
 
 ## `markRaw`
 
-Marca um objeto para que nunca seja convertido em proxy. Retorna o próprio objeto.
+Marca um objeto para que nunca seja convertido em *proxy*. Retorna o próprio objeto.
 
 ```js
 const foo = markRaw({})
@@ -109,14 +109,14 @@ const bar = reactive({ foo })
 console.log(isReactive(bar.foo)) // false
 ```
 
-::: Atenção
-`markRaw` e as APIs shallowXXX abaixo permitem que você desative seletivamente a conversão profunda reativa/somente de leitura padrão e incorpore objetos brutos e não proxy em seu gráfico de estado. Eles podem ser usados por vários motivos:
+::: warning Aviso
+`markRaw` e as APIs *shallowXXX* abaixo permitem que você desative seletivamente a conversão profunda reativa/somente leitura padrão e incorpore objetos brutos e não-*proxy* em seu gráfico de estado. Eles podem ser usados por vários motivos:
 
 - Alguns valores simplesmente não devem se tornar reativos, por exemplo, uma instância complexa de classe de terceiros, ou um objeto de componente Vue.
 
-- Ignorar a conversão de proxy pode fornecer melhorias de desempenho ao renderizar grandes listas com fontes de dados imutáveis.
+- Ignorar a conversão de *proxy* pode fornecer melhorias de desempenho ao renderizar grandes listas com fontes de dados imutáveis.
 
-Eles são considerados avançados porque a desativação bruta está apenas no nível raiz, portanto, se você definir um objeto bruto aninhado e não marcado em um objeto reativo e acessá-lo novamente, obterá a versão em proxy de volta. Isso pode levar a **riscos de identidade** - ou seja, realizar uma operação que depende da identidade do objeto, mas usando a versão bruta e a versão proxy do mesmo objeto:
+Eles são considerados avançados porque a desativação bruta está apenas no nível raiz, portanto, se você definir um objeto bruto aninhado e não marcado em um objeto reativo e acessá-lo novamente, obterá a versão em *proxy* de volta. Isso pode levar a **riscos de identidade** - ou seja, realizar uma operação que depende da identidade do objeto, mas usando ambas a versão bruta e a versão *proxy* do mesmo objeto:
 
 ```js
 const foo = markRaw({
@@ -136,7 +136,7 @@ Riscos de identidade são geralmente raros. No entanto, para utilizar adequadame
 
 ## `shallowReactive`
 
-Cria um proxy reativo que rastreia a reatividade de suas próprias propriedades, mas não executa conversão reativa profunda de objetos aninhados (expõe valores brutos).
+Cria um *proxy* reativo que rastreia a reatividade de suas próprias propriedades, mas não executa conversão reativa profunda de objetos aninhados (expõe valores brutos).
 
 ```js
 const state = shallowReactive({
@@ -146,16 +146,16 @@ const state = shallowReactive({
   }
 })
 
-// as próprias propriedades do estado mutante são reativas
+// a mutação das próprias propriedades do "state" é reativa
 state.foo++
-// ...mas não às converte em objetos aninhados
+// ...mas não converte objetos aninhados
 isReactive(state.nested) // false
 state.nested.bar++ // não reativo
 ```
 
 ## `shallowReadonly`
 
-Cria um proxy que torna suas próprias propriedades somente de leitura, mas não executa a conversão somente leitura de profunda de objetos aninhados (expõe valores brutos).
+Cria um *proxy* que torna suas próprias propriedades em somente leitura, mas não executa a conversão somente leitura profunda de objetos aninhados (expõe valores brutos).
 
 ```js
 const state = shallowReadonly({
@@ -165,9 +165,9 @@ const state = shallowReadonly({
   }
 })
 
-// as próprias propriedades do estado mutante irão falhar
+// a mutação das próprias propriedades do "state" irão falhar
 state.foo++
 // ...mas funciona em objetos aninhados
 isReadonly(state.nested) // false
 state.nested.bar++ // funciona
-```
+```