* Translates start prerequisites to pt-BR
* Fixes grammatical and didactic errors
* Updates new topics and fixes minor grammatical errors
* Updates translation and fixes grammatical and conceptual errors
tags/2.0.16.1
Sidney Lins6 years agocommitted byAlexander Makarov
@ -2,27 +2,25 @@ Atualizando a partir da Versão 1.1
==================================
Existem muitas diferenças entre as versões 1.1 e 2.0 do Yii, uma vez que o
framework foi completamente reescrito no 2.0.
framework foi completamente reescrito na 2.0.
Por causa disso, atualizar a partir da versão 1.1 não é tão trivial quanto atualizar de versões menores. Neste guia você encontrará as principais diferenças entre as duas versões.
Se você nunca usou o Yii 1.1 antes, você pode pular com segurança esta seção
e ir diretamente para "[Instalando o Yii](start-installation.md)".
Por favor perceba que o Yii 2.0 introduz mais novas funcionalidades do que as que
são abordadas neste resumo. Recomenda-se fortemente que você leia completamente
o guia definitivo para aprender todas elas. É possível que algumas das funcionalidades
que antes você tinha que desenvolver por conta própria agora sejam partes do
Por favor, note que o Yii 2.0 introduz outras novas funcionalidades além das que
são abordadas neste resumo. Recomenda-se fortemente que você leia o guia definitivo por completo para aprender todas elas. É possível que algumas funcionalidades
que antes você tinha de desenvolver por conta própria agora façam parte do
código principal.
Instalação
----------
O Yii 2.0 adota plenamente o [Composer](https://getcomposer.org/), o gerenciador
de pacotes PHP. Tanto a instalação do núcleo do framework quanto das
extensões são gerenciados através do Composer. Por favor consulte a seção
O Yii 2.0 utiliza plenamente o [Composer](https://getcomposer.org/), o gerenciador
de pacotes PHP. Tanto a instalação do núcleo do framework quanto das extensões são feitas através do Composer. Por favor, consulte a seção
[Instalando o Yii](start-installation.md) para aprender como instalar
o Yii 2.0. Se você quiser criar novas extensões, ou tornar compatíveis as suas extensões
o Yii 2.0. Se você quer criar novas extensões ou tornar compatíveis as suas extensões
existentes do 1.1 com o 2.0, por favor consulte a seção [Criando Extensões](structure-extensions.md#creating-extensions)
do guia.
@ -30,15 +28,14 @@ do guia.
Requisitos do PHP
-----------------
O Yii 2.0 requer o PHP 5.4 ou superior, que é uma grande melhoria sobre a versão
5.2 do PHP, que era exigida pelo Yii 1.1.
Como resultado, existem muitas diferenças a nível de linguagem às quais você deveria prestar atenção.
Segue abaixo um resumo das principais mudanças no que diz respeito ao PHP:
O Yii 2.0 requer o PHP 5.4 ou superior, que é uma versão de grande melhoria sobre a versão 5.2, que era exigida pelo Yii 1.1.
Como resultado, existem muitas diferenças na linguagem às quais você deve dar a devida atenção.
Segue abaixo um resumo das principais mudanças do PHP:
Existem muitas melhorias das funcionalidades de eventos. Para mais detalhes,
por favor consulte a seção [Eventos](concept-events.md).
Há muitas melhorias nas funcionalidades de evento. Para mais detalhes,
por favor, consulte a seção [Eventos](concept-events.md).
Path Aliases
------------
O Yii 2.0 expande o uso de *path aliases* (apelidos de caminhos) para caminhos
de arquivos e diretórios e URLs. O Yii 2.0 agora também requer que um nome de alias
comece com o caractere `@`, para diferenciar aliases de caminhos e URLs normais
de arquivos e diretórios. Por exemplo, o alias `@yii` se refere ao diretório de
O Yii 2.0 expande o uso de *path aliases* (apelidos de caminhos) tanto para caminhos de arquivos e diretórios como para URLs. Agora ele requer que um nome de alias
comece com o caractere `@` para diferenciar entre aliases e caminhos e URLs normais de arquivos e diretórios. Por exemplo, o alias `@yii` se refere ao diretório de
instalação do Yii. Os path aliases são suportados na maior porte do código do core
do Yii. Por exemplo, o método [[yii\caching\FileCache::cachePath]] pode receber
tanto um path alias quanto um caminho de diretório normal.
Um path alias também está intimamente relacionado a um namespace de classe.
Recomenda-se que um path alias seja definido para cada namespace raiz, desta forma
É recomendado que um path alias seja definido para cada namespace raiz, desta forma
permitindo que você use o auto-carregamento de classes do Yii sem qualquer
configuração adicional. Por exemplo, como `@yii` se refere ao diretório de
instalação do Yii, uma classe como `yii\web\Request` pode ser carregada
@ -170,22 +165,21 @@ Framework, você pode definir um path alias `@Zend` que se refere ao diretório
de instalação desse framework. Uma vez que você tenha feito isso, o Yii também
poderá carregar automaticamente qualquer classe nessa biblioteca do Zend Framework.
Você pode encontrar mais sobre *path aliases* na seção [Aliases](concept-aliases.md).
Você pode encontrar mais informações sobre *path aliases* na seção [Aliases](concept-aliases.md).
Views (Visões)
--------------
A mudança mais significante das views no Yii 2 é que a variável especial `$this`
em uma view não se refere mais ao controller (controlador) ou widget atual.
Ao invés disso, `$this` agora se refere a um objeto **view**, um novo conceito
introduzido no 2.0. O objeto *view* é do tipo [[yii\web\View]], que representa a
parte da visão do padrão MVC. Se você quiser acessar o controlador (controller) ou
em uma view não se refere mais ao controller ou widget atual. Ao invés disso, `$this` agora se refer[ a um objeto **view**, um novo conceito
introduzido no 2.0. O objeto *view* é do tipo [[yii\web\View]] e representa a
parte da visão do padrão MVC. Se você quiser acessar o controller ou
o widget em uma visão, você pode utilizar `$this->context`.
Para renderizar uma visão parcial (partial view) dentro de outra view, você usa
`$this->render()`, e não `$this->renderPartial()`. Agora a chamada de `render`
também precisa ser explicitamente imprimida com *echo*, uma vez que o métood
Para renderizar uma view parcial (partial view) dentro de outra view, você usa
`$this->render()`, e não `$this->renderPartial()`. Agora a chamada de `render`
também precisa ser explicitamente impressa com *echo*, uma vez que o métood
`render()` retorna o resultado da renderização ao invés de exibi-lo diretamente.
Por favor consulte a seção [Widgets](structure-widgets.md) para mais detalhes.
Por favor, consulte a seção [Widgets](structure-widgets.md) para mais detalhes.
Temas
-----
Os temas funcionam de maneira completamente diferente no 2.0. Agora eles se baseiam
em um mecanismo de mapeamento de caminhos que mapeia um caminho de arquivo de view (visão) fonte
em um mecanismo de mapeamento de caminhos que mapeia um caminho de arquivo de view fonte
a um caminho de arquivo de view com o tema. Por exemplo, se o mapa de caminho de um tema
é `['/web/views' => '/web/themes/basic']`, então a versão com tema deste arquivo
de view `/web/views/site/index.php` será `/web/themes/basic/site/index.php`.
Por esse motivo, os temas agora podem ser aplicados a qualquer arquivo de view,
até mesmo uma view renderizada fora do contexto de um controller ou widget.
Além disso, não há mais um componente `CThemeManager`. Ao invés disso, `theme` é
uma propriedade configurável do componente de aplicação `view`.
Além disso, não há mais um componente `CThemeManager`. Em vez disso, `theme` é
uma propriedade configurável do componente `view` da aplicação.
Por favor consulte a seção [Temas](tutorial-theming.md) para mais detalhes.
Por favor, consulte a seção [Temas](tutorial-theming.md) para mais detalhes.
Aplicações de Console
---------------------
As aplicações de console agora são organizadas como controllers (controladores),
As aplicações de console agora são organizadas como controllers
assim como as aplicações web. Os controllers de console devem estender de [[yii\console\Controller]],
de maneira semelhante à `CConsoleCommand` no 1.1.
Para rodar um comando do console, use `yii <rota>`, onde `<rota>` representa a rota de
um controller (por exemplo, `sitemap/index`). Argumentos anônimos adicionais são
passados como os parâmetros correspondentes ao método da ação do controller, enquanto
argumentos com nome são parseados de acordo com as declarações em [[yii\console\Controller::options()]].
passados como parâmetros à action correspondente no controller, enquanto
argumentos com nome são "convertidos" de acordo com as declarações em [[yii\console\Controller::options()]].
O Yii 2.0 suporta a geração automática de informação de ajuda do comando a partir
de blocos de comentários.
O Yii 2.0 suporta a geração automática de informação de ajuda do comando a partir de blocos de comentários.
Por favor consulte a seção [Comandos de Console](tutorial-console.md) para mais detalhes.
@ -334,12 +326,11 @@ Por favor consulte a seção [Comandos de Console](tutorial-console.md) para mai
I18N
----
O Yii 2.0 remove os formatters de data e número em favor do módulo
O Yii 2.0 remove os formatadores de data e número embutidos em favor do módulo
[intl do PECL do PHP](http://pecl.php.net/package/intl).
A tradução de mensagens agora é realizaada pelo componente de aplicação `i18n`.
Este componente gerencia um conjunto de fontes de mensagens, que lhe permite
usar diferentes fontes de mensagens baseadas nas categorias das mensagens.
A tradução de mensagens agora é realizada pelo componente `i18n` da aplicação.
Este componente gerencia um conjunto de fontes de mensagens, o que permite a você usar diferentes fontes de mensagens baseadas em categorias de mensagens.
Por favor consulte a seção [Internacionalização](tutorial-i18n.md) para mais detalhes.
@ -347,10 +338,9 @@ Por favor consulte a seção [Internacionalização](tutorial-i18n.md) para mais
Action Filters (Filtros de Ação)
--------------------------------
Agora os action filters (filtros de ação) são implementados via behaviors.
Agora os filtros de ação (action filters) são implementados via comportamentos (behaviors).
Para definir um novo filtro personalizado, estenda de [[yii\base\ActionFilter]].
Para usar um filtro, anexe a classe do filtro ao controller (controlador) como um
behavior. Por exemplo, para usar o filtro [[yii\filters\AccessControl]],
Para usar um filtro, anexe a classe do filtro ao controller como um behavior. Por exemplo, para usar o filtro [[yii\filters\AccessControl]],
Ao fazer o eager loading (carregamento na inicialização) de um relacionamento,
Ao fazer o eager loading (carregamento antecipado) de um relacionamento,
o Yii 2.0 faz isso de maneira diferente do 1.1. Em particular, no 1.1 uma consulta
JOIN seria criada para selecionar tanto o registro primário quanto os de
relacionamentos. No Yii 2.0, duas instruções SQL são executadas sem usar JOIN:
a primeira instrução retorna os registros principais e a segunda retorna os registros
de relacionamentos filtrando pelas chaves primários dos registros principais.
a primeira instrução retorna os registros primários e a segunda retorna os registros
relacionados por filtrar pelas chaves primárias dos registros primários.
Ao invés de retornar objetos [[yii\db\ActiveRecord|ActiveRecord]], você pode
Em vez de retornar objetos [[yii\db\ActiveRecord|ActiveRecord]], você pode
encadear o método [[yii\db\ActiveQuery::asArray()|asArray()]] ao construir uma
consulta para retornar um grande número de registros. Isso fará com que o resultado
da consulta retorne como arrays, o que pode reduzir significativamente o tempo
de CPU e memória necessários para um grande número de registros. Por exemplo,
```php
$customers = Customer::find()->asArray()->all();
$clientes = Cliente::find()->asArray()->all();
```
Outra mudança é que você não pode mais definir valores padrão de atributos através
@ -520,7 +508,7 @@ init na classe do seu registro.
public function init()
{
parent::init();
$this->status = self::STATUS_NEW;
$this->status = self::STATUS_NOVO;
}
```
@ -528,31 +516,59 @@ Havia alguns problemas ao sobrescrever o construtor de uma classe ActiveRecord
no 1.1. Estes não ocorrem mais na versão 2.0. Perceba que ao adicionar parâmetros
ao construtor você pode ter que sobrescrever o método [[yii\db\ActiveRecord::instantiate()]].
Existem muitas outras mudanças e melhorias no Active Record. Por favor consulte
Existem muitas outras mudanças e melhorias no Active Record. Por favor, consulte
a seção [Active Record](db-active-record.md) para mais detalhes.
Comportamentos (Behaviors) do Active Record
-----------------------
No Yii 2, removemos a classe base de behaviors `CActiveRecordBehavior`. Se você quer criar um Active Record Behavior, você terá que estender diretamente de `yii\base\Behavior`. Se a classe behavior class precisa responder a algums eventos da classe que a possui, você deve sobrescrever o método `events()` conforme a seguir:
A classe `CWebUser` do 1.1 agora foi substituída pela [[yii\web\User]], e não há
mais a classe `CUserIdentity`. Ao invés disso, você deve implementar a interface
[[yii\web\IdentityInterface]] que é muito mais simples de usar. O template avançado
de projetos dá um exemplo disso.
A classe `CWebUser` do 1.1 foi substituída pela [[yii\web\User]] e não há
mais a classe `CUserIdentity`. Em vez disso, você deve implementar a interface
[[yii\web\IdentityInterface]] que é muito mais simples de usar. O template avançado
de projetos fornece um exemplo de como fazer isso.
Por favor consulte as seções [Autenticação](security-authentication.md),
[Autorização](security-authorization.md), e [Template Avançado de Projetos](tutorial-advanced-app.md)
Por favor, consulte as seções [Autenticação](security-authentication.md),
[Autorização](security-authorization.md) e [Template Avançado de Projetos](tutorial-advanced-app.md)
para mais detalhes.
Gerenciamento de URLs
---------------------
O gerenciamento de URLs no Yii 2 é semelhante ao do 1.1. A principal melhoria
é que o gerenciamento de URL agora suporta parâmetros opcionais. Por exemplo,
se você tiver uma regra declarada como a seguir, então ela corresponderá
tanto `post/popular` quanto `post/1/popular`. No 1.1, você teria que usar duas
regrar para este mesmo fim.
O gerenciamento de URLs no Yii 2 é semelhante ao do 1.1. Uma grande melhoria é que o gerenciamento de URLs agora suporta parâmetros opcionais. Por exemplo,
se você tiver uma regra declarada como a seguir, ela vai corresponder tanto a `post/popular` quanto a `post/1/popular`. No 1.1, você teria que usar duas
regrar para fazer isso.
```php
[
@ -562,10 +578,14 @@ regrar para este mesmo fim.
]
```
Por favor consulte a seção da [documentação de gerenciamento de URL](runtime-routing.md) para mais detalhes.
Por favor, consulte a seção [Roteamento e Criação de URL](runtime-routing.md) para mais detalhes.
Uma importante mudança nas convenções de nomes para rotas é que actions e controllers com nomes em estilo camel case agora, quando referenciados em rotas, são convertidos para minúsculas separando cada palavra com um hífen. Por exemplo, o ID de controller `GestaoDeClientesController` deve ser referenciado em uma rota como `gestao-de-clientes`.
Veja as seções [IDs de Controllers](structure-controllers.md#controller-ids) e [IDs de Actions](structure-controllers.md#action-ids) para mais detalhes.
Utilizando o Yii 1.1 e o 2.x juntos
-----------------------------------
Se você tem código legado do Yii 1.1 que você queira manter para utilizar com o
Yii 2.0, por favor, consulte a seção [Usando Yii 1.1 e 2.0 juntos](tutorial-yii-integration.md).
Se você tem código legado do Yii 1.1 que você quer utilizar com o Yii 2.0, por favor, consulte a seção [Usando Yii 1.1 e 2.0 juntos](tutorial-yii-integration.md).
O Yii é um framework PHP de alta performance e baseado em componentes, para o
desenvolvimento rápido de aplicações web modernas.
O nome Yii (pronunciado `Ii` ou `[ji:]`) significa "simples e evolutivo" em chinês. Ele também pode ser considerado como um acrônimo de **Yes It Is** (*sim, ele é*)!
Yii é um framework PHP de alta performance baseado em componentes para desenvolvimento rápido de aplicações web modernas.
O nome Yii (pronunciado `ii`) significa "simples e evolutivo" em chinês. Ele também pode ser considerado um acrônimo de **Yes It Is** (*Sim, ele é*)!
Para quê o Yii é melhor?
Yii é melhor para que tipo de aplicações?
------------------------
O Yii é um framework de programação web genérico, o que significa que ele pode
ser usado para o desenvolvimento de todo tipo de aplicações web baseadas usando PHP.
Yii é um framework de programação web genérico, o que significa que ele pode
ser usado para o desenvolvimento de todo tipo de aplicações web usando PHP.
Por causa de sua arquitetura baseada em componentes e suporte sofisticado a
caching, ele é especialmente adequado para o desenvolvimento de aplicações de
larga escala como portais, fóruns, sistemas de gerenciamento de conteúdo (CMS),
projetos de e-commerce, Web services RESTful, e assim por diante.
projetos de e-commerce, Web services RESTful e assim por diante.
Como o Yii se compara a outros frameworks?
Como o Yii se Compara a Outros Frameworks?
------------------------------------------
Se já estiver familiarizado com um outro framework, você pode gosta se saber como o Yii se compara:
Se já estiver familiarizado com um outro framework, você pode gostar de saber como o Yii se compara:
- Como a maioria dos frameworks PHP, o Yii implementa o padrão de arquitetura MVC
(Modelo-Visão-Controlador) e promove a organização do código baseada nesse padrão.
- O Yii tem a filosofia de que o código deveria ser escrito de uma maneira simples,
porém elegante. O Yii nunca tentará exagerar no design com o propósito principal
de seguir algum padrão de projeto.
- O Yii é um framework full-stack, fornecendo muitas funcionalidades comprovadas
- Yii tem a filosofia de que o código deveria ser escrito de uma maneira simples,
porém elegante. O Yii nunca vai tentar exagerar no projeto só para seguir estritamente algum padrão de projeto.
- Yii é um framework completo fornecendo muitas funcionalidades comprovadas
e prontas para o uso, tais como: construtores de consultas (query builders) e
ActiveRecord, tanto para bancos de dados relacionais quanto para NoSQL; suporte ao
ActiveRecord tanto para bancos de dados relacionais quanto para NoSQL; suporte ao
desenvolvimento de APIs RESTful; suporte a caching de múltiplas camadas; e mais.
- O Yii é extremamente extensível. Você pode personalizá-lo ou substituir quase
todas as partes do código core. Você também pode aproveitar-se de sua
sólida arquitetura de extensões, para utilizar ou desenvolver extensões
- Yii é extremamente extensível. Você pode personalizá-lo ou substituir quase
todas as partes do código central (core). Você também pode tirar vantagem de sua
sólida arquitetura de extensões para utilizar ou desenvolver extensões
que podem ser redistribuídas.
- A alta performance é sempre um objetivo principal do Yii.
- Alta performance é sempre um objetivo principal do Yii.
O Yii não é um show de um homem só, ele é apoiado por uma [forte equipe de desenvolvedores do core][about_yii]
bem como por uma ampla comunidade de muitos profissionais constantemente
Yii não é um show de um homem só, ele é apoiado por uma [forte equipe de desenvolvedores do código central (core)][about_yii]
bem como por uma ampla comunidade de profissionais constantemente
contribuindo com o desenvolvimento do Yii. A equipe de desenvolvedores do Yii
acompanha de perto às últimas tendências do desenvolvimento Web, e às
acompanha de perto às últimas tendências do desenvolvimento Web e as
melhores práticas e funcionalidades encontradas em outros frameworks e projetos.
As melhores práticas e funcionalidades mais relevantes encontradas em outros lugares
As mais relevantes e melhores práticas e características encontradas em outros lugares
são incorporadas regularmente no core do framework e expostas via interfaces
simples e elegantes.
@ -53,8 +51,7 @@ Versões do Yii
Atualmente, o Yii tem duas versões principais disponíveis: a 1.1 e a 2.0. A Versão
1.1 é a antiga geração e agora está em modo de manutenção. A versão 2.0 é uma
reescrita completa do Yii, adotando as tecnologias e protocolos mais recentes, incluindo
o Composer, PSR, namespaces, traits, e assim por diante. A versão 2.0 representa
reescrita completa do Yii, adotando as tecnologias e protocolos mais recentes, incluindo Composer, PSR, namespaces, traits, e assim por diante. A versão 2.0 representa
a geração atual do framework e receberá os nossos esforços principais de
desenvolvimento nos próximos anos. Este guia trata principalmente da versão 2.0.
@ -62,11 +59,11 @@ desenvolvimento nos próximos anos. Este guia trata principalmente da versão 2.
Requisitos e Pré-requisitos
---------------------------
O Yii 2.0 requer o PHP 5.4.0 ou superior. Você pode encontrar os requisitos mais
detalhados para funcionalidades em particular executando o verificador de requisitos
(requirement checker) incluído em todos os pacotes do Yii.
Yii 2.0 requer PHP 5.4.0 ou superior. Você pode encontrar requisitos mais
detalhados para recursos específicos executando o verificador de requisitos
(requirement checker) incluído em cada lançamento do Yii.
Utilizar o Yii requer conhecimentos básicos sobre programação orientada a objetos
(OOP), uma vez que o Yii é um framework puramente OOP.
O Yii 2.0 também utiliza as funcionalides mais recentes do PHP, tais como [namespaces](http://www.php.net/manual/en/language.namespaces.php) e [traits](http://www.php.net/manual/en/language.oop5.traits.php). Compreender estes conceitos lhe ajudará e entender mais facilmente o Yii 2.0
(OOP), uma vez que o Yii é um framework puramente OOP.
O Yii 2.0 também utiliza as funcionalides mais recentes do PHP, tais como [namespaces](http://www.php.net/manual/en/language.namespaces.php) e [traits](http://www.php.net/manual/en/language.oop5.traits.php). Compreender esses conceitos lhe ajudará a entender mais facilmente o Yii 2.0.
Você pode instalar o Yii de duas maneiras, usando o gerenciador de pacotes [Composer](https://getcomposer.org/)
Você pode instalar o Yii de duas maneiras: usando o gerenciador de pacotes [Composer](https://getcomposer.org/)
ou baixando um arquivo compactado. O primeiro modo é o preferido, já que permite
que você instale novas [extensões](structure-extensions.md) ou atualize o
Yii simplesmente executando um único comando.
A instalação do Yii padrão resulta no download e instalação tanto do framework
A instalação padrão do Yii resulta no download e instalação tanto do framework
quanto de um template de projetos.
Um template de projetos é uma aplicação do Yii implementando algumas recursos básicos,
como a autenticação, o formulário de contato, etc.
Este código é organizado de uma forma recomendada. No entanto, ele pode servir
Um template de projeto é um projeto funcional do Yii que implementa alguns recursos básicos, tais como: autenticação, formulário de contato, etc.
Este código é organizado de uma forma recomendada. Portanto, ele pode servir
como ponto de partida para seus projetos.
Nesta e nas próximas seções, iremos descrever como instalar o *Template Básico
de Projetos* do Yii e como implementar novas funcionalidades emcima deste template.
O Yii também fornece um outro template chamado de [Template Avançado de Projetos](https://github.com/yiisoft/yii2-app-advanced/blob/master/docs/guide-pt-BR/README.md) que é melhor usado em uma equipe de desenvolvimento que desenvolvem
aplicações de multiplas camadas.
Nesta e nas próximas seções, vamos descrever como instalar o *Template Básico
de Projetos* do Yii e como implementar novas funcionalidades sobre este template.
O Yii fornece ainda outro template chamado [Template Avançado de Projetos](https://github.com/yiisoft/yii2-app-advanced/blob/master/docs/guide-pt-BR/README.md) que é melhor usado em um ambiente de desenvolvimento em equipe e para desenvolver
aplicações com multiplas camadas.
> Informação: O Template Básico de Projetos é adequado para o desenvolvimento de
cerca de 90% das aplicações Web. Este template difere do Template Avançado de
Projetos principalmente na forma de como o seu código é organizado. Se você é
novo no Yii, recomendamos fortemente em escolher o Template Básico de Projetos
pela sua simplicidade além de ter funcionalidades o suficiente.
> Info: O Template Básico de Projetos é adequado para o desenvolvimento de
cerca de 90% das aplicações Web. Ele difere do Template Avançado de
Projetos principalmente em como o seu código é organizado. Se você é
novo no Yii, recomendamos fortemente escolher o Template Básico de Projetos
pela sua simplicidade e por manter suficientes funcionalidades.
Instalando via Composer <spanid="installing-via-composer"></span>
-----------------------
Se você já não tiver o Composer instalado, você pode fazê-lo seguindo as instruções
### Instalando o Composer
Se você ainda não tem o Composer instalado, você pode instalá-lo seguindo as instruções
em [getcomposer.org](https://getcomposer.org/download/). No Linux e no Mac OS X,
você executará os seguintes comandos:
@ -37,35 +38,47 @@ você executará os seguintes comandos:
No Windows, você baixará e executará o [Composer-Setup.exe](https://getcomposer.org/Composer-Setup.exe).
Por favor consulte a [Documentação do Composer](https://getcomposer.org/doc/) se
você encontrar quaisquer problemas ou se quiser aprender mais sobre o uso do Composer.
Por favor, consulte a seção de [Resolução de Problemas do Composer](https://getcomposer.org/doc/articles/troubleshooting.md) se você encontrar dificuldades. Se você é novo no assunto, nós também recomendamos que leia pelo menos a seção [Uso Básico](https://getcomposer.org/doc/01-basic-usage.md) na documentação do Composer.
Neste guia, todos os comandos do composer assumem que você o tem instaldo [globalmente](https://getcomposer.org/doc/00-intro.md#globally) de modo que ele seja acessível através do comando `composer`. Se em vez disso estiver usando o `composer.phar` no diretório local, você tem que ajustar os comandos de exemplo de acordo.
Se você já estiver com o Composer instalado, certifique-se de usar uma versão atualizada.
Se você já tem o Composer instalado, certifique-se de usar uma versão atualizada.
Você pode atualizar o Composer executando o comando `composer self-update`.
> Note: Durante a instalação do Yii, o Composer precisará solicitar muitas informações da API do Github.
> A quantidade de solicitações depende do número de dependências que sua aplicação possui e pode extrapolar a
> **taxa limite da API do Github**. Se você atingir esse limite, o Composer pode pedir a você suas credenciais de login para obter um
> token de acesso à API Github. Em conexões rápidas você pode atingir esse limite antes que o Composer consiga lidar com a situação, então, recomendamos
> configurar um toke de acesso antes de instalar o Yii.
> Por favor, consulte a [documentação do Composer sobre tokens da API Github](https://getcomposer.org/doc/articles/troubleshooting.md#api-rate-limit-and-oauth-tokens)
> para instruções de como fazer isso.
### Instalando o Yii <spanid="installing-from-composer"></span>
Com o Composer instalado, você pode instalar o Yii executando o seguinte comando
em um diretório acessível pela Web:
composer global require "fxp/composer-asset-plugin:^1.4.1"
O primeiro comando instala o [composer asset plugin](https://github.com/francoispluchino/composer-asset-plugin/)
o que permite gerenciar dependências via bower e npm package por meio do Composer.
Você apenas precisa rodar este comando uma vez. O segundo comando instala o Yii
em um diretório chamado `basic`. Você pode escolher um diretório diferente se quiser.
Isto vai instalar a versão estável mais recente do Yii em um diretório chamado `basico`.
Você pode especificar um nome de diretório diferente se quiser.
> Observação: Durante a instalação, o Composer pode pedir suas credenciais de login
> do Github. Isto é normal, pelo fato do Composer precisar obter a taxa limite
> (rate-limit) da API para recuperar as informações de dependência de pacotes do
> Github. Para mais detalhes, consulte a [documentação do Composer](https://getcomposer.org/doc/articles/troubleshooting.md#api-rate-limit-and-oauth-tokens).
> Info: Se o comando `composer create-project` falhar, você pode consultar a
> [seção de Resolução de Problemas na documentação do Composer](https://getcomposer.org/doc/articles/troubleshooting.md)
> para verificar erros comuns. Quando tiver corrigido o erro, você pode continuar a instalação abortada por executar o comando
> `composer update` dentro do diretório `basico`.
> Dica: Se você quiser instalar a última versão de desenvolvimento do Yii, você
> pode usar o seguinte comando, que adiciona uma [opção de estabilidade](https://getcomposer.org/doc/04-schema.md#minimum-stability):
> Tip: Se em disso você quiser instalar a versão em desenvolvimento mais recente do Yii, use o comando a seguir
> que adiciona uma [opção de estabilidade](https://getcomposer.org/doc/04-schema.md#minimum-stability):
Yii utiliza os pacotes [Bower](http://bower.io/) e/ou [NPM](https://www.npmjs.org/) para a instalação das bibliotecas de recursos estáticos (CSS and JavaScript).
Ele usa composer para obter essa bibliotecas, permitindo que versões de pacotes PHP, CSS e Javascrtip possam ser definidas/instaladas ao mesmo tempo.
Isto é possível por usar ou [asset-packagist.org](https://asset-packagist.org) ou [composer asset plugin](https://github.com/francoispluchino/composer-asset-plugin/).
Por favor, consulta a [documentação sobre Assets](structure-assets.md) para mais detalhes.
Você pode querer gerenciar assets através de clientes nativos do Bower ou NPM, pode querer utilizar CDNs ou até evitar completamente a instalação de recursos estáticos.
Para evitar que recursos estáticos sejam instalados via Composer, adicione o seguinte código ao seu `composer.json`:
```json
"replace": {
"bower-asset/jquery": ">=1.11.0",
"bower-asset/inputmask": ">=3.2.0",
"bower-asset/punycode": ">=1.3.0",
"bower-asset/yii2-pjax": ">=2.0.0"
},
```
> Note: caso a instalação de recursos estáticos via Composer seja evitada, caberá a você instalar e resolver conflitos de versão ao instalar recursos estáticos (assets).
> Esteja preparado para possíveis inconsistências entre arquivos de recursos estáticos de diferentes extensões.
Verificando a Instalação <spanid="verifying-installation"></span>
------------------------
Após a instalação, você pode usar o seu navegador para acessar a aplicação do Yii
instalada através da seguinte URL:
Após a instalação ser concluída, você pode tanto configurar seu servidor web (veja na próxima seção) como usar o
[servidor web embutido do PHP](https://secure.php.net/manual/pt_BR/features.commandline.webserver.php) executando o seguinte comando de console no diretório `web`:
```bash
php yii serve
```
http://localhost/basic/web/index.php
> Note: Por padrão o servidor HTTP vai ouvir na porta 8080. Contudo, se essa porta já estiver em uso ou se você pretende servir múltiplas aplicações desta forma, você pode querer especificar qual porta será usada. Para isso,
basta adicionar o argumento `--port`:
```bash
php yii serve --port=8888
```
Essa URL presume que você tenha instalado o Yii em um diretório chamado de `basic`,
diretamente no diretório raiz do servidor Web, e que o servidor Web está rodando
em sua máquina local (`localhost`). Você pode precisar ajustá-la ao seu ambiente
de instalação.
Você pode usar seu navegador para acessar a aplicação instalada por meio da seguinte URL:
```
http://localhost:8080/
```
Você deve ver acima a página de "Congratulations!" em seu navegador. Se não vê-la,
por favor verifique se a sua instalação do PHP satisfaz os requisitos do Yii. Você
pode verificar se os requisitos mínimos são atendidos através de um dos seguintes modos:
* Use um navegador para acessar a URL `http://localhost/basic/requirements.php`
* Execute os seguintes comandos:
Você deverá ver a página de parabenização acima em seu navegador. Se não a vir, por favor, verifique se sua instalação PHP satisfaz os requisitos do Yii. Você pode verificar se os requisitos mínimos são atingidos usando uma das seguintes abordagens:
```
cd basic
* Copiar `/requirements.php` para `/web/requirements.php` e então usar um navegador para acessá-lo por meio da URL `http://localhost/requirements.php`
* Executar os seguintes comandos:
```bash
cd basico
php requirements.php
```
Você deve configurar a sua instalação do PHP de modo que ela atenda aos requisitos
mínimos do Yii. Mais importante ainda, você deve ter o PHP 5.4 ou superior. Você
também deve instalar a [Extensão PDO do PHP](http://www.php.net/manual/en/pdo.installation.php)
e o driver do banco de dados correspondente (tal como `pdo_mysql` para bancos de
dados MySQL), se a sua aplicação precisar de um banco de dados.
Você deve configurar sua instalação PHP de forma a atingir os requisitos mínimos do Yii. A versão mínima do PHP que você deve ter é a 5.4. Mas o ideal seria utilizar a versão mais recente, PHP 7.
Se sua aplicação precisa de um banco de dados, você também deve instalar a [Extensão PDO PHP](http://php.net/manual/pt_BR/pdo.installation.php) e o driver de banco de dados correspondente (tal como `pdo_mysql` para bancos de dados MySQL).
Configurando os Servidores Web <spanid="configuring-web-servers"></span>
Configurando Servidores Web <spanid="configuring-web-servers"></span>
------------------------------
> Informação: Você pode pular essa subseção se só estiver fazendo um test drive do Yii
sem a intenção de publicá-lo em um servidor de produção.
> Info: Você pode pular essa subseção por enquanto se estiver fazendo somente um test drive do Yii sem a intenção de publicá-lo em um servidor de produção.
A aplicação instalada de acordo com as instruções acima deve funcionar imediatamente
A aplicação instalada de acordo com as instruções acima deve funcionar imediatamente
com um [Servidor HTTP Apache](http://httpd.apache.org/) ou um [Servidor HTTP Nginx](http://nginx.org/),
no Windows, Mac OS X ou Linux usando PHP 5.4 ou superior. O Yii 2.0 também é compatível
com o [HHVM](http://hhvm.com/) do Facebook, no entanto, existem alguns casos extremos
que o HHVM se comporta diferente no PHP nativo, então, terá que tomar um cuidado
extra quando usar o HHVM.
com o [HHVM](http://hhvm.com/) do Facebook. No entanto, existem alguns casos extremos em que o HHVM se comporta diferentemente do PHP nativo, então você terá que ter um cuidado extra quando usar o HHVM.
Em um servidor de produção, você pode querer configurar o seu servidor Web de
modo que a aplicação possa ser acessada pela URL `http://www.example.com/index.php`
ao invés de `http://www.example.com/basic/web/index.php`. Tal configuração requer que
você aponte a raiz dos documentos de seu servidor Web para o diretório `basic/web`.
ao invés de `http://www.example.com/basico/web/index.php`. Tal configuração requer que
você aponte a raiz dos documentos de seu servidor Web para o diretório `basico/web`.
Você também pode querer ocultar o `index.php` da URL, conforme descrito na seção
[Roteamento e Criação de URL](runtime-routing.md). Nesta sub-seção, você
[Roteamento e Criação de URL](runtime-routing.md). Nessa sub-seção, você
aprenderá como configurar o seu servidor Apache ou Nginx para atingir estes
objetivos.
> Informação: Definindo `basic/web` como a raiz dos documentos, você também previne os
usuários finais de acessarem o código privado de sua aplicação e os arquivos de
dados sensíveis que estão armazenados em diretórios irmãos de `basic/web`.
> Info: Definindo `basico/web` como a raiz dos documentos, você também evita que
usuários finais acessem o código privado de sua aplicação e os arquivos de
dados sensíveis que estão armazenados em diretórios no mesmo nível de `basico/web`.
Negar o acesso a estes outros diretórios é uma melhoria de segurança.
> Informação: Se a sua aplicação rodará em um ambiente de hospedagem compartilhada
> Info: Se a sua aplicação rodará em um ambiente de hospedagem compartilhada
onde você não tem permissão para alterar a configuração do seu servidor Web,
você ainda pode ajustar a estrutura de sua aplicação para uma melhor segurança.
Por favor consulte a seção [Ambiente de Hospedagem Compartilhada](tutorial-shared-hosting.md)
Por favor, consulte a seção [Ambiente de Hospedagem Compartilhada](tutorial-shared-hosting.md)
para mais detalhes.
### Configuração do Apache Recomendada <spanid="recommended-apache-configuration"></span>
Use a seguinte configuração no arquivo `httpd.conf` do Apache ou em uma
configuração de virtual host. Perceba que você pode deve substituir `path/to/basic/web`
com o caminho real para `basic/web`.
configuração de virtual host. Perceba que você pode deve substituir `caminho/para/basico/web`
com o caminho real para `basico/web`.
```
# Define a raiz dos documentos como sendo "basic/web"
DocumentRoot "path/to/basic/web"
```apache
# Torna "basico/web" a raíz de documentos
DocumentRoot "caminho/para/basico/web"
<Directory"path/to/basic/web">
# Utilize o mod_rewrite para suporte a URL amigável
<Directory"caminho/para/basico/web">
# Usa mod_rewrite para suporte a URLs amigáveis
RewriteEngine on
# Se um diretório ou arquivo existe, usa a requisição diretamente
# Se $showScriptName for "false" no UrlManager, impede o acesso a URLs que tenham o nome do script (index.php)
RewriteRule ^index.php/ - [L,R=404]
# Se um arquivo ou diretório existe, usa a solicitação diretamente
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
# Caso contrário, encaminha a requisição para index.php
# Caso contrário, redireciona para index.php
RewriteRule . index.php
# ...outras configurações...
# ...outras configurações...
</Directory>
```
### Configuração do Nginx Recomendada <spanid="recommended-nginx-configuration"></span>
Você deve ter instalado o PHP como um [FPM SAPI](http://php.net/install.fpm) para
usar o [Nginx](http://wiki.nginx.org/). Use a seguinte configuração do Nginx,
substituindo `path/to/basic/web` com o caminho real para `basic/web` e `mysite.test`
com o nome de host real a servidor.
Para usar o [Nginx](http://wiki.nginx.org/), você deve ter instalado o PHP como um [FPM SAPI](http://php.net/install.fpm). Use a seguinte configuração do Nginx,
substituindo `caminho/para/basico/web` com o caminho real para `basico/web` e `mysite.test` com o nome de host real a servir.
```
```nginx
server {
charset utf-8;
client_max_body_size 128M;
@ -214,32 +254,37 @@ server {
#listen [::]:80 default_server ipv6only=on; ## listen for ipv6
server_name mysite.test;
root /path/to/basic/web;
root /caminho/para/basico/web;
index index.php;
access_log /path/to/basic/log/access.log;
error_log /path/to/basic/log/error.log;
access_log /caminho/para/basico/log/access.log;
error_log /caminho/para/basico/log/error.log;
location / {
# Redireciona tudo que não é um arquivo real para index.php
try_files $uri $uri/ /index.php?$args;
try_files $uri $uri/ /index.php$is_args$args;
}
# descomente para evitar o processamento de chamadas a arquivos estáticos não existentes pelo Yii
# Descomente para evitar processar chamadas feitas pelo Yii a arquivos estáticos não existentes
A curva de aprendizado no Yii não é tão íngreme como em outros frameworks PHP mas, ainda assim, há algumas coisas que você devia aprender antes de começar.
## PHP
Yii é um framework PHP. Portanto, certifique-se de [ler e entender a referência da linguagem](http://php.net/manual/pt_BR/langref.php).
Quando estiver desenvolvendo com Yii, você estará escrevendo código orientado a objetos, então, certifique-se de que está familiarizado tanto com [Classes e Objetos](https://secure.php.net/manual/pt_BR/language.oop5.basic.php) como com [namespaces](https://secure.php.net/manual/pt_BR/language.namespaces.php).
## Programação orientada a objetos
É necessário ter conhecimentos básicos de programação orientada a objetos. Se você não está familizarizado com esse tipo de programação, acesse um dos muitos tutoriais disponíveis, como [este do tuts+](https://code.tutsplus.com/tutorials/object-oriented-php-for-beginners--net-12762).
Note que, quanto mais complicado for seu projeto ou aplicação, mais você precisará de conceitos avançados de POO (Programação Orientada a Objetos) para ser bem sucedido em tratar essa complexidade.
## Linha de comando and composer
Yii usa extensivamente o gerenciador de pacotes mais utilizado do PHP, o [Composer](https://getcomposer.org/), então certifique-se de ler e entender seu [guia](https://getcomposer.org/doc/01-basic-usage.md). Se você não tem familiaridade com a linha de comando é hora de começar a experimentar. Quando tiver aprendido o básico, nunca mais vai querer trabalhar sem ela.
As classes dos controllers devem ser [autoloadable](concept-autoloading.md).
Por esta razão, nos exemplos anteriores, o controller `article` deve ser salvo
As classes dos controllers devem ser [autoloadable](concept-autoloading.md).
Por esta razão, nos exemplos anteriores, o controller `article` deve ser salvo
no arquivo cuja [alias](concept-aliases.md) é `@app/controllers/ArticleController.php`;
enquanto o controller `admin/post-comment` deve ser salvo no `@app/controllers/admin/PostCommentController.php`.
> Informação: No último exemplo `admin/post-comment`, mostra como você pode colocar
um controller em um subdiretório do [[yii\base\Application::controllerNamespace|namespace controller]]. Isto é útil quando você quiser organizar seus controllers em diversas
> Informação: No último exemplo `admin/post-comment`, mostra como você pode colocar
um controller em um subdiretório do [[yii\base\Application::controllerNamespace|namespace controller]]. Isto é útil quando você quiser organizar seus controllers em diversas
categorias e não quiser usar [módulos](structure-modules.md).
Ações standalone são definidas por classes de ações que estendem de [[yii\base\Action]]
ou de uma classe-filha.
ou de uma classe-filha.
Por example, nas versões do Yii, existe a [[yii\web\ViewAction]] e a [[yii\web\ErrorAction]], ambas são ações standalone.
Para usar uma ação standalone, você deve *mapear as ações* sobrescrevendo o método
@ -306,7 +306,7 @@ das ações e os valores correspondentes ao nome da classe da ação ou [configu
podem conter caracteres arbitrários desde que sejam mapeados no método `actions()`.
Para criar uma classe de ação standalone, você deve estender de [[yii\base\Action]] ou de duas classes filhas e implementar um método público chamado `run()`. A regra para o método `run()`
Para criar uma classe de ação standalone, você deve estender de [[yii\base\Action]] ou de duas classes filhas e implementar um método público chamado `run()`. A regra para o método `run()`
é semelhante ao de um método de ação. Por exemplo,
```php
@ -327,23 +327,23 @@ class HelloWorldAction extends Action
### Resultados da Ação <spanid="action-results"></span>
O valor de retorno do método de ação ou do método `run()` de uma ação standalone
O valor de retorno do método de ação ou do método `run()` de uma ação standalone
são importantes. Eles representam o resultado da ação correspondente.
O valor de retorno pode ser um objeto de [resposta](runtime-responses.md) que
O valor de retorno pode ser um objeto de [resposta](runtime-responses.md) que
será enviado como resposta aos usuários finais.
* Para [[yii\web\Application|aplicações Web]], o valor de retorno também poder
ser algum dado arbitrário que será atribuído à propriedade [[yii\web\Response::data]]
ser algum dado arbitrário que será atribuído à propriedade [[yii\web\Response::data]]
e ainda ser convertido em uma string para representar o corpo da resposta.
* Para [[yii\console\Application|aplicações console]], o valor de retorno também
poder ser um inteiro representando o [[yii\console\Response::exitStatus|exit status]]
* Para [[yii\console\Application|aplicações console]], o valor de retorno também
poder ser um inteiro representando o [[yii\console\Response::exitStatus|exit status]]
(status de saída) da execução do comando.
Nos exemplos acima, todos os resultados são strings que serão tratados como o
Nos exemplos acima, todos os resultados são strings que serão tratados como o
corpo das respostas para serem enviados aos usuários finais. No exemplo a seguir,
mostra como uma ação pode redirecionar o navegador do usuário para uma nova URL
retornando um objeto de resposta (o método [[yii\web\Controller::redirect()|redirect()]]
mostra como uma ação pode redirecionar o navegador do usuário para uma nova URL
retornando um objeto de resposta (o método [[yii\web\Controller::redirect()|redirect()]]
retorna um objeto de resposta):
```php
@ -359,9 +359,9 @@ public function actionForward()
Os métodos de ações para as ações inline e os métodos `run()` para as ações
standalone podem receber parâmetros, chamados *parâmetros da ação*.
Seus valores são obtidos a partir das requisições. Para
[[yii\web\Application|aplicações Web]], o valor de cada parâmetro da ação são
obtidos pelo `$_GET` usando o nome do parâmetro como chave; para
Seus valores são obtidos a partir das requisições. Para
[[yii\web\Application|aplicações Web]], o valor de cada parâmetro da ação são
obtidos pelo `$_GET` usando o nome do parâmetro como chave; para
[[yii\console\Application|aplicações console]], eles correspondem aos argumentos
da linha de comando.
@ -387,15 +387,15 @@ A seguir, os parâmetros da ação serão populados em diferentes requisições:
* `http://hostname/index.php?r=post/view&id=123`: o parâmetro `$id` receberá
o valor `'123'`, enquanto o `$version` continuará com o valor nulo porque não
existe o parâmetro `version` na URL.
* `http://hostname/index.php?r=post/view&id=123&version=2`: os parâmetros `$id`
* `http://hostname/index.php?r=post/view&id=123&version=2`: os parâmetros `$id`
e `$version` serão receberão os valores `'123'` e `'2'`, respectivamente.
* `http://hostname/index.php?r=post/view`: uma exceção [[yii\web\BadRequestHttpException]]
* `http://hostname/index.php?r=post/view`: uma exceção [[yii\web\BadRequestHttpException]]
será lançada porque o parâmetro obrigatório `$id` não foi informado na requisição.
* `http://hostname/index.php?r=post/view&id[]=123`: uma exceção [[yii\web\BadRequestHttpException]]
será lançada porque o parâmetro `$id` foi informado com um valor array `['123']`
* `http://hostname/index.php?r=post/view&id[]=123`: uma exceção [[yii\web\BadRequestHttpException]]
será lançada porque o parâmetro `$id` foi informado com um valor array `['123']`
na qual não era esperado.
Se você quiser que um parâmetro da ação aceite valores arrays, deverá declara-lo
Se você quiser que um parâmetro da ação aceite valores arrays, deverá declara-lo
explicitamente com `array`, como mostro a seguir:
```php
@ -405,22 +405,22 @@ public function actionView(array $id, $version = null)
}
```
Agora, se a requisição for `http://hostname/index.php?r=post/view&id[]=123`, o
parâmetro `$id` receberá o valor `['123']`. Se a requisição for
`http://hostname/index.php?r=post/view&id=123`, o parâmetro `$id` ainda receberá
um array como valor pois o valor escalar `'123'` será convertido automaticamente
Agora, se a requisição for `http://hostname/index.php?r=post/view&id[]=123`, o
parâmetro `$id` receberá o valor `['123']`. Se a requisição for
`http://hostname/index.php?r=post/view&id=123`, o parâmetro `$id` ainda receberá
um array como valor pois o valor escalar `'123'` será convertido automaticamente
em um array.
Os exemplo acima mostram, principalmente, como os parâmetros da ação trabalham em
aplicações Web. Para aplicações console, por favor, consulte a seção
aplicações Web. Para aplicações console, por favor, consulte a seção
[Comandos de Console](tutorial-console.md) para mais detalhes.
Sidney Lins
6 years ago
committed by
Alexander Makarov