diff --git a/docs/guide-pt-BR/README.md b/docs/guide-pt-BR/README.md
index 1508e6581f..3b008cf8d4 100644
--- a/docs/guide-pt-BR/README.md
+++ b/docs/guide-pt-BR/README.md
@@ -21,7 +21,7 @@ Primeiros Passos
* [O que você precisa saber](start-prerequisites.md)
* [Instalando o Yii](start-installation.md)
* [Executando Aplicações](start-workflow.md)
-* [Fazendo um Hello-World](start-hello.md)
+* [Dizendo "Olá!"](start-hello.md)
* [Trabalhando com Formulários](start-forms.md)
* [Trabalhando com Bancos de Dados](start-databases.md)
* [Gerando Código com Gii](start-gii.md)
diff --git a/docs/guide-pt-BR/images/start-country-list.png b/docs/guide-pt-BR/images/start-country-list.png
index 375419414d..7939bbf059 100644
Binary files a/docs/guide-pt-BR/images/start-country-list.png and b/docs/guide-pt-BR/images/start-country-list.png differ
diff --git a/docs/guide-pt-BR/images/start-entry-confirmation.png b/docs/guide-pt-BR/images/start-entry-confirmation.png
index ed442a4c6e..13d6019f64 100644
Binary files a/docs/guide-pt-BR/images/start-entry-confirmation.png and b/docs/guide-pt-BR/images/start-entry-confirmation.png differ
diff --git a/docs/guide-pt-BR/images/start-form-validation.png b/docs/guide-pt-BR/images/start-form-validation.png
index f38652871d..64154464b1 100644
Binary files a/docs/guide-pt-BR/images/start-form-validation.png and b/docs/guide-pt-BR/images/start-form-validation.png differ
diff --git a/docs/guide-pt-BR/images/start-gii-country-grid.png b/docs/guide-pt-BR/images/start-gii-country-grid.png
index 746663c8f9..b1f23b2c01 100644
Binary files a/docs/guide-pt-BR/images/start-gii-country-grid.png and b/docs/guide-pt-BR/images/start-gii-country-grid.png differ
diff --git a/docs/guide-pt-BR/images/start-gii-country-update.png b/docs/guide-pt-BR/images/start-gii-country-update.png
index 51f2d38a32..6391a9f74f 100644
Binary files a/docs/guide-pt-BR/images/start-gii-country-update.png and b/docs/guide-pt-BR/images/start-gii-country-update.png differ
diff --git a/docs/guide-pt-BR/images/start-hello-world.png b/docs/guide-pt-BR/images/start-hello-world.png
index 30d1acad38..66984092f6 100644
Binary files a/docs/guide-pt-BR/images/start-hello-world.png and b/docs/guide-pt-BR/images/start-hello-world.png differ
diff --git a/docs/guide-pt-BR/start-databases.md b/docs/guide-pt-BR/start-databases.md
index 384080e2e3..32963da38e 100644
--- a/docs/guide-pt-BR/start-databases.md
+++ b/docs/guide-pt-BR/start-databases.md
@@ -1,102 +1,101 @@
Trabalhando com Bancos de Dados
===============================
-Esta seção descreverá como criar uma nova página que exibe dados de países
-buscados de uma tabela do banco de dados chamada `country`. Para isso, você
+Esta seção descreverá como criar uma nova página que exibe informações de países obtidos de uma tabela de banco de dados chamada `pais`. Para isso, você
configurará uma conexão com o banco de dados, criará uma classe de
-[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) (ação),
-e criará uma [view](structure-views.md) (visão).
+[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) e criará uma [view](structure-views.md).
-Através deste tutorial, você aprenderá como:
+Ao longo deste tutorial, você aprenderá como:
-* Configurar uma conexão de BD
-* Definir uma classe de Active Record
-* Consultar dados usando a classe de Active Record
-* Exibir dados em uma view de forma paginada
+* configurar uma conexão de BD
+* definir uma classe Active Record
+* consultar dados usando a classe de Active Record
+* exibir dados em uma view de forma paginada
Perceba que para terminar essa seção, você deve ter conhecimento e experiência
-básica usando bancos de dados. Em particular, você deveria saber como criar um
-banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
-de BD.
+básicos em bancos de dados. Em particular, você deve saber como criar um banco de dados e como executar instruções SQL usando uma ferramenta cliente de bancos de dados.
Preparando o Banco de Dados
---------------------------
-Para começar, crie um banco de dados chamado `yii2basic`, a partir do qual você
-buscará os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
-PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a muitas aplicações
-de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
+Para começar, crie um banco de dados chamado `yii2basico`, de onde você
+obterá os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
+PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a vários gerenciadores de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
na descrição a seguir.
-Em seguida, crie uma tabela chamada `country` no banco de dados, e insira alguns
-dados de exemplo. Você pode rodar as seguintes declarações SQL para fazê-lo:
+> Info: O MariaDB costumava ser um substituto transparente do MySQL. Isto já não é mais totalmente verdade. Caso você queira usar recursos avançados como suporte a `JSON` no MariaDB, por favor, consulte a extensão do MariaDB listada mais à frente.
+
+Em seguida, crie uma tabela chamada `pais` no banco de dados e insira alguns
+dados de exemplo. Você pode rodar as seguintes declarações SQL para fazer isso:
```sql
-CREATE TABLE `country` (
- `code` CHAR(2) NOT NULL PRIMARY KEY,
- `name` CHAR(52) NOT NULL,
- `population` INT(11) NOT NULL DEFAULT '0'
+CREATE TABLE `pais` (
+ `codigo` CHAR(2) NOT NULL PRIMARY KEY,
+ `nome` CHAR(52) NOT NULL,
+ `populacao` INT(11) NOT NULL DEFAULT '0'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-INSERT INTO `country` VALUES ('AU','Australia',24016400);
-INSERT INTO `country` VALUES ('BR','Brazil',205722000);
-INSERT INTO `country` VALUES ('CA','Canada',35985751);
-INSERT INTO `country` VALUES ('CN','China',1375210000);
-INSERT INTO `country` VALUES ('DE','Germany',81459000);
-INSERT INTO `country` VALUES ('FR','France',64513242);
-INSERT INTO `country` VALUES ('GB','United Kingdom',65097000);
-INSERT INTO `country` VALUES ('IN','India',1285400000);
-INSERT INTO `country` VALUES ('RU','Russia',146519759);
-INSERT INTO `country` VALUES ('US','United States',322976000);
+INSERT INTO `pais` VALUES ('AU','Austrália',24016400);
+INSERT INTO `pais` VALUES ('BR','Brasil',205722000);
+INSERT INTO `pais` VALUES ('CA','Canadá',35985751);
+INSERT INTO `pais` VALUES ('CN','China',1375210000);
+INSERT INTO `pais` VALUES ('DE','Alemanha',81459000);
+INSERT INTO `pais` VALUES ('FR','França',64513242);
+INSERT INTO `pais` VALUES ('GB','Reino Unido',65097000);
+INSERT INTO `pais` VALUES ('IN','Índia',1285400000);
+INSERT INTO `pais` VALUES ('RU','Rússia',146519759);
+INSERT INTO `pais` VALUES ('US','Estados Unidos',322976000);
```
-Neste ponto, você tem um banco de dados chamado `yii2basic`, e dentro dele uma
-tabela `country` com três colunas, contendo dez linhas de dados.
+Neste ponto, você tem um banco de dados chamado `yii2basico` e dentro dele uma
+tabela `pais` com três colunas, contendo dez linhas de dados.
-Configurando uma Conexão do BD
+Configurando uma Conexão de BD
------------------------------
Antes de prosseguir, certifique-se de que você possui instalados tanto a
extensão [PDO](http://www.php.net/manual/en/book.pdo.php) do PHP quanto o driver
-do PDO para a base que você está usando (por exemplo, `pdo_mysql` para o MySQL).
+PDO para o gerenciador de banco de dados que você está usando (por exemplo, `pdo_mysql` para o MySQL).
Este é um requisito básico se a sua aplicação usa um banco de dados relacional.
-Tendo estes instalados, abra o arquivo `config/db.php` e mude os parâmetros para
-que estejam corretos para o seu banco de dados. Por padrão, o arquivo contém
-o seguinte:
+Tendo esses instalados, abra o arquivo `config/db.php` e mude os parâmetros conforme seu banco de dados.
+Por padrão, o arquivo contém o seguinte:
```php
'yii\db\Connection',
- 'dsn' => 'mysql:host=localhost;dbname=yii2basic',
+ 'dsn' => 'mysql:host=localhost;dbname=yii2basico',
'username' => 'root',
'password' => '',
'charset' => 'utf8',
];
```
-O arquivo `config/db.php` é uma ferramenta de [configuração](concept-configurations.md)
-típica baseada em arquivos. Este arquivo de configuração em particular especifica
-os parâmetros necessários para criar e inicializar uma instância de [[yii\db\Connection]]
-através da qual você pode fazer consultas de SQL ao banco de dados subjacente.
+O arquivo `config/db.php` é uma típica ferramenta de [configuração](concept-configurations.md) baseada em arquivo. Este arquivo de configuração em particular especifica
+os parâmetros necessários para criar e inicializar uma instância [[yii\db\Connection]]
+por meio da qual você pode fazer consultas SQL ao banco de dados subjacente.
-A conexão de BD configurada acima pode ser acessada no código da aplicação
-através da expressão `Yii::$app->db`.
+A conexão configurada acima pode ser acessada no código da aplicação através da expressão `Yii::$app->db`.
-> Informação: O arquivo `config/db.php` será incluso pela configuração principal da
+> Info: O arquivo `config/db.php` será absorvido (incluso) pela configuração principal da
aplicação `config/web.php`, que especifica como a instância da [aplicação](structure-applications.md)
- deverá ser inicializada. Para mais informações, por favor consulte a seção sobre [Configurações](concept-configurations.md).
+ deve ser inicializada. Para mais informações, por favor, consulte a seção [Configurações](concept-configurations.md).
+Se você precisa trabalhar com bancos de dados para os quais não há suporte nativo no Yii, consulte as seguintes extensões:
+
+- [Informix](https://github.com/edgardmessias/yii2-informix)
+- [IBM DB2](https://github.com/edgardmessias/yii2-ibm-db2)
+- [Firebird](https://github.com/edgardmessias/yii2-firebird)
+- [MariaDB](https://github.com/sam-it/yii2-mariadb)
Criando um Active Record
------------------------
-Para representar e buscar os dados da tabela `country`, crie uma classe que
-deriva de [Active Record](db-active-record.md) chamada `Country`, e salve-a
-no arquivo `models/Country.php`.
+Para representar e buscar os dados da tabela `pais`, crie uma classe que deriva de [Active Record](db-active-record.md) chamada `Pais` e salve-a
+no arquivo `models/Pais.php`.
```php
Informação: Se não houver nenhuma correspondência direta do nome da classe com o nome
- da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]]
+> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
+ da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]]
para especificar explicitamente o nome da tabela associada.
-Usando a classe `Country`, você pode manipular facilmente os dados na tabela
-`country`, conforme é demonstrado nestes fragmentos:
+Usando a classe `Pais`, você pode manipular facilmente os dados na tabela
+`pais`, conforme é demonstrado nos fragmentos de código a seguir:
```php
-use app\models\Country;
+use app\models\Pais;
-// obtém todas as linhas da tabela country e as ordena pela coluna "name"
-$countries = Country::find()->orderBy('name')->all();
+// obtém todas as linhas da tabela pais e as ordena pela coluna "nome"
+$paises = Pais::find()->orderBy('nome')->all();
-// obtém a linha cuja chave primária é "US"
-$country = Country::findOne('US');
+// obtém a linha cuja chave primária é "BR"
+$pais = Pais::findOne('BR');
-// exibe "United States"
-echo $country->name;
+// exibe "Brasil"
+echo $pais->nome;
-// altera o nome do país para ser "U.S.A." e o salva no banco de dados
-$country->name = 'U.S.A.';
-$country->save();
+// altera o nome do país para "Brazil" e o salva no banco de dados
+$pais->nome = 'Brazil';
+$pais->save();
```
-> Informação: O Active Record é uma maneira poderosa de acessar e manipular os dados
- do banco de dados de uma forma orientada a objeto. Você pode encontrar informações
- mais detalhadas na seção [Active Record](db-active-record.md). Alternativamente,
- você também pode interagir com o banco de dados usando um método de acesso aos
- dados de baixo nível chamado [Data Access Objects](db-dao.md).
+> Info: O Active Record é uma maneira poderosa de acessar e manipular dados
+ do banco de dados de uma forma orientada a objetos. Você pode encontrar informações
+ mais detalhadas na seção [Active Record](db-active-record.md. Alternativamente,
+ você também pode interagir com o banco de dados usando um método de acesso a
+ dados em baixo nível chamado [Objeto de Acesso a Dados (Data Access Objects)](db-dao.md).
Criando uma Action
------------------
-Para expor os dados de países aos usuários finais, você precisaria de uma nova
-action. Ao invés de colocar a nova action no controller (controlador) `site`,
+Para disponibiliar os dados de países aos usuários finais, você precisa criar uma nova
+action. Em vez de colocar a nova action no controller `site`
como você fez nas seções anteriores, faz mais sentido criar um novo controller
especificamente para todas as actions relacionadas aos dados de países. Chame
-este novo controller de `CountryController`, e crie uma action `index` nele,
-conforme o exemplo a seguir.
+este novo controller de `PaisController`, e crie uma action `index` nele,
+conforme o exemplo a seguir:
```php
5,
'totalCount' => $query->count(),
]);
- $countries = $query->orderBy('name')
- ->offset($pagination->offset)
- ->limit($pagination->limit)
+ $paises = $query->orderBy('nome')
+ ->offset($paginacao->offset)
+ ->limit($paginacao->limit)
->all();
return $this->render('index', [
- 'countries' => $countries,
- 'pagination' => $pagination,
+ 'paises' => $paises,
+ 'paginacao' => $paginacao,
]);
}
}
```
-Salve o código acima em um arquivo `controllers/CountryController.php`.
+Salve o código acima no arquivo `controllers/PaisController.php`.
-A action `index` chama `Country::find()`. Este método do Active Record constrói
-uma consulta do BD e retorna todos os dados da tabela `country`. Para limitar o
-número de países retornados em cada requisição, a consulta é paginada com a ajuda
+A action `index` chama `Pais::find()`. Este método do Active Record constrói
+uma consulta ao BD e retorna todos os dados da tabela `pais`. Para limitar o
+número de países retornados a cada requisição, a consulta é paginada com a ajuda
de um objeto [[yii\data\Pagination]]. O objeto `Pagination` serve para dois propósitos:
-* Definir as cláusulas `offset` e `limit` da declaração SQL representada pela
- consulta de modo que apenas retorne uma única página de dados por vez (no máximo
+* Define as cláusulas `offset` e `limit` da declaração SQL representada pela query
+ (consulta) de modo que apenas retorne uma única página de dados por vez (no exemplo, no máximo
5 linhas por página).
-* É usado para que a view exiba um paginador que consite de uma lista de botões
- para as páginas, conforme será explicado na próxima sub-seção.
+* É usado na view para exibir um paginador que consiste de uma lista de botões de páginas, conforme será explicado na próxima subseção.
-No final do código, a action `index` renderiza uma view chamada `index`, e passa
-para ela os dados dos países bem como as informações de paginação.
+No final do código, a action `index` renderiza uma view chamada `index` e envia a ela os dados dos países e as informações de paginação.
Criando uma View
----------------
-Dentro do diretório `views`, primeiro crie um sub-diretório chamado `country`.
+Dentro do diretório `views`, primeiro crie um subdiretório chamado `pais`.
Esta pasta será usada para guardar todas as views renderizadas pelo controller
-`country`. Dentro do diretório `views/country`, crie um arquivo `index.php`
+`PaisController`. Dentro do diretório `views/pais`, crie um arquivo `index.php`
contendo o seguinte:
```php
@@ -218,50 +215,48 @@ contendo o seguinte:
use yii\helpers\Html;
use yii\widgets\LinkPager;
?>
-
-= LinkPager::widget(['pagination' => $pagination]) ?>
+= LinkPager::widget(['pagination' => $paginacao]) ?>
```
A view tem duas seções relativas à exibição dos dados dos países. Na primeira parte,
-os dados de países fornecidos são cruzados e renderizados como uma lista do HTML.
+os dados de países fornecidos são percorridos e renderizados como uma lista HTML.
Na segunda parte, um widget [[yii\widgets\LinkPager]] é renderizado usando as
informações de paginação passadas pela action. O widget `LinkPager` exibe uma
-lista de botões para as páginas. Ao clicar em qualquer um deles atualizará
-os dados dos países com a página correspondente.
+lista de botões de páginas. Clicar em qualquer um deles vai atualizar os dados dos países conforme a página correspondente.
-Testando
+Conferindo
--------
-Para verificar se todo os códigos acima funcionam, use o seu navegador para
-acessar a seguinte URL:
+Para ver se todo os códigos acima funcionam, use o seu navegador para acessar a seguinte URL:
```
-http://hostname/index.php?r=country/index
+http://hostname/index.php?r=pais/index
```

Primeiramente, você verá uma lista exibindo cinco países. Abaixo dos países,
você verá um paginador com quatro botões. Se você clicar no botão "2", você
-verá a página exibindo outros cinco países no banco de dados: a segunda
+verá a página exibir outros cinco países do banco de dados: a segunda
página de registros. Observe mais cuidadosamente e você perceberá que a URL no
browser mudou para
```
-http://hostname/index.php?r=country/index&page=2
+http://hostname/index.php?r=pais/index&page=2
```
-Por baixo dos panos, [[yii\data\Pagination|Pagination]] está fornecendo toda
+Por trás das cortinas, [[yii\data\Pagination|Pagination]] está fornecendo toda
a funcionalidade necessária para paginar um conjunto de dados:
* Inicialmente, [[yii\data\Pagination|Pagination]] representa a primeira página,
@@ -271,8 +266,8 @@ a funcionalidade necessária para paginar um conjunto de dados:
usando as URLs criadas pelo [[yii\data\Pagination::createUrl()|Pagination]].
As URLs conterão um parâmetro `page`, que representa os diferentes números de
páginas.
-* Se você clicar no botão da página "2", uma nova requisição para a rota
- `country/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
+* Se você clicar no botão de página "2", uma nova requisição para a rota
+ `pais/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
o parâmetro `page` da URL e define o número da página atual como sendo 2. A nova
consulta de países então terá a cláusula `LIMIT 5 OFFSET 5` e retornará os
próximos cinco países para a exibição.
@@ -285,9 +280,9 @@ Nesta seção, você aprendeu como trabalhar com um banco de dados. Você també
aprendeu como buscar e exibir dados em páginas com a ajuda do
[[yii\data\Pagination]] e do [[yii\widgets\LinkPager]].
-Na próxima seção, você aprenderá como usar a poderosa ferramenta geradora de códigos,
+Na próxima seção, você aprenderá como usar a poderosa ferramenta de geração de códigos,
chamada [Gii](tool-gii.md), para ajudá-lo a implementar rapidamente algumas
funcionalidades comumente necessárias, tais como as operações CRUD
-(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados em uma tabela do
+(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados de uma tabela do
banco de dados. Na verdade, todo o código que você acabou de escrever pode ser
gerado automaticamente no Yii usando a ferramenta Gii.
diff --git a/docs/guide-pt-BR/start-forms.md b/docs/guide-pt-BR/start-forms.md
index 17db7d3a4c..a62381ca14 100644
--- a/docs/guide-pt-BR/start-forms.md
+++ b/docs/guide-pt-BR/start-forms.md
@@ -1,28 +1,26 @@
Trabalhando com Formulários
===========================
-Nesta seção descreve como se cria uma nova página com um formulário para obter
-dados a partir dos usuários. A página exibirá uma formulário com um campo para
-o nome e uma para o e-mail. Depois de obter essas duas informações a partir do
-usuário, a página exibirá os valores inseridos de volta para a confirmação.
+Esta seção descreve como criar uma nova página com um formulário para receber
+dados dos usuários. A página exibirá um formulário com um campo para o nome e outro para o e-mail. Depois de obter essas duas informações do usuário, a página exibirá os valores inseridos de volta para confirmação.
-Para atingir este objetivo, além de criar uma [ação](structure-controllers.md) (action) e
-duas [visões](structure-views.md) (view), você também criará uma [modelo](structure-models.md) (model).
+Para alcançar esse objetivo, além de criar uma [action](structure-controllers.md) e
+duas [views](structure-views.md), você também criará um [model](structure-models.md).
-Através deste tutorial, você aprenderá como:
+No decorrer deste tutorial, você aprenderá como:
-* Criar um [modelo](structure-models.md) (model) para representar os dados inseridos pelo usuário por meio de um formulário
-* Declarar regras (rules) para validar os dados inseridos
-* Criar um formulário HTML em uma [visão](structure-views.md) (view)
+* criar um [model](structure-models.md) para representar os dados que o usuário insere por meio de um formulário
+* declarar regras (rules) para validar os dados inseridos
+* criar um formulário HTML em uma [view](structure-views.md)
-Criando uma Modelo (Model)
+Criando um Model
----------------
-Os dados a serem solicitados pelo usuário será representados por uma classe modelo
-`EntryForm` como mostro a seguir e salvos no arquivo `models/EntryForm.php`. Por
-favor consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais
-detalhes sobre convenção de nomenclatura dos arquivos de classes.
+Os dados a serem solicitados do usuário serão representados por uma classe model
+`FormularioDeRegistro`, como visto a seguir, que será salva no arquivo `models/FormularioDeRegistro.php`. Por
+favor, consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais
+detalhes sobre convenção de nomenclatura de arquivos de classes.
```php
Informação: O [[yii\base\Model]] é usado como pai das classes modelos que *não*
-são associadas com tabelas do banco de dados.
-O [[yii\db\ActiveRecord]] é normalmente usado como pai das classes modelos que
-correspondem a tabelas do banco de dados.
+> Info: [[yii\base\Model]] é usado como pai das classes de models que *não*
+são associadas com tabelas de bancos de dados.
+Enquanto [[yii\db\ActiveRecord]], como pai das classes de models que correspondem a tabelas de bancos de dados.
-A classe `EntryForm` contém dois atributos públicos, `name` e `email`, que são
-usados para guardar os dados fornecidos pelo usuário. Ele também contém um método
-chamado `rules()`, que retorna um conjunto de regras para validação dos dados.
-As regras de validação declaradas no código acima permitem que:
+A classe `FormularioDeRegistro` contém dois atributos públicos, `nome` e `e_mail`, que são
+usados para armazenar os dados fornecidos pelo usuário. Ele também contém um método
+chamado `rules()`, que retorna um conjunto de regras para validação dos dados.
+As regras de validação declaradas no código acima declaram que:
-* tanto os valores do `name` quanto do `email` sejam obrigatórios
-* os dados do `email` devem ser um e-mail válido sintaticamente
+* tanto o `nome` quanto o `e_mail` são obrigatórios
+* o `e_mail` deve ser preenchido com um e-mail sintaticamente válido (por exemplo, um valor sem @ não pode ser considerado válido para um e-mail, etc.)
-Se você tiver um objeto `EntryForm` populado com dados fornecidos pelo usuário,
-você pode chamar o [[yii\base\Model::validate()|validate()]] para iniciar as
-rotinas de validação dos dados. A validação dos dados falhar, a propriedade
+Se você tem um objeto `FormularioDeRegistro` preenchido com dados fornecidos pelo usuário,
+você pode chamar seu método [[yii\base\Model::validate()|validate()]] para iniciar as rotinas de validação dos dados. Se a validação de dados falhar, a propriedade
[[yii\base\Model::hasErrors|hasErrors]] será definida como *true* e você pode
-saber quais erros ocorrerão pela validação através de [[yii\base\Model::getErrors|errors]].
+saber quais erros de validação ocorreram por consultar [[yii\base\Model::getErrors|errors]].
```php
name = 'Qiang';
-$model->email = 'bad';
+$model = new FormularioDeRegistro();
+$model->nome = 'Fulano';
+$model->e_mail = 'emailruim';
if ($model->validate()) {
// Bom!
} else {
- // Falha!
+ // Falhou!
// Utilize $model->getErrors()
}
```
-Criando uma Ação
+Criando uma Action
------------------
-Em seguida, você precisará criar uma ação `entry` no controlador `site` que será usado no novo modelo. O processo de criação e utilização das ações são explicadas na seção
-[Como Fazer um "Hello World"](start-hello.md).
+Em seguida, você precisará criar uma action `registro` no controller `site` que usará o novo model. O processo de criação e utilização de ações foi explicado na seção
+[Dizendo "Olá!"](start-hello.md).
```php
load(Yii::$app->request->post()) && $model->validate()) {
- // dados válidos recebidos pelo $model
+ // dados válidos recebidos no $model
- // fazer alguma coisa aqui sobre $model ...
+ // faça alguma coisa significativa com o $model aqui ...
- return $this->render('entry-confirm', ['model' => $model]);
+ return $this->render('confirmar-registro', ['model' => $model]);
} else {
- // Ou a página é exibida inicialmente ou existe algum erro de validação
- return $this->render('entry', ['model' => $model]);
+ // Ou a página esta sendo exibida inicial ou houve algum erro de validação
+ return $this->render('registro', ['model' => $model]);
}
}
}
```
-A primeira ação cria um objeto `EntryForm`. Ele, então, tenta popular o modelo
-(model) com os dados vindos do `$_POST`, fornecidos pelo [[yii\web\Request::post()]]
-no Yii. Se o modelo (model) for populado com sucesso (por exemplo, se o usuário
-enviar o formulário HTML), a ação chamará o [[yii\base\Model::validate()|validate()]]
-para certifique-se que os valores fornecidos são válidos.
+A primeira action cria um objeto `FormularioDeRegistro`. Ele, então, tenta preencher o model com os dados de `$_POST`, fornecidos no Yii por [[yii\web\Request::post()]].
+Se o model for preenchido (observe o método `load()`) com sucesso, ou seja, se o usuário
+enviou o formulário HTML, a action chamará o [[yii\base\Model::validate()|validate()]]
+para se certificar de que os valores fornecidos são válidos.
-> Informação: A expressão `Yii::$app` representa a instância da
- [aplicação](structure-applications.md), que é globalmente acessível via singleton.
- Também é um [service locator](concept-service-locator.md) que fornece componentes
- tais como `request`, `response`, `db`, etc. para suportar a funcionalidade específica.
- No código acima, o componente `request` da instância da aplicação é usada para
- acessar os dados do `$_POST`.
+> Info: A expressão `Yii::$app` representa a instância da
+ [aplicação](structure-applications.md), que é um "singleton" globalmente acessível.
+ Ao mesmo tempo, é um [service locator](concept-service-locator.md) que fornece componentes
+ tais como `request`, `response`, `db`, etc., para permitir funcionalidades específicas.
+ No código acima, o componente `request` da instância da aplicação é usado para acessar os dados do `$_POST`.
-Se tudo tiver certo, a ação renderizará a visão chamada `entry-confirm` para
-confirmar os dados enviados pelo usuário. Se ao enviar o formulário não
-houver dados ou se os dados tiverem erros, a visão `entry` será renderizada,
-em que o formulário será exibigo, juntamente com as mensagens de erros da
-validação.
+Se tudo estiver certo, a action renderizará a view chamada `confirmar-registro` para confirmar ao usuário que os dados foram enviados corretamente. Se nenhum dado foi enviado ou se tiverem erros, a view `registro` será renderizada novamente
+e seu formulário HTML voltará a ser exibido mas, dessa vez, juntamente com as mensagens de erro de validação.
-> Nota: Neste exemplo muito simples, acabamos de renderizar um página de confirmação
- mediante a dados válidos enviados de uma formulário. Em prática, você poderia
- considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
- para evitar [problemas ao reenviar formulários](http://en.wikipedia.org/wiki/Post/Redirect/Get).
+> Nota: Neste exemplo muito simples, renderizamos a página de confirmação somente se os dados enviados eram válidos. Na prática, você deve considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
+ para evitar [problemas de reenvio de formulário](http://en.wikipedia.org/wiki/Post/Redirect/Get).
-Criando Visões
+Criando Views
--------------
-Finalmente, crie dois arquivos de visões chamados de `entry-confirm` e `entry`.
-Estas visões serão renderizados pela ação `entry`, como descrito anteriormente.
+Por fim, crie dois arquivos de views chamados `confirmar-registro` e `registro`. Essas serão as views renderizadas pela action `registro`, como acabamos de descrever acima.
-A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`.
-Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
+A view `confirmar-registro` simplesmente exibe os dados dos campos `nome` e `e_mail` e deve ser salva no arquivo `views/site/confirmar-registro.php`.
```php
-
You have entered the following information:
+
Você enviou as seguintes informações:
-
: = Html::encode($model->name) ?>
-
: = Html::encode($model->email) ?>
+
: = Html::encode($model->nome) ?>
+
: = Html::encode($model->e_mail) ?>
```
-A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
+A view `registro` exibe um formulário HTML e deve ser salva no arquivo `views/site/registro.php`.
```php
- = $form->field($model, 'name') ?>
+ = $form->field($model, 'nome') ?>
- = $form->field($model, 'email') ?>
+ = $form->field($model, 'e_mail') ?>
```
-A visão usa o poderoso [widget](structure-widgets.md) chamado
-[[yii\widgets\ActiveForm|ActiveForm]] para criar o formulário HTML. Os métodos
-`begin()` e `end()` do widget renderizam a abertura e o fechamento da tag do
-formulário. Entre os dois métodos chamados, os campos de entrada são criados pelo
-método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo de entrada
-é para o "name" (nome) e o segundo é para o "email". Após os campos de entrada,
-o método [[yii\helpers\Html::submitButton()]] é chamado para criar o botão
-de enviar.
+A view usa um poderoso [widget](structure-widgets.md) chamado
+[[yii\widgets\ActiveForm|ActiveForm]] para construir o formulário HTML. Os métodos
+`begin()` e `end()` do widget renderizam as tags de abertura e de fechamento do formulário.
+Entre as duas chamadas de métido, campos são criados pelo
+método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo é para o nome e o segundo é para o e-mail. Após os campos,
+o método [[yii\helpers\Html::submitButton()]] é chamado para criar um botão de envio do formulário (submit).
-Testando
+Conferindo
-------------
-Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
+Para ver como funciona, utilize seu navegador para acessar a seguinte URL:
```
-http://hostname/index.php?r=site/entry
+http://hostname/index.php?r=site/registro
```
-Você verá uma página exibindo um formulário com dois campos de entrada. Na frente
-de cada campo, um *label* indicando quais dados devem ser inseridos. Se você clicar
-no botão de enviar sem informar nenhum dado, ou se você não fornecer um e-mail
-válido, você verá uma mensagem de erro após cada campo de entrada.
+Você verá uma página exibindo um formulário com dois campos. Na frente de cada campo, um *label* indica quais dados devem ser inseridos. Se você clicar
+no botão Enviar sem informar nenhum dado, ou se você não fornecer um e-mail
+válido, você verá uma mensagem de erro próxima a cada campo com problema.
-
+
-Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma
+Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma
nova página exibindo os dados informados por você.
-
+
-### Explicação da Mágica
+### Mágica Explicada
-Você pode querer saber como o formulário HTML trabalha por baixo dos panos, porque
-parece quase mágica exibir um *label* para cada campo de entrada e mostrar mensagens
-de erro quando você não informa dados corretos sem recarregar a página.
+Você talvez se pergunte como o formulário HTML trabalha por trás das cortinas, já que parece
+quase mágica exibir um *label* para cada campo e mostrar mensagens
+de erro sem recarregar a página quando você não informa os dados corretamente.
-Sim, a validação dos dados inicialmente é feito no lado do cliente usando JavaScript
-e posteriormente realizada no lado do servidor via PHP.
-O [[yii\widgets\ActiveForm]] é inteligente o suficiente para extrair as regras de
-validação declaradas no `EntryForm`, transformando-as em códigos JavaScript e utilizando
-o JavaScript para realizar as validações dos dados. No caso do JavaScript estiver desabilitado
-em seu navegador, a validação ainda será realizada pelo lado do servidor, como mostrado
-no método `actionEntry()`. Isso garante que os dados serão validados em qualquer
-circunstância.
+Sim, a validação de dados inicialmente é feita no cliente usando JavaScript e, posteriormente, realizada no servidor via PHP.
+O [[yii\widgets\ActiveForm]] é esperto o suficiente para extrair as regras de
+validação que você declarou no `FormularioDeRegistro`, transformá-las em código JavaScript executável e usar esse
+código JavaScript para realizar a validação de dados. Caso você tenha desabilitado o JavaScript em seu navegador, a validação ainda será realizada no servidor, como mostrado
+no método `actionRegistro()`. Isso garante a validade dos dados em todas as circunstâncias.
-> Aviso: A validação feita pelo lado do cliente é uma conveniência que fornece uma melhor
- experiência para o usuário. A validação feita pelo lado do servidor é sempre necessária
- com ou sem validação no lado do cliente.
+> Warning: (Alerta!) A validação feita no cliente é uma conveniência que fornece uma melhor
+ experiência para o usuário. A validação feita no servidor é sempre necessária, quer a validação no cliente aconteça, quer não.
-Os *labels* dos campos de entrada são geradas pelo método `field()`, usando os nomes
-das propriedades do modelo (model).
-Por exemplo, um *label* chamado `Name` será gerado para a propriedade `name`.
+Os *labels* dos campos são gerados pelo método `field()`, usando os nomes
+das propriedades do model.
+Por exemplo, um *label* chamado `Nome` será gerado para a propriedade `nome`.
-Você pode personalizar um *label* em uma visão utilizando o seguinte código:
+Você pode personalizar um *label* em uma view utilizando o seguinte código:
```php
-= $form->field($model, 'name')->label('Your Name') ?>
-= $form->field($model, 'email')->label('Your Email') ?>
+= $form->field($model, 'nome')->label('Seu Nome') ?>
+= $form->field($model, 'e_mail')->label('Seu E-mail') ?>
```
-> Informação: O Yii fornece muitos destes widgets para lhe ajudar a criar rapidamente
- complexas e dinâmicos layouts.
- Como você vai aprender mais tarde, escrever um novo widget é também extremamenet fácil.
- Você pode querer transformar grande parte do seu código de visão em reutilizáveis
- widget para simplificar o desenvolvimento de visões no futuro.
+> Info: O Yii fornece muitos desses widgets para ajudá-lo a construir rapidamente views dinâmicas e complexas.
+ Conforme você vai aprender mais tarde, escrever um novo widget também é extremamente fácil.
+ Você talvez queira transformar grande parte do código de suas views em widgets reutilizáveis
+ para simplificar o desenvolvimento de views no futuro.
+
-
Resumo
-------
-Nesta seção, você tocou em cada parte do padrão de arquitetura MVC.
-Aprendeu como criar uma classe modelo (model) para representar os dados do usuário
-e validá-los.
+Nesta seção do guia, você teve uma introduçao à última parte do padrão de arquitetura MVC. Você aprendeu como criar uma classe model para representar os dados do usuário e validá-los.
Também aprendeu como obter os dados enviados pelos usuários e como exibi-los de
-volta no navegador. Esta é uma tarefa que poderia levar muito tempo ao desenvolver
-uma aplicação, mas o Yii fornece widgets inteligentes para gerar estas tarefas de
-forma simples.
-Na próxima seção, você aprenderá como trabalhar com banco de dados, os quais são
+volta no navegador. Essa é uma tarefa que poderia tomar muito tempo ao desenvolver uma aplicação, mas o Yii fornece widgets poderosos que tornam o processo muito simples.
+
+Na próxima seção, você aprenderá como trabalhar com bancos de dados, que são
necessários em quase todas as aplicações.
diff --git a/docs/guide-pt-BR/start-gii.md b/docs/guide-pt-BR/start-gii.md
index 6405355476..a31c24808b 100644
--- a/docs/guide-pt-BR/start-gii.md
+++ b/docs/guide-pt-BR/start-gii.md
@@ -1,20 +1,20 @@
Gerando Código com Gii
========================
-Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simples, trata-se apenas de uma questão de entrar com as informações corretas de acordo com as instruções mostradas nas páginas do Gii.
+Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simplesmente uma questão de informar os dados corretos conforme as instruções mostradas nas páginas do Gii.
Através desse tutorial, você irá aprender a:
-* Habilitar o Gii em sua aplicação
-* Usar o Gii para gerar uma classe Active Record
-* Usar o Gii para gerar código que implementa as operações CRUD para uma tabela do BD
-* Customizar o código gerado pelo Gii
+* habilitar o Gii em sua aplicação,
+* usar o Gii para gerar uma classe Active Record,
+* usar o Gii para gerar código que implementa as operações CRUD para uma tabela do banco de dados, e
+* personalizar o código gerado pelo Gii.
Começando a usar o Gii
------------
-O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido com o Yii como um [módulo](structure-modules.md). Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode já encontrar o seguinte código no arquivo de configuração `config/web.php`:
+O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido como um [módulo](structure-modules.md) do Yii. Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode encontrar o seguinte código já pronto no arquivo de configuração `config/web.php`:
```php
$config = [ ... ];
@@ -27,22 +27,22 @@ if (YII_ENV_DEV) {
}
```
-A configuração acima declara que quando se está em [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
+A configuração acima declara que, quando estiver usando o [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
-Se você checar o [script inicial](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha, que essencialmente faz com que o `YII_ENV_DEV` seja verdadeiro.
+Se você verificar o [script de entrada](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha que, basicamente, torna `YII_ENV_DEV` verdadeira.
```php
defined('YII_ENV') or define('YII_ENV', 'dev');
```
-Graças a essa linha, sua aplicação está em modo de desenvolvimento e estará com o Gii habilitado, pela configuração acima. Agora você pode acessar o Gii pela URL:
+Graças a essa linha, sua aplicação está em modo de desenvolvimento e terá o Gii habilitado, devido a configuração mais acima. Agora você pode acessar o Gii pela URL:
```
http://hostname/index.php?r=gii
```
-> Observação: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão.
-> Para mudar isso, adicione a lista de endereços IP permitidos à configuração:
+> Note: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão, por questões de segurança.
+> Você pode configurar o Gii adicionando endereços IP permitidos como mostrado a seguir:
>
```php
'gii' => [
@@ -57,32 +57,32 @@ http://hostname/index.php?r=gii
Gerando uma classe Active Record
---------------------------------
-Para usar o Gii para gerar uma classe Active Record, selecione o "Model Generator" clicando no link na página inicial do Gii. Preencha o formulário como indicado abaixo:
+Para gerar uma classe Active Record usando o Gii, selecione o "Model Generator" clicando no link na página inicial do Gii. Então, preencha o formulário como indicado abaixo:
-* Nome da tabela: `country`
-* Classe do modelo: `Country`
+* Nome da tabela: `pais`
+* Classe do modelo: `Pais`

-Em seguida, clique no botão "Preview". Você verá o `models/Country.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
+Em seguida, clique no botão "Preview". Você verá o `models/Pais.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê-lo, clique no botão `diff` próximo ao nome do arquivo para ver as diferenças entre o código a ser gerado e a versão já existente.

-Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um arquivo novo, apenas clique em "Generate".
+Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um novo arquivo, apenas clique em "Generate".
-Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito com o novo código.
+Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito pelo novo código.
Gerando código CRUD
--------------------
-CRUD corresponde a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria dos sites. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
+CRUD significa a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria das aplicações. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "pais", preencha o formulário com as seguintes informações:
-* Classe do Modelo: `app\models\Country`
-* Classe da Busca: `app\models\CountrySearch`
-* Classe do Controller: `app\controllers\CountryController`
+* Model Class: `app\models\Pais`
+* Search Model Class: `app\models\PaisSearch`
+* Controller Class: `app\controllers\PaisController`

@@ -90,38 +90,38 @@ Em seguida, clique no botão "Preview". Você verá uma lista de arquivos a sere

-Se você criou anteriormente os arquivos `controllers/CountryController.php` e
-`views/country/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
+Se você criou anteriormente os arquivos `controllers/PaisController.php` e
+`views/pais/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
-Checando os resultados
+Conferindo
-------------
Para ver como ficou, use seu navegador para acessar a seguinte URL:
```
-http://hostname/index.php?r=country/index
+http://hostname/index.php?r=pais/index
```
Você verá uma tabela mostrando os países do seu banco de dados. Você pode ordená-los ou filtrá-los inserindo condições nos cabeçalhos das colunas.
Para cada país exibido na tabela, você pode visualizar detalhes, editar ou excluir.
-Você também pode clicar no botão “Create Country” no topo da tabela para ter acesso a um formulário de criação de um novo país.
+Você também pode clicar no botão “Create Pais” no topo da tabela para ter acesso a um formulário para cadastrar um novo país.
-
+

-Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades são implementadas ou adaptá-las:
+Esta é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades estão implementadas ou ajustá-las:
-* Controller: `controllers/CountryController.php`
-* Modelo: `models/Country.php` e `models/CountrySearch.php`
-* Views: `views/country/*.php`
+* Controller: `controllers/PaisController.php`
+* Modelo: `models/Pais.php` e `models/PaisSearch.php`
+* Views: `views/pais/*.php`
-> Informação: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você irá acelerar o desenvolvimento da sua aplicação. Para mais detalhes, por favor siga para a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
+> Info: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você pode acelerar bastante o desenvolvimento de sua aplicação. Para mais detalhes, por favor, consulte a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
Resumo
-------
-Nessa seção, você aprendeu a usar o Gii para gerar código que implementa funcionalidades CRUD para o conteúdo guardado em uma tabela do banco de dados.
+Nessa seção, você aprendeu a usar o Gii para gerar código que implementa todas as operações CRUD para o conteúdo armazenado em uma tabela de banco de dados.
diff --git a/docs/guide-pt-BR/start-hello.md b/docs/guide-pt-BR/start-hello.md
index 9fe723d3a5..927c89f07c 100644
--- a/docs/guide-pt-BR/start-hello.md
+++ b/docs/guide-pt-BR/start-hello.md
@@ -1,38 +1,33 @@
-Como Fazer um "Hello World"
+Dizendo "Olá!"
=====================
-Esta seção descreve como criar uma nova página de "Hello" em sua aplicação.
-Para atingir este objetivo, você criará uma [ação](structure-controllers.md#creating-actions)
-(action) e uma [visão](structure-views.md) (view):
+Esta seção descreve como criar uma nova página de "Olá!" em sua aplicação.
+Para atingir este objetivo, você criará uma [action](structure-controllers.md#creating-actions)
+e uma [view](structure-views.md):
-* A aplicação enviará a requisição de página para a ação
-* e a ação por sua vez renderizará a view que mostra as palavras "Hello"
- para o usuário final.
+* A aplicação enviará a requisição de página para a action
+* e a action, por sua vez, renderizará a view que mostra a palavra "Olá!" ao usuário final.
Através deste tutorial, você aprenderá três coisas:
-1. Como criar uma [ação](structure-controllers.md) para responder às requisições,
-2. como criar uma [visão](structure-views.md) para compor o conteúdo da resposta, e
-3. como uma aplicação envia as requisições para as [ações](structure-controllers.md#creating-actions).
+1. Como criar uma [action](structure-controllers.md) para responder às requisições,
+2. como criar uma [view](structure-views.md) para compor o conteúdo da resposta, e
+3. como uma aplicação envia requisições às [actions](structure-controllers.md#creating-actions).
-Criando uma Ação
+Criando uma Action
----------------
-Para a tarefa "Hello", você criará uma [ação](structure-controllers.md#creating-actions)
-`say` que lê um parâmetro `message` da requisição e exibe essa mensagem de volta
-para o usuário. Se a requisição não fornecer um parâmetro `message`, a ação
-exibirá a mensagem padrão "Hello".
+Para a tarefa "Olá!", você criará uma [action](structure-controllers.md#creating-actions)
+`cumprimentar` que lê um parâmetro `mensagem` da requisição e exibe essa mensagem de volta
+para o usuário. Se a requisição não fornecer um parâmetro `mensagem`, a action exibirá a mensagem padrão "Olá!".
-> Informação: [Ações](structure-controllers.md#creating-actions) são os objetos aos
- quais os usuários finais podem se referir diretamente para execução. As ações são
- agrupadas nos [controladores](structure-controllers.md) (controllers). O resultado
- da execução de uma ação é a resposta que o usuário final receberá.
+> Info: [Actions](structure-controllers.md#creating-actions) são os objetos que usuários finais podem solicitar diretamente para execução. Actions são
+ agrupadas nos [controllers](structure-controllers.md). O resultado da execução de uma action é a resposta que o usuário final receberá.
-As ações devem ser declaradas em [controladores](structure-controllers.md). Por
-motivo de simplicidade, você pode declarar a ação `say` na classe já existente
-`SiteController`. Este controlador está definido no arquivo `controllers/SiteController.php`.
-Segue aqui o início da nova ação:
+As actions devem ser declaradas em [controllers](structure-controllers.md). Para manter a simplicidade, você pode declarar a action `cumprimentar` na classe já existente
+`SiteController`. Esse controller está definido no arquivo `controllers/SiteController.php`.
+Segue aqui o início da nova action:
```php
render('say', ['message' => $message]);
+ return $this->render('cumprimentar', ['mensagem' => $mensagem]);
}
}
```
-No código acima, a ação `say` está definida como um método chamado `actionSay`
-na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar métodos
-de ações de métodos que não são de ações em uma classe de controlador. O nome
-após o prefixo `action` é mapeado para o ID da ação.
+No código acima, a action `cumprimentar` está definida como um método chamado `actionCumprimentar`
+na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar os métodos
+de actions dos métodos que não são de actions em uma classe de controller. O nome após o prefixo `action` é mapeado como o ID da action.
-Quando se trata de dar nome às suas ações, você deveria entender como o Yii
-trata os IDs de ações. Os IDs das ações são sempre referenciados em minúsculo.
-Se o ID de uma ação necessitar de múltiplas palavras, elas serão concatenadas
-por hífens (por exemplo, `create-comment`). Os nomes de métodos de ações são mapeados
-para os IDs das ações removendo-se os hífens dos IDs, colocando em maiúsculo a
+Quando se trata de dar nome às suas actions, você deveria entender como o Yii
+trata os IDs de actions. Os IDs de actions são sempre referenciados em minúsculo.
+Se o ID de uma action necessitar de múltiplas palavras, elas serão concatenadas
+por hífens (por exemplo, `criar-comentario`). Os IDs de actions são convertidos em nomes de actions removendo-se os hífens dos IDs, colocando em maiúscula a
primeira letra de cada palavra, e prefixando o resultado com a palavra `action`. Por exemplo,
-o ID de ação `create-comment` corresponde ao método de ação `actionCreateComment`.
+o ID de action `criar-comentario` corresponde ao método de action `actionCriarComentario`.
-O método de ação em nosso exemplo recebe um parâmetro `$message`, cujo valor
-padrão é "Hello" (exatamente da mesma forma que você define um valor padrão para
+O método da action em nosso exemplo recebe um parâmetro `$mensagem`, cujo valor
+padrão é "Olá!" (exatamente da mesma forma que você define um valor padrão para
qualquer argumento de função ou método no PHP). Quando a aplicação recebe a
-requisição e determina que a ação `say` é responsável por tratar a requisição,
-a aplicação alimentará este parâmetro com o parâmetro de mesmo nome encontrado
-na requisição. Em outras palavras, se a requisição inclui um parâmetro `message`
-com o valor `"Goodbye"`, a variável `$message` na ação receberá esse valor.
+requisição e determina que a action `cumprimentar` é responsável por tratar a requisição,
+a aplicação vai preencher esse parâmetro com o parâmetro que tiver o mesmo nome
+na requisição. Em outras palavras, se a requisição inclui um parâmetro `mensagem`
+com o valor `"Adeus!"`, a variável `$mensagem` na action receberá esse valor.
-Dentro do método da ação, [[yii\web\Controller::render()|render()]] é chamado
-para renderizar um arquivo de [visão](structure-views.md) chamado `say`. O
-parâmetro `message` também é passado para a visão de modo que ele possa ser usado
-ali. O resultado da renderização é retornado pelo método da ação. Esse resultado
-será recebido pela aplicação, e exibido para o usuário final no navegador (como
-parte de uma página HTML completa).
+Dentro do método da action, [[yii\web\Controller::render()|render()]] é chamado
+para renderizar um arquivo de [view](structure-views.md) chamado `cumprimentar`. O
+parâmetro `mensagem` também é passado para a view de modo que ele possa ser usado
+por ela. O resultado da renderização da view é retornado pelo método da action. Esse resultado
+será recebido pela aplicação e exibido para o usuário final no navegador (como parte de uma página HTML completa).
-Criando uma Visão
+Criando uma View
-----------------
-As [visões](structure-views.md) são scripts que você escreve para gerar o conteúdo
-de uma resposta. Para a tarefa "Hello", você criará uma visão `say` que imprime o
-parâmetro `message` recebido do método da ação:
+As [views](structure-views.md) são scripts que você escreve para gerar o conteúdo de uma resposta.
+Para a tarefa "Olá!", você criará uma view `cumprimentar` que exibe o parâmetro `mensagem` recebido do método da action:
```php
-= Html::encode($message) ?>
+= Html::encode($mensagem) ?>
```
-A visão `say` deve ser salva no arquivo `views/site/say.php`. Quando o método
-[[yii\web\Controller::render()|render()]] é chamado em uma ação, ele procurará
-um arquivo PHP chamado de `views/IDdoController/NomeDaView.php`.
+A view `cumprimentar` deve ser salva no arquivo `views/site/cumprimentar.php`. Quando o método
+[[yii\web\Controller::render()|render()]] é chamado em uma action, ele procurará
+o arquivo PHP em `views/IDdoController/NomeDaView.php`.
-Perceba que no código acima o parâmetro `message` é [[yii\helpers\Html::encode()|codificado como HTML]]
+Perceba que no código acima o parâmetro `mensagem` é [[yii\helpers\Html::encode()|codificado como HTML]]
antes de ser impresso. Isso é necessário, já que o parâmetro vem de um usuário final,
tornando-o vulnerável a [ataques de cross-site scripting (XSS)](http://en.wikipedia.org/wiki/Cross-site_scripting)
-onde coloca-se código JavaScript malicioso no parâmetro.
+por embutir código JavaScript malicioso no parâmetro.
-Naturalmente, você pode colocar mais conteúdo na visão `say`. O conteúdo pode consistir
-de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato a visão `say` é
+Naturalmente, você pode colocar mais conteúdo na view `cumprimentar`. O conteúdo pode consistir
+de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato, a view `cumprimentar` é
apenas um script PHP que é executado pelo método [[yii\web\Controller::render()|render()]].
-O conteúdo impresso pelo script da visão será retornado à aplicação como o resultado
-da resposta. A aplicação, por sua vez, retornará este resultado para o usuário final.
+O conteúdo impresso pelo script da view será retornado à aplicação como o resultado
+da resposta. A aplicação, por sua vez, retornará esse resultado para o usuário final.
-Testando
+Conferindo
--------
-Após criar a ação e a visão, você pode acessar a nova página através da seguinte URL:
+Após criar a action e a view, você pode acessar a nova página através da seguinte URL:
```
-http://hostname/index.php?r=site/say&message=Hello+World
+http://hostname/index.php?r=site/cumprimentar&mensagem=Olá+Mundo!
```
-
+
-Esta URL resultará em uma página exibindo "Hello World". Esta página compartilha
-o mesmo cabeçalho e rodapé das outras páginas da aplicação.
+Essa URL resultará em uma página exibindo "Olá Mundo!". Essa página compartilha o mesmo cabeçalho e rodapé das outras páginas da aplicação.
-Se você omitir o parâmetro `message` na URL, você veria a página exibindo somente
-"Hello". Isso é porque `message` é passado como um parâmetro para o método `actionSay()`,
-e quando ele é omitido, o valor padrão `"Hello"` será usado ao invés dele.
+Se você omitir o parâmetro `mensagem` na URL, você verá a página exibindo somente
+"Olá!". Isso ocorre por que `mensagem` é passado como um parâmetro para o método `actionCumprimentar()` e,
+quando ele é omitido, o valor padrão `"Olá!"` é usado em seu lugar.
-> Informação: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
- porque o método [[yii\web\Controller::render()|render()]] irá automaticamente
- incluir o resultado da visão `say` em um [layout](structure-views.md#layouts)
+> Info: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
+ porque o método [[yii\web\Controller::render()|render()]] vai automaticamente
+ incluir o resultado da view `cumprimentar` em um [layout](structure-views.md#layouts)
que neste caso está localizado em `views/layouts/main.php`.
O parâmetro `r` na URL acima requer mais explicação. Ele significa [rota](runtime-routing.md),
-um ID abrangente e único de uma aplicação que se refere a uma ação. O formato da rota
+um ID único e amplo de uma aplicação que se refere a uma action. O formato da rota
é `IDdoController/IDdaAction`. Quando a aplicação recebe uma requisição, ela
-verificará este parâmetro, usando a parte `IDdoController` para determinar qual
-classe de controlador deve ser instanciada para tratar a requisição. Então o
-controlador usará a parte `IDdaAction` para determinar qual ação deverá ser
-instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/say` será
-resolvida como a classe de controlador `SiteController` e a ação `say`. Como
-resultado, o método `SiteController::actionSay()` será chamado para tratar a requisição.
+verificará esse parâmetro e usará a parte `IDdoController` para determinar qual
+classe de controller deve ser instanciada para tratar a requisição. Então o
+controller usará a parte `IDdaAction` para determinar qual action deverá ser
+instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/cumprimentar` será
+resolvida como a classe de controller `SiteController` e a action `cumprimentar`. Como
+resultado, o método `SiteController::actionCumprimentar()` será chamado para tratar a requisição.
-> Informação: Assim como as ações, os controladores também possuem IDs que os identificam
- de maneira única em uma aplicação. Os IDs de controladores seguem as mesmas regras
- de nomenclatura que os IDs de ações. Os nomes das classes de controlllers
- derivam dos IDs de controladores removendo-se os hífens dos IDs, convertendo a
+> Info: Assim como as actions, os controllers também possuem IDs que os identificam
+ de maneira única em uma aplicação. IDs de controllers seguem as mesmas regras de nomenclatura dos IDs de actions. Os nomes das classes de controlllers
+ derivam dos IDs de controllers removendo-se os hífens dos IDs, convertendo a
primeira letra de cada palavra em maiúscula, e adicionando o sufixo `Controller`.
- Por exemplo, o ID de controlador `post-comment` corresponde ao nome de classe
- de controlador `PostCommentController`.
+ Por exemplo, o ID de controller `comentario-de-artigo` corresponde ao nome de classe
+ de controller `ComentarioDeArtigoController`.
Resumo
------
-Nesta seção, você tocou as partes do controlador (controller) e da visão (view)
-do padrão de arquitetura MVC. Você criou uma ação (action) como parte de um controlador
-para tratar uma requisição específica. E você também criou uma visão para compor
-o conteúdo da resposta. Neste exemplo simples acima, nenhum modelo (model) foi
-utilizado, já que os único dado sendo exibido foi o parâmetro `message`.
+Nesta seção, você teve uma introdução sobre as partes controller e view do padrão de arquitetura MVC. Você criou uma action como parte de um controller para tratar uma requisição específica.
+E você também criou uma view para compor o conteúdo da resposta. Nesse exemplo simples, nenhum modelo (model) foi
+utilizado, já que o único dado exibido foi o parâmetro `mensagem`.
Você também aprendeu sobre as rotas no Yii, que agem como a ponte entre as
-requisições do usuário e as ações do controlador.
+requisições de usuário e as actions de controllers.
-Na próxima seção, você aprenderá como criar um modelo e adicionar uma nova
-página contendo um formulário HTML.
+Na próxima seção, você aprenderá como criar um modelo (model) e adicionar uma nova página contendo um formulário HTML.
diff --git a/docs/guide-pt-BR/start-looking-ahead.md b/docs/guide-pt-BR/start-looking-ahead.md
index 19740e8029..11cc12ef3a 100644
--- a/docs/guide-pt-BR/start-looking-ahead.md
+++ b/docs/guide-pt-BR/start-looking-ahead.md
@@ -1,44 +1,36 @@
Seguindo em Frente
==================
-Se você leu a seção "Primeiros Passos" inteira, você criou uma aplicação Yii
-completa. Neste processo, você aprendeu como implementar algumas funcionalidades
-comumente necessárias, tais como obter dados de usuários através de um formulário
-HTML, consultar dados de um banco de dados, e exibir os dados de forma paginada.
+Se você leu toda a seção "Primeiros Passos", você criou uma aplicação Yii
+completa. No processo, você aprendeu como implementar algumas funcionalidades comumente necessárias, tais como obter dados de usuários através de um formulário
+HTML, consultar dados de um banco de dados e exibir os dados de forma paginada.
Você também aprendeu a usar o [Gii](tool-gii.md) para gerar código automaticamente.
Usar o Gii para a geração de código torna a carga do seu processo de desenvolvimento
Web uma tarefa tão simples quanto preencher alguns formulários.
-Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais produtivo
-usando o framework.
+Esta seção resume recursos Yii disponíveis que o ajudarão a ser mais produtivo usando o framework.
* Documentação
- [O Guia Definitivo](http://www.yiiframework.com/doc-2.0/guide-README.html):
Conforme o nome indica, o guia define precisamente como o Yii deve funcionar
- e fornece orientações gerais sobre como usar o Yii. É o tutorial
- mais importante, e que você deveria ler antes de escrever qualquer código
- com o Yii.
+ e fornece orientações gerais sobre como usá-lo. É o tutorial mais importante e que você deveria ler antes de escrever qualquer código Yii.
- [A Referência de Classes](http://www.yiiframework.com/doc-2.0/index.html):
- Especifica o uso de todas as classes disponibilizadas pelo Yii. Deve ser
- principalmente usado quando você estiver escrevendo o código e quiser entender
- o uso de uma classe, método ou propriedade em particular. O uso da referência
- de classes só é melhor depois de um entendimento contextual do framework
- inteiro.
- - [Os Artigos do Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
- Os artigos do wiki escritos pelos usuários do Yii baseados em suas próprias
- experiências. A maioria deles são escritos como receitas de bolo, e mostram
- como resolver problemas em particular usando o Yii. Enquanto a qualidade destes
- artigos pode não ser tão boa quanto a do Guia Definitivo, eles ainda assim
- são úteis porque são mais abrangentes e frequentemente fornecem
+ Especifica o uso de todas as classes fornecidas pelo Yii. Deve ser
+ principalmente usada quando você estiver escrevendo código e quiser entender o uso de uma classe, método ou propriedade específicos. O uso da referência
+ de classes é idealmente melhor somente depois de um entendimento contextual do framework como um todo.
+ - [Os Artigos Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
+ Os artigos wiki são escritos por usuários do Yii baseados em suas próprias experiências. A maioria deles são escritos como receitas de bolo e mostram
+ como resolver problemas específicos usando o Yii. Ainda que a qualidade desses artigos possa não ser tão boa quanto a do Guia Definitivo, eles são úteis porque são abrangem assuntos adicionais e frequentemente fornecem
soluções prontas para serem usadas.
- [Livros](http://www.yiiframework.com/doc/)
* [Extensões](http://www.yiiframework.com/extensions/):
- O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários,
- que podem facilmente ser plugadas em suas aplicações, desta forma tornando
+ O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários que podem facilmente ser plugadas em suas aplicações, tornando
o seu desenvolvimento ainda mais rápido e mais fácil.
* Comunidade
- Fórum:
- - Chat do IRC: O canal #yii na rede freenode ()
+ - Chat IRC: O canal #yii na rede freenode ()
+ - Canal Slack:
+ - Chat Gitter:
- GitHub:
- Facebook:
- Twitter:
diff --git a/docs/guide-pt-BR/start-workflow.md b/docs/guide-pt-BR/start-workflow.md
index bbdbef31cf..1ff74a8f87 100644
--- a/docs/guide-pt-BR/start-workflow.md
+++ b/docs/guide-pt-BR/start-workflow.md
@@ -2,20 +2,17 @@ Executando Aplicações
=====================
Após instalar o Yii, você tem uma aplicação Yii funcional que pode ser acessada
-pela URL `http://hostname/basic/web/index.php` ou `http://hostname/index.php`,
-dependendo da sua configuração. Esta seção introduzirá a funcionalidade embutida
-da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
-em geral.
+pela URL `http://hostname/basico/web/index.php` ou `http://hostname/index.php`,
+dependendo de sua configuração. Esta seção introduzirá a funcionalidade embutida
+da aplicação, como o código é organizado e como a aplicação trata as requisições em geral.
> Info: Por questões de simplicidade, por todo este tutorial de "Primeiros Passos"
- assume-se que você definiu `basic/web` como a raiz de documentos do seu
+ assume-se que você definiu `basico/web` como a raiz de documentos do seu
servidor Web e configurou a URL de acesso de sua aplicação como `http://hostname/index.php`
- ou algo semelhantes. Por favor ajuste as URLs em nossas descrições às suas
- necessidades.
+ ou algo semelhante.
+ Por favor, ajuste as URLs em nossas descrições conforme necessário.
-Observe que ao contrário do próprio framework, após a instalação de um dos templates
-de projetos, você está livre para adicionar, remover ou sobrescrever qualquer código
-que precisar.
+Observe que, ao contrário do framework em si, após o template de projeto ser instalado, ele é todo seu. Você está livre para adicionar ou remover código e modificar o template conforme precisar.
Funcionalidade
@@ -27,32 +24,27 @@ O template básico de projetos instalado contém quatro páginas:
* a página "About" (Sobre),
* a página "Contact" (Contato), que exibe um formulário de contato que permite
que usuários finais entrem em contato com você via e-mail,
-* e a página "Login", que exibe um formulário de login que pode ser usado
- para aurenticar usuários finais. Tente fazer o login com "admin/admin", e
- você perceberá que o item do menu principal "Login" mudará para "Logout".
+* e a página "Login", que exibe um formulário de login que pode ser usado para aurenticar usuários finais.
+ Tente fazer o login com "admin/admin", e você perceberá que o item do menu principal "Login" mudará para "Logout".
-Estas páginas compartilham um cabeçalho e rodapé em comum. O cabeçalho contém
-uma barra de menu principal que permite a navegação através das diferentes páginas.
+Essas páginas compartilham o mesmo cabeçalho e rodapé. O cabeçalho contém uma barra de menu principal que permite a navegação entre as diferentes páginas.
Você também deverá ver uma barra de ferramentas no rodapé da janela do navegador.
-Essa é uma [ferramenta de depuração](tool-debugger.md) fornecida pelo Yii para
-registrar e exibir várias informações de depuração, tais como mensagens de logs,
-status de respostas, as consultas de banco de dados executadas, e assim por diante.
+Essa é uma [ferramenta de depuração](tool-debugger.md) muito útil fornecida pelo Yii para
+registrar e exibir várias informações de depuração, tais como: mensagens de logs, status de respostas, as consultas de banco de dados executadas, e assim por diante.
+
+Além da aplicação Web, existe um script de console chamado `yii`, que está localizado no diretório raiz da aplicação.
+Esse script pode ser usado para executar rotinas em segundo plano e tarefas de manutenção da aplicação que são descritas na seção [Comandos de Console](tutorial-console.md).
-Além da aplicação Web, existe um script console chamado `yii`, que está localizado
-na pasta base da aplicação.
-Este script pode ser usado para executar rotinas em segundo plano e tarefas de
-manutenção da aplicação, descritas na [seção Comandos de Console](tutorial-console.md).
Estrutura da Aplicação
----------------------
-Os diretórios e arquivos mais importantes em sua aplicação são (assumindo que
-o diretório raiz de sua aplicação é `basic`):
+Os diretórios e arquivos mais importantes em sua aplicação, assumindo que o diretório raiz dela é o `basico`, são:
```
-basic/ caminho base de sua aplicação
- composer.json usado pelo Composer, descreve as informações de pacotes
+basico/ caminho base de sua aplicação
+ composer.json usado pelo Composer, descreve informações de pacotes
config/ contém as configurações da aplicação e outras
console.php a configuração da aplicação de console
web.php a configuração da aplicação Web
@@ -68,10 +60,8 @@ basic/ caminho base de sua aplicação
yii o script de execução dos comandos de console do Yii
```
-Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em
-`basic/web` e aqueles em outros diretórios. Os primeiros podem ser acessados
-diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
-e nem deveriam.
+Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em `basico/web` e aqueles em outros diretórios.
+Os primeiros podem ser acessados diretamente via HTTP (ou seja, em um navegador), enquanto os demais não podem e deveriam ser acessados.
O Yii implementa o padrão de arquitetura [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
que se reflete na organização de diretórios acima. O diretório `models` contém
@@ -84,36 +74,30 @@ O diagrama a seguir demonstra a estrutura estática de uma aplicação.

Cada aplicação tem um script de entrada `web/index.php` que é o único script PHP
-acessível pela Web na aplicação. O script de entrada recebe uma requisição e
-cria uma instância da [aplicação](structure-applications.md) para gerenciá-la.
-A [aplicação](structure-applications.md) resolve a requisição com a ajuda de seus
-[componentes](concept-components.md), e despacha a requisição para os elementos
-do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md)
-para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
+acessível pela Web na aplicação. O script de entrada recebe uma requisição e cria uma instância de [aplicação](structure-applications.md) para tratar a requisição.
+A [aplicação](structure-applications.md) resolve ("traduz") a requisição com a ajuda de seus [componentes](concept-components.md) e despacha a requisição para os elementos do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md) para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
Ciclo de Vida da Requisição
---------------------------
-O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
+O diagrama a seguir demonstra como uma aplicação trata uma requisição.

1. Um usuário faz uma requisição ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
2. O script de entrada carrega a [configuração](concept-configurations.md) da
- aplicação e cria uma instância da [aplicação](structure-applications.md) para
- gerenciar a requisição.
-3. A aplicação resolve a [rota](runtime-routing.md) solicitada com a ajuda do
- componente de aplicação [request](runtime-requests.md).
+ aplicação e cria uma instância de [aplicação](structure-applications.md) para
+ tratar a requisição.
+3. A aplicação resolve ("traduz") a [rota](runtime-routing.md) solicitada com a ajuda do componente [request](runtime-requests.md) da aplicação.
4. A aplicação cria uma instância de um [controller](structure-controllers.md)
- para gerenciar a requisição.
-5. O controller cria uma instância de um [action](structure-controllers.md) (ação)
- e aplica os filtros para a ação.
+ para tratar a requisição.
+5. O controller cria uma instância de uma [action](structure-controllers.md) (ação) e aplica os filtros para a ação.
6. Se qualquer filtro falhar, a ação é cancelada.
7. Se todos os filtros passarem, a ação é executada.
-8. A ação carrega um modelo de dados, possivelmente a partir de um banco de dados.
-9. A ação renderiza uma view, fornecendo a ela o modelo de dados.
-10. O resultado renderizado é retornado pelo componente de aplicação
- [response](runtime-responses.md) (resposta).
-11. O componente *response* envia o resultado renderizado para o navegador do usuário.
+8. A ação carrega alguns modelos (models) de dados, possivelmente a partir de um banco de dados.
+9. A ação renderiza uma view, passando a ela os modelos de dados.
+10. O resultado renderizado é retornado pelo componente
+ [response](runtime-responses.md) (resposta) da aplicação.
+11. O componente response envia o resultado renderizado para o navegador do usuário.
diff --git a/docs/guide/start-hello.md b/docs/guide/start-hello.md
index c812001341..c99bf55630 100644
--- a/docs/guide/start-hello.md
+++ b/docs/guide/start-hello.md
@@ -54,7 +54,7 @@ The name after the `action` prefix maps to the action's ID.
When it comes to naming your actions, you should understand how Yii treats action IDs. Action IDs are always
referenced in lower case. If an action ID requires multiple words, they will be concatenated by dashes
-(e.g., `create-comment`). Action method names are mapped to action IDs by removing any dashes from the IDs,
+(e.g., `create-comment`). Action method IDs are mapped to action names by removing any dashes from the IDs,
capitalizing the first letter in each word, and prefixing the resulting string with `action`. For example,
the action ID `create-comment` corresponds to the action method name `actionCreateComment`.
@@ -67,7 +67,7 @@ a `message` parameter with a value of `"Goodbye"`, the `$message` variable withi
Within the action method, [[yii\web\Controller::render()|render()]] is called to render
a [view](structure-views.md) file named `say`. The `message` parameter is also passed to the view
so that it can be used there. The rendering result is returned by the action method. That result will be received
-by the application and displayed to the end user in the browser (as part of a complete HTML page).
+by the application and displayed to the end user in the browser (as part of a complete HTML page).
Creating a View
@@ -107,7 +107,7 @@ http://hostname/index.php?r=site%2Fsay&message=Hello+World

-This URL will result in a page displaying "Hello World". The page shares the same header and footer as the other application pages.
+This URL will result in a page displaying "Hello World". The page shares the same header and footer as the other application pages.
If you omit the `message` parameter in the URL, you would see the page display just "Hello". This is because `message` is passed as a parameter to the `actionSay()` method, and when it is omitted,
the default value of `"Hello"` will be used instead.