Portuguese Translation (#1302)

* First Commit * Translated the inital files * Translated the api docs * Translate some files * Translate some more files * One more file * made some fixes in translation * made some fixes in translation * make some fixes and translates * Add more translations and fixes * Add more translations and fixes * Add the last file translated
vuejs · Jul 14, 2018 · 7eeeca0 · 7eeeca0
1 parent 951b2a7
commit 7eeeca0
Show file tree

Hide file tree

Showing 17 changed files with 1,932 additions and 0 deletions.
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
@@ -24,6 +24,11 @@ module.exports = {
       lang: 'kr',
       title: 'Vuex',
       description: 'Vue.js의 중앙 상태 관리'
+    },
+    '/ptbr/': {
+      lang: 'pt-BR',
+      title: 'Vuex',
+      description: 'Gerenciamento de Estado Centralizado para Vue.js'
     }
   },
   serviceWorker: true,
@@ -234,6 +239,47 @@ module.exports = {
           '/kr/guide/testing',
           '/kr/guide/hot-reload'
         ]
+      },
+      '/ptbr/': {
+        label: 'Português',
+        selectText: 'Idiomas',
+        editLinkText: 'Edite esta página no GitHub',
+        nav: [
+          {
+            text: 'Guia',
+            link: '/ptbr/guide/'
+          },
+          {
+            text: 'Referência da API',
+            link: '/ptbr/api/'
+          },
+          {
+            text: 'Notas da Versão',
+            link: 'https://github.com/vuejs/vuex/releases'
+          }
+        ],
+        sidebar: [
+          '/ptbr/installation',
+          '/ptbr/',
+          '/ptbr/guide/',
+          {
+            title: 'Conceitos Básicos',
+            collapsable: false,
+            children: [
+              '/ptbr/guide/state',
+              '/ptbr/guide/getters',
+              '/ptbr/guide/mutations',
+              '/ptbr/guide/actions',
+              '/ptbr/guide/modules'
+            ]
+          },
+          '/ptbr/guide/structure',
+          '/ptbr/guide/plugins',
+          '/ptbr/guide/strict',
+          '/ptbr/guide/forms',
+          '/ptbr/guide/testing',
+          '/ptbr/guide/hot-reload'
+        ]
       }
     }
   }

diff --git a/docs/ptbr/README.md b/docs/ptbr/README.md
@@ -0,0 +1,63 @@
+# O que é Vuex?
+
+O Vuex é um **padrão de gerenciamento de estado + biblioteca** para aplicativos Vue.js. Ele serve como um _store_ centralizado para todos os componentes em uma aplicação, com regras garantindo que o estado só possa ser mutado de forma previsível. Ele também se integra com a extensão oficial [Vue devtools](https://github.com/vuejs/vue-devtools) para fornecer recursos avançados sem configurações adicionais, como depuração viajando pelo histórico de estado (_time travel_) e exportação/importação de registros de estado em determinado momento.
+
+### O que é um "Padrão de Gerenciamento do Estado"?
+
+Vamos começar com um aplicativo simples de contador Vue:
+
+``` js
+new Vue({
+  // state
+  data () {
+    return {
+      count: 0
+    }
+  },
+  // view
+  template: `
+    <div>{{ count }}</div>
+  `,
+  // actions
+  methods: {
+    increment () {
+      this.count++
+    }
+  }
+})
+```
+
+É um aplicativo independente com as seguintes partes:
+
+- O **estado** (_state_), que é a fonte da verdade que direciona nosso aplicativo;
+- A **_view_**, que é apenas um mapeamento declarativo do **estado**;
+- As **ações** (_actions_), que são as possíveis maneiras pelas quais o estado pode mudar em reação às interações dos usuários da **_view_**.
+
+Esta é uma representação extremamente simples do conceito de "fluxo de dados unidirecional" (_one-way_):
+
+<p style="text-align: center; margin: 2em">
+  <img style="width:100%;max-width:450px;" src="/flow.png">
+</p>
+
+No entanto, a simplicidade é quebrada rapidamente quando temos **vários componentes que compartilham um estado comum**:
+
+- Múltiplas _views_ podem depender do mesmo pedaço de estado.
+- Ações de diferentes _views_ podem precisar mudar o mesmo pedaço de estado.
+
+Para o problema um, passar propriedades pode ser entediante para componentes profundamente aninhados e simplesmente não funcionam para componentes irmãos. Para o problema dois, frequentemente nos encontramos recorrendo a soluções como alcançar referências diretas da instância pai/filho ou tentar alterar e sincronizar várias cópias do estado por meio de eventos. Ambos os padrões são frágeis e levam rapidamente a um código não-sustentável.
+
+Então, por que não extraímos o estado compartilhado dos componentes, e o gerenciamos em um _singleton_ global? Com isso, nossa árvore de componentes se torna uma grande "_view_", e qualquer componente pode acessar o estado ou acionar ações, não importando onde elas estejam na árvore!
+
+Além disso, definindo e separando os conceitos envolvidos no gerenciamento do estado e aplicando certas regras, também damos ao nosso código mais estrutura e sustentabilidade.
+
+Esta é a ideia básica por trás do Vuex, inspirada por [Flux](https://facebook.github.io/flux/docs/overview.html), [Redux](http://redux.js.org/) e [The Elm Architecture](https://guide.elm-lang.org/architecture/). Ao contrário dos outros padrões, o Vuex também é uma implementação de biblioteca adaptada especificamente para o Vue.js tirar proveito de seu sistema de reatividade granular para atualizações eficientes.
+
+![vuex](/vuex.png)
+
+### Quando usar o Vuex?
+
+Embora o Vuex nos ajude a lidar com o gerenciamento de estado compartilhado, ele também vem com o custo de mais conceitos e códigos repetitivos. É uma escolha de prós e contras entre produtividade de curto e longo prazo
+
+Se você nunca construiu um SPA em grande escala e for direto para o Vuex, ele pode parecer detalhado e desanimador. Isso é perfeitamente normal - se o seu aplicativo é simples, você provavelmente ficará bem sem o Vuex. Um simples [global event bus](https://br.vuejs.org/v2/guide/components.html#Comunicacao-Nao-Pai-Filho) pode ser tudo que você precisa. Mas, se você está criando um SPA de médio a grande porte, é provável que tenha encontrado situações que fazem você pensar em como lidar melhor com o estado fora de seus componentes do Vue, e o Vuex será o próximo passo natural para você. Há uma boa citação de Dan Abramov, o autor do Redux:
+
+> As bibliotecas _Flux_ são como óculos: você saberá quando precisar delas.
diff --git a/docs/ptbr/api/README.md b/docs/ptbr/api/README.md
@@ -0,0 +1,263 @@
+---
+sidebar: auto
+---
+
+# Referência da API
+
+## Vuex.Store
+
+``` js
+import Vuex from 'vuex'
+
+const store = new Vuex.Store({ ...options })
+```
+
+## Vuex.Store Opções do Construtor
+
+### estado
+
+- type: `Object | Function`
+
+  O objeto raiz de estado para o _store_ Vuex. [Detalhes](../guide/state.md)
+
+  Se você passar uma função que retorna um objeto, o objeto retornado é usado como o estado da raiz. Isso é útil quando você deseja reutilizar o objeto de estado, especialmente para reutilização de módulos. [Detalhes](../guide/modules.md#reutilizacao-do-modulo)
+
+### mutações
+
+- type: `{ [type: string]: Function }`
+
+  Registra mutações no _store_. A função do manipulador sempre recebe `estado` como o 1º argumento (será o estado local do módulo se definido em um módulo) e receberá um 2º argumento _payload_ se houver um.
+
+  [Detalhes](../guide/mutations.md)
+
+### ações
+
+- type: `{ [type: string]: Function }`
+
+  Registra ações no _store_. A função do manipulador recebe um objeto _context_ que expõe as seguintes propriedades:
+
+  ``` js
+  {
+    state,      // o mesmo que `store.state`, ou estado local se estiver em módulos
+    rootState,  // o mesmo que `store.state`, apenas em módulos
+    commit,     // o mesmo que `store.commit`
+    dispatch,   // o mesmo que `store.dispatch`
+    getters,    // o mesmo que `store.getters`, ou com getters locais se estiver em módulos
+    rootGetters // o mesmo que `store.getters`, apenas em módulos
+  }
+  ```
+
+  E também recebe um 2º argumento _payload_ se houver um.
+
+  [Detalhes](../guide/actions.md)
+
+### getters
+
+- type: `{ [key: string]: Function }`
+
+  Registra _getters_ no _store_. A função _getter_ recebe os seguintes argumentos:
+
+  ```
+  state,     // será estado local do módulo se definido em um módulo.
+  getters    // o mesmo que store.getters
+  ```
+
+  Específico quando definido em um módulo
+
+  ```
+  state,       // será estado local do módulo se definido em um módulo.
+  getters,     // módulo de getters locais do módulo atual
+  rootState,   // estado global
+  rootGetters  // todos os getters
+  ```
+
+  Os _getters_ registrados estão expostos em _store.getters_.
+
+  [Detalhes](../guide/getters.md)
+
+### módulos
+
+- type: `Object`
+
+  Um objeto contendo sub módulos a serem incorporados no _store_, de forma que:
+
+  ``` js
+  {
+    key: {
+      state,
+      namespaced?,
+      mutations?,
+      actions?,
+      getters?,
+      modules?
+    },
+    ...
+  }
+  ```
+
+  Cada módulo pode conter `estado` e `mutações` semelhantes às opções raiz. O estado de um módulo será anexado ao estado da raiz do _store_ usando a chave do módulo. As mutações e _getters_ de um módulo receberão apenas o estado local do módulo como o 1º argumento em vez do estado da raiz e as ações do módulo _context.state_ também apontarão para o estado local.
+
+  [Detalhes](../guide/modules.md)
+
+### plugins
+
+- type: `Array<Function>`
+
+  Um _Array_ de funções de plug-in a serem aplicadas no _store_. O plug-in simplesmente recebe o _store_ como o único argumento e pode ouvir mutações (para persistência de dados de saída, registro ou depuração) ou mutações de despacho (para dados de entrada, por exemplo, websockets ou _observables_).
+
+  [Detalhes](../guide/plugins.md)
+
+### strict
+
+- type: `Boolean`
+- default: `false`
+
+  Força o _store_ Vuex em modo estrito. No modo estrito, qualquer mutação ao estado do Vuex fora dos manipuladores de mutação acusará um erro.
+
+  [Detalhes](../guide/strict.md)
+
+## Vuex.Store Propriedades da Instância
+
+### state
+
+- type: `Object`
+
+  O estado raiz. Apenas leitura.
+
+### getters
+
+- type: `Object`
+
+  Expõe os _getters_ registrados. Apenas leitura.
+
+## Vuex.Store Métodos da Instância
+
+### commit
+
+-  `commit(type: string, payload?: any, options?: Object)`
+-  `commit(mutation: Object, options?: Object)`
+
+  Confirma (ou faz um _Commit_ de) uma mutação. _options_ pode ter _root: true_ que permite confirmar mutações da raiz em [módulos namespaced](../guide/modules.md#namespacing). [Detalhes](../guide/mutations.md)
+
+### dispatch
+
+-  `dispatch(type: string, payload?: any, options?: Object)`
+-  `dispatch(action: Object, options?: Object)`
+
+  Despacha uma ação. _options_ pode ter _root: true_ que permite despachar ações para raiz em [módulos namespaced](../guide/modules.md#namespacing). Retorna um _Promise_ que resolve todos os manipuladores de ação acionados. [Detalhes](../guide/actions.md)
+
+### replaceState
+
+-  `replaceState(state: Object)`
+
+  Substitua o estado da raiz do _store_. Use isso apenas para fins de _hydration_ / _time-travel_.
+
+### watch
+
+-  `watch(fn: Function, callback: Function, options?: Object): Function`
+
+  Visualiza de forma reativa um valor de retorno de `fn`, e chama o _callback_ para o retorno de chamada quando o valor for alterado. O `fn` recebe o estado do _store_ como o 1º argumento, e os _getters_ como o 2º argumento. Aceita um objeto de opções opcional que leva as mesmas opções que o método _vm.$watch_ do Vue.
+
+  Para parar um _watch_, chame a função _unwatch_ retornada.
+
+### subscribe
+
+-  `subscribe(handler: Function): Function`
+
+  Assina as mutações do _store_. O `manipulador` é chamado após cada mutação e recebe o descritor de mutação e o estado pós-mutação como argumentos:
+
+  ``` js
+  store.subscribe((mutation, state) => {
+    console.log(mutation.type)
+    console.log(mutation.payload)
+  })
+  ```
+
+  Para cancelar a assinatura, chame a função _unsubscribe_ retornada.
+
+  Mais comumente usado em plugins. [Detalhes](../guide/plugins.md)
+
+### subscribeAction
+
+-  `subscribeAction(handler: Function): Function`
+
+  > Novo na 2.5.0
+
+  Assina as ações do _store_. O `manipulador` é chamado para cada ação despachada e recebe o descritor de ação e o estado atual do _store_ como argumentos:
+
+  ``` js
+  store.subscribeAction((action, state) => {
+    console.log(action.type)
+    console.log(action.payload)
+  })
+  ```
+
+  Para cancelar a assinatura, chame a função _unsubscribe_ retornada.
+
+  Mais comumente usado em plugins. [Detalhes](../guide/plugins.md)
+
+### registerModule
+
+-  `registerModule(path: string | Array<string>, module: Module, options?: Object)`
+
+  Registra um módulo dinâmico. [Detalhes](../guide/modules.md#registro-de-modulo-dinamico)
+
+  _options_ can have _preserveState: true_ que permite preservar o estado anterior. Útil com renderização do lado do servidor (_server-side-rendering_).
+
+### unregisterModule
+
+-  `unregisterModule(path: string | Array<string>)`
+
+  Cancela o registro de um módulo dinâmico. [Detalhes](../guide/modules.md#registro-de-modulo-dinamico)
+
+### hotUpdate
+
+-  `hotUpdate(newOptions: Object)`
+
+  Faz _Hot_ _swap_ de novas ações e mutações. [Detalhes](../guide/hot-reload.md)
+
+## Métodos Auxiliares dos Componentes
+
+### mapState
+
+-  `mapState(namespace?: string, map: Array<string> | Object<string | function>): Object`
+
+  Criar dados computados do componente que retornam a subárvore do _store_ Vuex. [Detalhes](../guide/state.md#o-auxiliar-mapstate)
+
+  O 1º argumento pode ser opcionalmente uma _String_ com _namespace_. [Detalhes](../guide/modules.md#usando-metodos-auxiliares-com-namespace)
+
+  O segundo objeto que compõem os argumentos pode ser uma função. `function(state: any)`
+
+### mapGetters
+
+-  `mapGetters(namespace?: string, map: Array<string> | Object<string>): Object`
+
+  Criar dados computados do componente que retornam o valor calculado de um _getter_. [Detalhes](../guide/getters.md#o-auxiliar-mapgetters)
+
+  O 1º argumento pode ser opcionalmente uma _String_ com _namespace_. [Detalhes](../guide/modules.md#usando-metodos-auxiliares-com-namespace)
+
+### mapActions
+
+-  `mapActions(namespace?: string, map: Array<string> | Object<string | function>): Object`
+
+  Criar opções de métodos nos componentes que despacham uma ação. [Detalhes](../guide/actions.md#acoes-de-despacho-em-componentes)
+
+  O 1º argumento pode ser opcionalmente uma _String_ com _namespace_. [Detalhes](../guide/modules.md#usando-metodos-auxiliares-com-namespace)
+
+  O segundo objeto que compõem os argumentos pode ser uma função. `function(dispatch: function, ...args: any[])`
+
+### mapMutations
+
+-  `mapMutations(namespace?: string, map: Array<string> | Object<string | function>): Object`
+
+  Criar opções de métodos nos componentes que confirmam (ou fazem um _commit_ de) uma mutação. [Detalhes](../guide/mutations.md#confirmando-ou-fazendo-commits-de-mutacoes-em-componentes)
+
+  O 1º argumento pode ser opcionalmente uma _String_ com _namespace_. [Detalhes](../guide/modules.md#usando-metodos-auxiliares-com-namespace)
+
+  O segundo objeto que compõem os argumentos pode ser uma função. `function(commit: function, ...args: any[])`
+
+### createNamespacedHelpers
+
+-  `createNamespacedHelpers(namespace: string): Object`
+
+  Cria um componente _namespaced_ dos métodos auxiliares. O objeto retornado possui _mapState_, _mapGetters_, _mapActions_ e _mapMutations_, que estão conectados com o dado _namespace_. [Detalhes](../guide/modules.md#usando-metodos-auxiliares-com-namespace)