Merge pull request #216 from LucasCastro99/patch-1

Tradução de "api/basic-reactivity.md"

Author: GuiDevloper

src/api/basic-reactivity.md

@@ -1,51 +1,51 @@
-# Basic Reactivity APIs
+# API's Básicas de Reatividade
 
-> This section uses [single-file component](../guide/single-file-component.html) syntax for code examples
+> Esta seção usa sintaxe de [componente de arquivo único](../guide/single-file-component.html) para exemplos de código
 
 ## `reactive`
 
-Returns a reactive copy of the object.
+Retorna uma cópia reativa do objeto.
 
 ```js
 const obj = reactive({ count: 0 })
 ```
 
-The reactive conversion is "deep"—it affects all nested properties. In the [ES2015 Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) based implementation, the returned proxy is **not** equal to the original object. It is recommended to work exclusively with the reactive proxy and avoid relying on the original object.
+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.
 
-**Typing:**
+**Digitando:**
 
 ```ts
 function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
 ```
 
 ## `readonly`
 
-Takes an object (reactive or plain) or a [ref](./refs-api.html#ref) and returns a readonly proxy to the original. A readonly proxy is deep: any nested property accessed will be readonly as well.
+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
 
 ```js
 const original = reactive({ count: 0 })
 
 const copy = readonly(original)
 
 watchEffect(() => {
-  // works for reactivity tracking
+  // realizando o rastreamento da reatividade
   console.log(copy.count)
 })
 
-// mutating original will trigger watchers relying on the copy
+// a mutação do "original" fará com que os observadores confiem na cópia
 original.count++
 
-// mutating the copy will fail and result in a warning
+// alterar a cópia irá falhar e resultará em um aviso
 copy.count++ // warning!
 ```
 
 ## `isProxy`
 
-Checks if an object is a proxy created by [`reactive`](#reactive) or [`readonly`](#readonly).
+Verifica se um objeto é um proxy criado por [`reactive`](#reactive) ou [`readonly`](#readonly).
 
 ## `isReactive`
 
-Checks if an object is a reactive proxy created by [`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 {
 }
 ```
 
-It also returns `true` if the proxy is created by [`readonly`](#readonly), but is wrapping another proxy created by [`reactive`](#reactive).
+Ele também retorna `true` se o proxy é 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'
     })
-    // readonly proxy created from plain object
+    // proxy "readonly"(somente de leitura) criado a partir de um objeto simples
     const plain = readonly({
       name: 'Mary'
     })
     console.log(isReactive(plain)) // -> false
 
-    // readonly proxy created from reactive proxy
+    // proxy "readonly"(somente de leitura) criado a partir de um proxy "reactive"
     const stateCopy = readonly(state)
     console.log(isReactive(stateCopy)) // -> true
   }
@@ -83,11 +83,11 @@ export default {
 
 ## `isReadonly`
 
-Checks if an object is a readonly proxy created by [`readonly`](#readonly).
+Verifica se um objeto é um proxy somente de leitura criado por [`readonly`](#readonly).
 
 ## `toRaw`
 
-Returns the raw, original object of a [`reactive`](#reactive) or [`readonly`](#readonly) proxy. This is an escape hatch that can be used to temporarily read without incurring proxy access/tracking overhead or write without triggering changes. It is **not** recommended to hold a persistent reference to the original object. Use with caution.
+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
 
 ```js
 const foo = {}
@@ -98,45 +98,45 @@ console.log(toRaw(reactiveFoo) === foo) // true
 
 ## `markRaw`
 
-Marks an object so that it will never be converted to a proxy. Returns the object itself.
+Marca um objeto para que nunca seja convertido em proxy. Retorna o próprio objeto.
 
 ```js
 const foo = markRaw({})
 console.log(isReactive(reactive(foo))) // false
 
-// also works when nested inside other reactive objects
+// também funciona quando aninhado dentro de outros objetos reativos
 const bar = reactive({ foo })
 console.log(isReactive(bar.foo)) // false
 ```
 
-::: warning
-`markRaw` and the shallowXXX APIs below allow you to selectively opt-out of the default deep reactive/readonly conversion and embed raw, non-proxied objects in your state graph. They can be used for various reasons:
+::: 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:
 
-- Some values simply should not be made reactive, for example a complex 3rd party class instance, or a Vue component object.
+- 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.
 
-- Skipping proxy conversion can provide performance improvements when rendering large lists with immutable data sources.
+- Ignorar a conversão de proxy pode fornecer melhorias de desempenho ao renderizar grandes listas com fontes de dados imutáveis.
 
-They are considered advanced because the raw opt-out is only at the root level, so if you set a nested, non-marked raw object into a reactive object and then access it again, you get the proxied version back. This can lead to **identity hazards** - i.e. performing an operation that relies on object identity but using both the raw and the proxied version of the same object:
+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:
 
 ```js
 const foo = markRaw({
   nested: {}
 })
 
 const bar = reactive({
-  // although `foo` is marked as raw, foo.nested is not.
+  // embora `foo` esteja marcado como bruto, foo.nested não está.
   nested: foo.nested
 })
 
 console.log(foo.nested === bar.nested) // false
 ```
 
-Identity hazards are in general rare. However, to properly utilize these APIs while safely avoiding identity hazards requires a solid understanding of how the reactivity system works.
+Riscos de identidade são geralmente raros. No entanto, para utilizar adequadamente essas APIs e ao mesmo tempo evitar riscos de identidade, é necessário um conhecimento sólido de como funciona o sistema de reatividade.
 :::
 
 ## `shallowReactive`
 
-Creates a reactive proxy that tracks reactivity of its own properties but does not perform deep reactive conversion of nested objects (exposes raw values).
+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({
   }
 })
 
-// mutating state's own properties is reactive
+// as próprias propriedades do estado mutante são reativas
 state.foo++
-// ...but does not convert nested objects
+// ...mas não às converte em objetos aninhados
 isReactive(state.nested) // false
-state.nested.bar++ // non-reactive
+state.nested.bar++ // não reativo
 ```
 
 ## `shallowReadonly`
 
-Creates a proxy that makes its own properties readonly, but does not perform deep readonly conversion of nested objects (exposes raw values).
+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).
 
 ```js
 const state = shallowReadonly({
@@ -165,9 +165,9 @@ const state = shallowReadonly({
   }
 })
 
-// mutating state's own properties will fail
+// as próprias propriedades do estado mutante irão falhar
 state.foo++
-// ...but works on nested objects
+// ...mas funciona em objetos aninhados
 isReadonly(state.nested) // false
-state.nested.bar++ // works
+state.nested.bar++ // funciona
 ```