mirror of
https://github.com/yiisoft/yii2.git
synced 2025-08-20 10:27:18 +08:00
docs/guide-pt-BR/start-workflow.md - typo
close #6216 docs/guide-pt-BR/start-forms.md - translate close #6218 docs/guide-pt-BR/start-databases.md - typo close #6219 docs/guide-pt-BR/start-gii.md - typo/fixed close #6221 docs/guide-pt-BR/start-looking-ahead.md - update close #6222 docs/guide-pt-BR/structure-overview.md - typo close #6223 docs/guide-pt-BR/structure-entry-scripts.md - typo close #6224
This commit is contained in:
Davidson Alencar
committed by
Carsten Brandt
Carsten Brandt
parent
94a5041723
commit
dda46109cd
@ -12,11 +12,11 @@ Através 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 modo paginado
|
||||
* 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 declarações SQL usando uma ferramente de cliente
|
||||
banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
|
||||
de BD.
|
||||
|
||||
|
||||
@ -86,7 +86,7 @@ através da qual você pode fazer consultas de 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`.
|
||||
|
||||
> Info: O arquivo `config/db.php` será incluso pela configuração principal da
|
||||
> Informação: O arquivo `config/db.php` será 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).
|
||||
|
||||
@ -114,7 +114,7 @@ A classe `Country` estende de [[yii\db\ActiveRecord]]. Você não precisa escrev
|
||||
nenhum código nela! Só com o código acima, o Yii adivinhará o nome da tabela
|
||||
associada a partir do nome da classe.
|
||||
|
||||
> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
|
||||
> 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()]]
|
||||
para especificar explicitamente o nome da tabela associada.
|
||||
|
||||
@ -138,8 +138,8 @@ $country->name = 'U.S.A.';
|
||||
$country->save();
|
||||
```
|
||||
|
||||
> Info: O Active Record é uma maneira poderosa de acessar e manipular os dados
|
||||
do banco de dados de um modo orientado a objeto. Você pode encontrar informações
|
||||
> 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).
|
||||
@ -242,7 +242,7 @@ os dados dos países com a página correspondente.
|
||||
Testando <a name="trying-it-out"></a>
|
||||
--------
|
||||
|
||||
Para verificar se todo o código acima funciona, use o seu navegador para
|
||||
Para verificar se todo os códigos acima funcionam, use o seu navegador para
|
||||
acessar a seguinte URL:
|
||||
|
||||
```
|
||||
|
||||
270
docs/guide-pt-BR/start-forms.md
Normal file
270
docs/guide-pt-BR/start-forms.md
Normal file
@ -0,0 +1,270 @@
|
||||
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.
|
||||
|
||||
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).
|
||||
|
||||
Através 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)
|
||||
|
||||
|
||||
Criando uma Modelo (Model) <a name="creating-model"></a>
|
||||
----------------
|
||||
|
||||
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.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
namespace app\models;
|
||||
|
||||
use yii\base\Model;
|
||||
|
||||
class EntryForm extends Model
|
||||
{
|
||||
public $name;
|
||||
public $email;
|
||||
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
[['name', 'email'], 'required'],
|
||||
['email', 'email'],
|
||||
];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii,
|
||||
comumente usados para representar dados do formulário.
|
||||
|
||||
> 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.
|
||||
|
||||
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:
|
||||
|
||||
* tanto os valores do `name` quanto do `email` sejam obrigatórios
|
||||
* os dados do `email` devem ser um e-mail válido sintaticamente
|
||||
|
||||
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
|
||||
[[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]].
|
||||
|
||||
```php
|
||||
<?php
|
||||
$model = new EntryForm();
|
||||
$model->name = 'Qiang';
|
||||
$model->email = 'bad';
|
||||
if ($model->validate()) {
|
||||
// Bom!
|
||||
} else {
|
||||
// Falha!
|
||||
// Utilize $model->getErrors()
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Criando uma Ação <a name="creating-action"></a>
|
||||
------------------
|
||||
|
||||
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).
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
namespace app\controllers;
|
||||
|
||||
use Yii;
|
||||
use yii\web\Controller;
|
||||
use app\models\EntryForm;
|
||||
|
||||
class SiteController extends Controller
|
||||
{
|
||||
// ...código existente...
|
||||
|
||||
public function actionEntry()
|
||||
{
|
||||
$model = new EntryForm;
|
||||
|
||||
if ($model->load(Yii::$app->request->post()) && $model->validate()) {
|
||||
// dados válidos recebidos pelo $model
|
||||
|
||||
// fazer alguma coisa aqui sobre $model ...
|
||||
|
||||
return $this->render('entry-confirm', ['model' => $model]);
|
||||
} else {
|
||||
// Ou a página é exibida inicialmente ou existe algum erro de validação
|
||||
return $this->render('entry', ['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.
|
||||
|
||||
> 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`.
|
||||
|
||||
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.
|
||||
|
||||
> 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).
|
||||
|
||||
|
||||
Criando Visões <a name="creating-views"></a>
|
||||
--------------
|
||||
|
||||
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.
|
||||
|
||||
A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`.
|
||||
Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
|
||||
|
||||
```php
|
||||
<?php
|
||||
use yii\helpers\Html;
|
||||
?>
|
||||
<p>You have entered the following information:</p>
|
||||
|
||||
<ul>
|
||||
<li><label>Name</label>: <?= Html::encode($model->name) ?></li>
|
||||
<li><label>Email</label>: <?= Html::encode($model->email) ?></li>
|
||||
</ul>
|
||||
```
|
||||
|
||||
A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
|
||||
|
||||
```php
|
||||
<?php
|
||||
use yii\helpers\Html;
|
||||
use yii\widgets\ActiveForm;
|
||||
?>
|
||||
<?php $form = ActiveForm::begin(); ?>
|
||||
|
||||
<?= $form->field($model, 'name') ?>
|
||||
|
||||
<?= $form->field($model, 'email') ?>
|
||||
|
||||
<div class="form-group">
|
||||
<?= Html::submitButton('Submit', ['class' => 'btn btn-primary']) ?>
|
||||
</div>
|
||||
|
||||
<?php ActiveForm::end(); ?>
|
||||
```
|
||||
|
||||
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.
|
||||
|
||||
|
||||
Testando <a name="trying-it-out"></a>
|
||||
-------------
|
||||
|
||||
Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
|
||||
|
||||
```
|
||||
http://hostname/index.php?r=site/entry
|
||||
```
|
||||
|
||||
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.
|
||||
|
||||
|
||||
|
||||
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 <a name="magic-explained"></a>
|
||||
|
||||
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.
|
||||
|
||||
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.
|
||||
|
||||
> 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.
|
||||
|
||||
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`.
|
||||
|
||||
Você pode personalizar um *label* em uma visão utilizando o seguinte código:
|
||||
|
||||
```php
|
||||
<?= $form->field($model, 'name')->label('Your Name') ?>
|
||||
<?= $form->field($model, 'email')->label('Your Email') ?>
|
||||
```
|
||||
|
||||
> 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.
|
||||
|
||||
|
||||
Resumo <a name="summary"></a>
|
||||
-------
|
||||
|
||||
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.
|
||||
|
||||
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
|
||||
necessários em quase todas as aplicações.
|
||||
@ -14,7 +14,7 @@ Através desse tutorial, você irá aprender a:
|
||||
Começando a usar o Gii <a name="starting-gii"></a>
|
||||
------------
|
||||
|
||||
[Gii](tool-gii.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](tool-gii.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`:
|
||||
|
||||
```php
|
||||
$config = [ ... ];
|
||||
@ -68,7 +68,7 @@ Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê
|
||||
|
||||
|
||||
|
||||
Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "sobrescrever" e clique no botão "Gerar". Se estiver criando um arquivo novo, apenas clique em "Gerar".
|
||||
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".
|
||||
|
||||
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.
|
||||
|
||||
@ -76,7 +76,7 @@ Em seguida, você verá uma página de confirmação indicando que o código foi
|
||||
Gerando código CRUD <a name="generating-crud"></a>
|
||||
--------------------
|
||||
|
||||
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 "Gerador CRUD" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
|
||||
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:
|
||||
|
||||
* Classe do Modelo: `app\models\Country`
|
||||
* Classe da Busca: `app\models\CountrySearch`
|
||||
@ -116,7 +116,7 @@ Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar com
|
||||
* Modelo: `models/Country.php` e `models/CountrySearch.php`
|
||||
* Views: `views/country/*.php`
|
||||
|
||||
> Info: 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](tool-gii.md).
|
||||
> 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](tool-gii.md).
|
||||
|
||||
|
||||
Resumo <a name="summary"></a>
|
||||
|
||||
@ -4,7 +4,7 @@ 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 modo paginado.
|
||||
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.
|
||||
@ -13,25 +13,25 @@ Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais pro
|
||||
usando o framework.
|
||||
|
||||
* Documentação
|
||||
- O Guia Definitivo:
|
||||
- [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.
|
||||
- A Referência de Classes (Class Reference):
|
||||
- [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:
|
||||
- [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
|
||||
soluções prontas para serem usadas.
|
||||
- Livros
|
||||
- [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
|
||||
|
||||
@ -7,7 +7,7 @@ dependendo da sua configuração. Esta seção introduzirá a funcionalidade emb
|
||||
da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
|
||||
em geral.
|
||||
|
||||
> Info: Por questões de simpicidade, por todo este tutorial de "Primeiros Passos"
|
||||
> 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
|
||||
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
|
||||
@ -17,7 +17,7 @@ em geral.
|
||||
Funcionalidade <a name="functionality"></a>
|
||||
--------------
|
||||
|
||||
A aplicação básica contém quatro páginas:
|
||||
A aplicação básica instalada contém quatro páginas:
|
||||
|
||||
* A página inicial, exibida quando você acessa a URL `http://hostname/index.php`,
|
||||
* a página "About" (Sobre),
|
||||
@ -65,7 +65,7 @@ Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles
|
||||
diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
|
||||
e nem deveriam.
|
||||
|
||||
O Yii implementa o padrão de projeto [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
|
||||
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
|
||||
todas as [classes de modelos](structure-models.md), o diretório `views` contém todos
|
||||
os [scripts de visões](structure-views.md), e o diretório `controllers` contém
|
||||
@ -77,7 +77,7 @@ 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 manejá-la.
|
||||
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)
|
||||
@ -91,7 +91,7 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
|
||||
|
||||
|
||||
|
||||
1. Um usuário faz uma requisiçao ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
|
||||
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.
|
||||
@ -99,8 +99,8 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
|
||||
componente de aplicação [request](runtime-requests.md).
|
||||
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 da [action](structure-controllers.md) (ação)
|
||||
e aplica os filtros da ação.
|
||||
5. O controller cria uma instância de um [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.
|
||||
|
||||
@ -2,7 +2,7 @@ Scripts de Entrada
|
||||
==================
|
||||
|
||||
Scripts de entrada são o primeiro passo no processo de inicialização da aplicação.
|
||||
Uma aplicação (seja uma aplicação Web ou do console) possui um único script de
|
||||
Uma aplicação (seja uma aplicação Web ou uma aplicação console) possui um único script de
|
||||
entrada. Os usuários finais fazem requisições a scripts de entrada que criam
|
||||
as instâncias da aplicação e redirecionam as requisições para elas.
|
||||
|
||||
@ -27,7 +27,7 @@ O trabalho principal dos scripts de entrada é o seguinte:
|
||||
* Chamar [[yii\base\Application::run()]] para processar as requisições que chegam.
|
||||
|
||||
|
||||
## Aplicações da Web <a name="web-applications"></a>
|
||||
## Aplicações Web <a name="web-applications"></a>
|
||||
|
||||
Este é o código no script de entrada para o [Modelo Básico de Aplicação Web](start-installation.md).
|
||||
|
||||
@ -51,7 +51,7 @@ $config = require(__DIR__ . '/../config/web.php');
|
||||
```
|
||||
|
||||
|
||||
## Aplicações do Console <a name="console-applications"></a>
|
||||
## Aplicações Console <a name="console-applications"></a>
|
||||
|
||||
De forma semelhante, o seguinte é o código do script de entrada de uma aplicação
|
||||
do console:
|
||||
|
||||
@ -15,7 +15,7 @@ Além do MVC, as aplicações do Yii também possuem as seguintes entidades:
|
||||
ciclo de tratamento de uma requisição.
|
||||
* [aplicações](structure-applications.md): são objetos globalmente acessíveis que
|
||||
gerenciam os componentes da aplicação e os coordenam para atender às requisições.
|
||||
* [componentes de aplicação](structure-application-components.md): são objetos
|
||||
* [componentes da aplicação](structure-application-components.md): são objetos
|
||||
registrados com as aplicações e fornecem vários serviços para atender às
|
||||
requisições.
|
||||
* [módulos](structure-modules.md): são pacotes auto-contidos que contém um MVC
|
||||
|
||||
Reference in New Issue
Block a user