php the right way gh pages

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

php-the-right-way-gh-pages/.gitattributes
# Auto detect text files and perform LF normalization
* text=auto
# Custom for Visual Studio
*.cs diff=csharp
*.sln merge=union
*.csproj merge=union
*.vbproj merge=union
*.fsproj merge=union
*.dbproj merge=union
# Standard to msysgit
*.doc	 diff=astextplain
*.DOC	 diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF	 diff=astextplain
*.rtf	 diff=astextplain
*.RTF	 diff=astextplain
php-the-right-way-gh-pages/.gitignore
#####################
## Project Specifics
#####################
/_site/
*.DS_Store
/.vagrant
#################
## JetBrains
#################
/.idea
*.iml
#################
## Eclipse
#################
*.pydevproject
.project
.metadata
bin/
tmp/
*.tmp
*.bak
*.swp
*~.nib
local.properties
.classpath
.settings/
.loadpath
# External tool builders
.externalToolBuilders/
# Locally stored "Eclipse launch configurations"
*.launch
# CDT-specific
.cproject
# PDT-specific
.buildpath
#################
## Visual Studio
#################
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.sln.docstates
# Build results
[Dd]ebug/
[Rr]elease/
x64/
build/
[Bb]in/
[Oo]bj/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
*_i.c
*_p.c
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.log
*.scc
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opensdf
*.sdf
*.cachefile
# Visual Studio profiler
*.psess
*.vsp
*.vspx
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
*.ncrunch*
.*crunch*.local.xml
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.Publish.xml
*.pubxml
# NuGet Packages Directory
## TODO: If you have NuGet Package Restore enabled, uncomment the next line
#packages/
# Windows Azure Build Output
csx
*.build.csdef
# Windows Store app package directory
AppPackages/
# Others
sql/
*.Cache
ClientBin/
[Ss]tyle[Cc]op.*
~$*
*~
*.dbmdl
*.[Pp]ublish.xml
*.pfx
*.publishsettings
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file to a newer
# Visual Studio version. Backup files are not needed, because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
App_Data/*.mdf
App_Data/*.ldf
#############
## Windows detritus
#############
# Windows image file caches
Thumbs.db
ehthumbs.db
# Folder config file
Desktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Mac crap
.DS_Store
#############
## Python
#############
*.py[co]
# Packages
*.egg
*.egg-info
dist/
build/
eggs/
parts/
var/
sdist/
develop-eggs/
.installed.cfg
# Installer logs
pip-log.txt
# Unit test / coverage reports
.coverage
.tox
#Translations
*.mo
#Mr Developer
.mr.developer.cfg
php-the-right-way-gh-pages/CNAME
br.phptherightway.com
php-the-right-way-gh-pages/LICENSE
Copyright (c) 2013 Josh Lockhart
http://creativecommons.org/licenses/by-nc-sa/3.0/
php-the-right-way-gh-pages/README.md
# PHP: Do Jeito Certo
## Sobre
Este é o repositório GitHub Pages para o projeto _PHP: Do Jeito Certo_, tradução brasileira do projeto _PHP: The Right Way_.
* Este website é um projeto Jekyll.
* Cada seção e sub-seção são arquivos Markdown em `_posts/`.
* Sub-seções possuem `isChild: true` em seu front matter.
* Navegação e estrutura de páginas são geradas automaticamente.
## Espalhe a palavra!
_PHP: Do Jeito Certo_ possui banners que você pode usar em seu site. Para mostrar seu apoio, deixe que novos desenvolvedores PHP saibam onde encontrar boas informações!
[Banners para divulgação](http://br.phptherightway.com/banners.html)
## Como contribuir
1. Fork e edite
2. Instale opcionalmente [Ruby](https://rvm.io/rvm/install/) com [Jekyll](https://github.com/mojombo/jekyll/) gem para visualizar
3. Envie um pull request para consideração
[Instalar utilizando o Vagrant](vagrant.md)
## Guia de Estilo para o Contribuidor
1. Use a ortografia do Português do Brasil neste repositório.
2. Use quatro (4) espaços para indentar o texto; não use TAB.
3. Limite o texto em 120 caracteres.
4. Os exemplos de código devem seguir a [PSR-1](http://www.php-fig.org/psr/psr-1/) ou superior.
## Onde
<http://br.phptherightway.com>
* [Inglês](http://www.phptherightway.com)
* [Alemão](http://rwetzlmayr.github.io/php-the-right-way)
* [Búlgaro](http://bg.phptherightway.com)
* [Chinês (Simplificado)](http://wulijun.github.com/php-the-right-way)
* [Chinês (Tradicional)](http://laravel-taiwan.github.io/php-the-right-way)
* [Coreano](http://modernpug.github.io/php-the-right-way)
* [Esloveno](http://sl.phptherightway.com)
* [Espanhol](http://phpdevenezuela.github.io/php-the-right-way)
* [Francês](http://eilgin.github.io/php-the-right-way/)
* [Indonésio](http://id.phptherightway.com)
* [Italiano](http://it.phptherightway.com)
* [Japonês](http://ja.phptherightway.com)
* [Persa](http://novid.github.io/php-the-right-way/)
* [Polonês](http://pl.phptherightway.com)
* [Português](http://br.phptherightway.com)
* [Romeno](https://bgui.github.io/php-the-right-way/)
* [Russo](http://getjump.github.io/ru-php-the-right-way)
* [Sérvio](http://smatejic.github.io/php-the-right-way/)
* [Tailandês](https://apzentral.github.io/php-the-right-way/)
* [Turco](http://hkulekci.github.io/php-the-right-way/)
* [Ucraniano](http://iflista.github.com/php-the-right-way)
## Traduções
Se você tem interesse em traduzir _PHP: The Right Way_, faça o fork do repo no GitHub e publique seu fork para sua
própria conta do GitHub. Nós vamos vincular sua tradução a partir do documento principal.
Para evitar fragmentação e confusão para o leitor, por favor escolha uma destas opções:
1. Vincularemos seu fork com a sua GitHub Page `[username].github.com/php-the-right-way`
2. Vincularemos seu fork com a sua GitHub Page com um subdomínio (por exemplo, "br.phptherightway.com")
Se você usa um subdomínio, coloque-o no arquivo `CNAME`, e avíse-nos para configurar o DNS para você. Se não usa um
subdomínio, apague o arquivo `CNAME` senão seu fork não vai fazer o build quando for publicado.
Quando sua tradução estiver pronta, abra uma issue no Isse Tracker para nos avisar.
[Notas de tradução](notas_de_traducao.md)
## Porque?
Têm havido muita discussão ultimamente sobre como a comunidade PHP carece de informação válida e suficiente para programadores novos no PHP. Este repositório busca resolver este problema.
## Quem
Meu nome é [Josh Lockhart](http://twitter.com/codeguy). Sou o autor do [Slim Framework](http://www.slimframework.com/), e trabalho para a [New Media Campaigns](http://www.newmediacampaigns.com/).
## Colaboradores
* [Kris Jordan](http://krisjordan.com/)
* [Phil Sturgeon](http://philsturgeon.co.uk/)
## Licença
[Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-nc-sa/3.0/)
php-the-right-way-gh-pages/Vagrantfile
Vagrant.configure("2") do |config|
 config.vm.box = "precise32"
 config.vm.box_url = "http://files.vagrantup.com/precise32.box"
 config.vm.network :forwarded_port, guest: 4000,
host: 4000
 $script = <<SCRIPT
sudo -i
apt-get update
apt-get -y install ruby1.9.3 nodejs build-essential
gem update --no-rdoc --no-ri --quiet
/opt/vagrant_ruby/bin/gem install jekyll rdiscount --no-ri --no-rdoc
cd /vagrant
jekyll server --detach --port 4000
SCRIPT
 config.vm.provision :shell, :inline => $script
end
php-the-right-way-gh-pages/_config.yml
safe: true
baseurl: /
url: http://localhost:4000
timezone: "America/Sao_Paulo"
highlighter: pygments
markdown: kramdown
permalink: date
php-the-right-way-gh-pages/_includes/welcome.md
# Bem vindo
Existe muita informação obsoleta na Web que desnorteia novos programadores PHP,
espalhando más práticas e códigos inseguros. _PHP: Do Jeito Certo_ é uma referência
rápida e fácil de ler, introduzindo desenvolvedores às melhores práticas, renomados
padrões de código e links para tutoriais competentes pela Web.
É importante entender que _não existe uma maneira canônica de usar PHP_. Este site introduz novos desenvolvedores PHP 
às melhores práticas, opções
disponíveis e boas informações, que por muitas vezes, quando descobertas, já é tarde
demais. Além disso leva o desenvolvedor a ter conceitos maduros sobre coisas que eram
feitas durante anos e nunca foram reconsideradas. Esse site não é para dizer quais
ferramentas você deve utilizar, mas ao invés disso, oferecer sugestões e multiplas
opções, e quando possível explicar as diferenças de acordo com casos de uso.
Este é um documento "vivo", que continuará sendo atualizado com mais informações úteis
e exemplos, assim que eles estiverem disponíveis.
## Traduções
_PHP: Do Jeito Certo_ está (ou em breve estará) sendo traduzido em várias linguagens:
* [Inglês](http://www.phptherightway.com)
* [Búlgaro](http://bg.phptherightway.com/)
* [Chinês (Simplificado)](http://wulijun.github.com/php-the-right-way)
* [Francês](http://eilgin.github.io/php-the-right-way/)
* [Alemão](http://rwetzlmayr.github.io/php-the-right-way/)
* [Língua indonésia](http://id.phptherightway.com/)
* [Italiano](http://it.phptherightway.com/)
* [Japonês](http://ja.phptherightway.com)
* [Coreano](http://wafe.github.io/php-the-right-way/)
* [Polonês](http://pl.phptherightway.com/)
* [Português do Brasil](http://br.phptherightway.com/)
* [Romeno](https://bgui.github.io/php-the-right-way/)
* [Russo](http://getjump.github.io/ru-php-the-right-way)
* [Esloveno](http://sl.phptherightway.com)
* [Espanhol](http://phpdevenezuela.github.io/php-the-right-way/)
* [Tailandês](https://apzentral.github.io/php-the-right-way/)
* [Turco](http://hkulekci.github.io/php-the-right-way/)
* [Ucraniano](http://iflista.github.com/php-the-right-way/)
## Como contribuir
Ajude a tornar este site o melhor recurso para novos programadores PHP! [Contribua no GitHub][1]
## Espalhe a palavra!
_PHP: Do Jeito Certo_ possui banners que você pode usar em seu site. Mostre seu apoio e deixe que novos desenvolvedores 
PHP saibam onde encontrar boas informações!
[Banners para divulgação][2]
[1]: https://github.com/PHPSP/php-the-right-way/tree/gh-pages
[2]: /banners.html
php-the-right-way-gh-pages/_layouts/default.html
 
 Última atualização: {{ site.time | date: "%d/%m/%Y %H:%M:%S"}}
 		Bem vindo
 {% assign lastIsChild = false %}
 {% for post in site.posts reversed %}
 {% if post.isChild and lastIsChild != true %}
{% endif %}
 {% if lastIsChild and post.isChild != true %}{% endif %}
 		{{ post.title }}
 {% assign lastIsChild = post.isChild %}
 {% endfor %}
 
		Créditos
 
 
 
 
 
 
 
 PHP
 Do Jeito Certo.
 
 Tweetar
 
 {{ content }}
 
 Criado e mantido por
 		Josh Lockhart
 Colaboradores do projeto
 		Kris Jordan
		Phil Sturgeon
 Contribuintes
 Carregando…
 Patrocinadores do projeto
 		New Media Campaigns
 
 
PHP: Do Jeito Certo por Josh Lockhart está sob a licença Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Baseado em um trabalho em www.phptherightway.com.
 
 
 
 
 
 
 
php-the-right-way-gh-pages/_layouts/page.html
 
 PHP
 Do Jeito Certo.
 Voltar ao início
 
 
 
 
 
 Você está lendo conteúdo extra sobre…
 {{ content }}
 
 
 
PHP: Do Jeito Certo por Josh Lockhart está sob a licença Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Baseado em um trabalho em www.phptherightway.com.
 
 
 
 
php-the-right-way-gh-pages/_posts/01-01-01-Getting-Started.md
---
title: Começando
anchor: comecando
---
# Começando {#comecando_title}
php-the-right-way-gh-pages/_posts/01-02-01-Use-the-Current-Stable-Version.md
---
title: Use a versão estável atual (5.6)
isChild: true
anchor: use_a_versao_estavel_atual
---
## Use a versão estável atual (5.6) {#use_a_versao_estavel_atual_title}
Se você está começando com o PHP, certifique-se de começar com a versão estável atual do [PHP 5.6][php-release]. O PHP
fez grandes avanços adicionando [novas funcionalidades](#language_highlights) poderosas nos últimos anos. Não deixe que
a pequena diferença entre os números decimais das versões 5.2 a 5.6 o enganem, elas representam _grandes_ melhorias. Se 
você está procurando por uma função ou seu uso, a documentação no [php.net][php-docs] terá a resposta.
[php-release]: http://php.net/downloads
[php-docs]: http://php.net/manual/
php-the-right-way-gh-pages/_posts/01-03-01-Built-in-Web-Server.md
---
title: Servidor web embutido
isChild: true
anchor: servidor_web_embutido
---
## Servidor web embutido {#servidor_web_embutido_title}
Com a versão PHP 5.4+, você pode começar a aprender PHP sem os problemas de instalar e configurar um servidor web. Para 
iniciar o servidor, execute o seguinte comando no seu terminal dentro da raiz de seu projeto:
{% highlight console %}
> php -S localhost:8000
{% endhighlight %}
* [Saiba mais sobre o servidor web embutido, pela linha de comando][cli-server]
[cli-server]: http://php.net/manual/pt_BR/features.commandline.webserver.php
php-the-right-way-gh-pages/_posts/01-04-01-Mac-Setup.md
---
title: Instalação no Mac
isChild: true
anchor: instalacao_no_mac
---
## Instalação no Mac {#instalacao_no_mac_title}
O OS X já vem com o PHP, mas ele é normalmente um pouco atrasado em relação à última versão estável. O Mountain Lion 
vem com a 5.3.10, o Mavericks com a 5.4.17 e o Yosemite com a 5.5.9.
Existem várias maneiras de instalar o PHP no Mac OS X.
[Homebrew](http://brew.sh/) é um poderoso gerenciador de pacotes para OS X, que pode ajudá-lo a instalar o PHP e várias 
extensões facilmente. [Homebrew PHP] é um repositório que contém "fórmulas" relacionadas ao PHP para Homebrew e permite 
a você instalar o PHP.
Neste ponto, você pode instalar o `php53`, `php54`, `php55` ou `php56` usando o comando `brew install` e alternar entre 
elas modificando a variável `PATH`.
### Instalar PHP via phpbrew
[phpbrew] é uma ferramenta para instalar e gerenciar múltiplas versões do PHP. Isto pode ser realmente útil se duas 
diferentes aplicações/projetos requerem diferentes versões do PHP e você não está usando máquinas virtuais.
### Compilar
o código fonte
Outra opção que lhe dá o controle sobre a versão do PHP você instalar, é [compilar o código fonte][mac-compile].
Nesse caso, certifique-se de ter instalado o XCode ou o substituto da Apple ["Command Line Tools for XCode"] que pode 
ser encontrado no _Apple's Mac Developer Center_.
### Instaladores _All-in-One_
As soluções listadas acima lidam apenas com o PHP e não fornecem coisas como Apache, Nginx ou um servidor SQL. As 
soluções _All-in-one_ como [MAMP][mamp-downloads] e [XAMPP][xampp] vão instalar estes outros programas para você e 
amarrá-los todos juntos, mas a facilidade de configuração vem com o contra-ponto da flexibilidade.
[Homebrew]: http://brew.sh/
[Homebrew PHP]: https://github.com/Homebrew/homebrew-php#installation
[mac-compile]: http://php.net/install.macosx.compile
[xcode-gcc-substitution]: https://github.com/kennethreitz/osx-gcc-installer
["Command Line Tools for XCode"]: https://developer.apple.com/downloads
[mamp-downloads]: http://www.mamp.info/en/downloads/
[phpbrew]: https://github.com/phpbrew/phpbrew
[xampp]: http://www.apachefriends.org/en/xampp.html
php-the-right-way-gh-pages/_posts/01-05-01-Windows-Setup.md
---
title: Instalação no Windows
isChild: true
anchor: instalacao_no_windows
---
## Instalação no Windows {#instalacao_no_windows_title}
O PHP está disponível de diversas maneiras no Windows. Você pode [baixar os binários](php-downloads) e até recentemente
você podia usar um instalador '.msi'. O instalador não é mais suportado e parou no PHP 5.3.0.
Para aprender e desenvolver localmente, você pode utilizar o servidor web embutido do PHP 5.4+, de forma que você não
precisa se preocupar em configurá-lo. Se você prefere um "pacote completo" que inclui um servidor web e MySQL, então
ferramentas como o [Web Platform Installer][wpi], o [Zend Server][zs], o [XAMPP][xampp] e o [WAMP][wamp] irão ajudá-lo a 
montar rapidamente um ambiente de desenvolvimento em Windows. Dito isso, estas ferramentas serão um pouco diferentes das 
ferramentas em produção, portanto tenha cuidado quanto às diferenças de ambiente caso esteja trabalhando
em Windows e publicando em Linux. 
Caso você precise rodar seu ambiente de produção em Windows, então o IIS7 vai lhe dar mais estabilidade e melhor
performance. Você pode usar o [phpmanager][phpmanager] (um plugin GUI para o IIS7) para tornar a configuração e o
gerenciamento do PHP mais simples. O IIS7 vem com o FastCGI embutido e pronto para uso, você só precisa configurar o PHP 
como handler. Para suporte e mais recursos, existe uma [área dedicada no iis.net][php-iis] ao PHP.
[php-downloads]: http://windows.php.net
[phpmanager]: http://phpmanager.codeplex.com/
[wpi]: http://www.microsoft.com/web/downloads/platform.aspx
[zs]: http://www.zend.com/en/products/server
[xampp]: http://www.apachefriends.org/en/xampp.html
[wamp]: http://www.wampserver.com/
[php-iis]: http://php.iis.net/
php-the-right-way-gh-pages/_posts/02-01-01-Code-Style-Guide.md
---
title: Guia de estilo de código
anchor: guia_de_estilo_de_codigo
---
# Guia de estilo de código {#guia_de_estilo_de_codigo_title}
A comunidade PHP é grande e diversa, composta por inúmeras bibliotecas, frameworks e componentes. É comum para
desenvolvedores PHP escolher vários destes e combiná-los em um único projeto. É importante que código PHP siga (o mais 
próximo possível) um estilo de código comum para que desenvolvedores PHP possam misturar várias bibliotecas em seus 
projetos.
O [Framework Interop Group][fig] propôs e aprovou uma série de recomendações de estilo, conhecidas como [PSR-0][psr0],
[PSR-1][psr1], [PSR-2][psr2] e [PSR-4][psr4]. Não deixe os nomes estranhos confundí-lo, estas recomendações são 
meramente um conjunto de regras que projetos como Drupal, Zend, Symfony, CakePHP, phpBB, AWS SDK, FuelPHP, Lithium etc. 
estão começando a adotar. Você pode utilizá-las para seus próprios projetos, ou continuar utilizando seu estilo pessoal.
Idealmente você deveria escrever código PHP que adere a um ou mais destes padrões. Pode ser qualquer combinação das
PSR's, ou um dos padrões de código feitos pela PEAR ou Zend. Isso significa que outros desenvolvedores podem facilmente
ler e trabalhar no seu código, e aplicações que implementem os componentes possam ter consistência, mesmo trabalhando
com bastante código de terceiros.
* [Leia sobre a PSR-0][psr0]
* [Leia sobre a PSR-1][psr1]
* [Leia sobre a PSR-2][psr2]
* [Leia sobre a PSR-4][psr4]
* [Leia sobre os Padrões de Código da PEAR][pear-cs]
* [Leia sobre os Padrões de Código da Zend][zend-cs]
* [Leia sobre os Padrões de Código do Symfony][symfony-cs]
Você pode usar o [PHP_CodeSniffer][phpcs] para checar seu código contra qualquer uma dessas recomendações e plugins
para editores de texto como o [Sublime Text 2][st-cs] para fazer a verificação em tempo real.
Você pode corrigir o estilo do código com uma das duas possíveis ferramentas. Uma é a
[PHP Coding Standards Fixer][phpcsfixer] do Fabien Potencier que tem uma base de código muito bem testada. É maior
e mais lenta, mas muito estável e usada por grandes projetos como Magento e Symfony. Outra opção é a [php.tools][phptools],
que se tornou popular pelo plugin [sublime-phpfmt][sublime-phpfmt] do sublime. Apesar de ser mais novo ela tem grandes
melhorias no desempenho fazendo com que a correção do estilo de código em tempo real seja mais fluída.
O Inglês é a linguagem preferida para todos os nomes simbólicos e para a infra-estrutura do código. Comentários devem
ser escritos em qualquer linguagem que possa ser facilmente lida por todos os atuais e futuros desenvolvedores que
possam trabalhar nessa base de código.
[fig]: http://www.php-fig.org/
[psr0]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
[psr1]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md
[psr2]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
[psr4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
[pear-cs]: http://pear.php.net/manual/en/standards.php
[zend-cs]: http://framework.zend.com/wiki/display/ZFDEV2/Coding+Standards
[symfony-cs]: http://symfony.com/doc/current/contributing/code/standards.html
[phpcs]: http://pear.php.net/package/PHP_CodeSniffer/
[st-cs]: https://github.com/benmatselby/sublime-phpcs
[phpcsfixer]: http://cs.sensiolabs.org/
[phptools]: https://github.com/dericofilho/php.tools
[sublime-phpfmt]: https://github.com/dericofilho/sublime-phpfmt
php-the-right-way-gh-pages/_posts/03-01-01-Language-Highlights.md
---
title: Destaques da linguagem
anchor: destaques_da_linguagem
---
# Destaques da linguagem {#destaques_da_linguagem_title}
php-the-right-way-gh-pages/_posts/03-02-01-Programming-Paradigms.md
---
title: Paradigmas de programação
isChild: true
anchor: paradigmas_de_programacao
---
## Paradigmas de programação {#paradigmas_de_programacao_title}
O PHP é uma linguagem dinâmica e flexível, que suporta uma variedade de técnicas de programação. Ele evoluiu
drasticamente com o passar dos anos, notavelmente adicionando um sólido modelo de orientação a objetos no PHP 5.0 
(2004), funções anônimas e namespaces no PHP 5.3 (2009) e traits no PHP 5.4 (2012).
### Programação orientada a objetos {#programacao_orientada_objetos}
O PHP possui um conjunto completo de funcionalidades de programação orientada a objetos, incluindo suporte à classes,
classes abstratas, interfaces, herança, construtores, clonagem, exceções e muito mais.
* [Leia sobre PHP orientado a objetos][oop]
* [Leia sobre Traits][traits]
### Programação funcional {#programacao_funcional}
PHP suporta funções de primeira classe, o que significa que funções podem ser atribuidas a variáveis. Tanto funções
nativas como funções definidas por usuários podem ser referenciadas por uma variável e invocadas dinamicamente. Funções
também pode
ser passadas como argumentos para outras funções (funcionalidade chamada de funções de ordem superior) e
funções podem retornar outras funções.
Recursão, uma funcionalidade que permite que funções realizem chamadas para elas mesmas também é suportada pela
linguagem, mas a maioria dos códigos em PHP tem foco em iteração.
Novas funções anônimas (incluindo suporte para closures) também estão presentes de o PHP 5.3 (2009).
PHP 5.4 inclui a habilidade de vincular closures com o escopo de objetos e também melhorou o suporte para invocaveis
(callables) tanto que elas podem ser usadas indistintamente com funções anónimas na maioria dos casos.
* Continue lendo em [Programação Funcional em PHP]({{ site.baseurl }}pages/Functional-Programming.html)
* [Leia mais sobre Funções Anônimas][anonymous-functions]
* [Leia mais sobre Closures][closure-class]
* [Mais detalhes na RFC sobre Closures][closures-rfc]
* [Leia mais sobre invocáveis (callables)][callables]
* [Leia sobre invocamento dinâmico de funções com `call_user_func_array`][call-user-func-array]
### Meta Programação {#meta_programacao}
PHP suporta várias formas de meta-programação através de mecanismos como a API de reflexão e métodos mágicos. Existem
vários métodos mágicos disponíveis como __get(), __set(), __clone(), __toString(), __invoke(), etc. Isso permite que
desenvolvedores alterem o comportamento das classes. Desenvolvedores Ruby costumam dizer que o PHP carece de
`method_missing`, mas ele está disponível com `__call()` e __callStatic().
* [Leia sobre Métodos Mágicos][magic-methods]
* [Leia sobre Reflexão][reflection]
[namespaces]: http://php.net/language.namespaces
[overloading]: http://php.net/language.oop5.overloading
[oop]: http://php.net/language.oop5
[anonymous-functions]: http://php.net/functions.anonymous
[closure-class]: http://php.net/class.closure
[callables]: http://php.net/language.types.callable
[magic-methods]: http://php.net/language.oop5.magic
[reflection]: http://php.net/intro.reflection
[traits]: http://php.net/language.oop5.traits
[call-user-func-array]: http://php.net/function.call-user-func-array
[closures-rfc]: https://wiki.php.net/rfc/closures
php-the-right-way-gh-pages/_posts/03-03-01-Namespaces.md
---
title: Namespaces
isChild: true
anchor: namespaces
---
## Namespaces {#namespaces_title}
Como mencionado anteriormente, a comunidade PHP tem muitos desenvolvedores criando muito código. Isso significa que o
código de uma biblioteca PHP pode usar o mesmo nome de classe que uma outra biblioteca. Quando ambas bibliotecas são
usadas no mesmo namespace, elas colidem e causam problemas.
Os _Namespaces_ resolvem esse problema. Como descrito no manual de referência do PHP, os namespaces podem ser
comparados com os diretórios dos sistemas operacionais, que fazem _namespace_ dos arquivos; dois arquivos com o mesmo
nome podem coexistir em diretórios separados. Da mesma forma, duas classes PHP com o mesmo nome podem coexistir em
namespaces PHP separados. Simples assim.
É importante que você use namespace no seu código para que ele possa ser usado por outros desenvolvedores sem risco
de colisão com outras bibliotecas.
Um modo recomendado de usar namespaces está descrito na [PSR-0][psr0], que tem como objetivo fornecer uma convenção
padrão para arquivos, classes e namespaces, permitindo código plug-and-play.
Em dezembro de 2013 o PHP-FIG (Framework Interop Group) criou um novo padrão para carregamento automático, a 
[PSR-4][psr4], que provavelmente vai substituir a PSR-0. Atualmente ambos são utilizáveis, pois a PSR-4 requer o PHP 5.3 
e muitos projetos que usam apenas o PHP 5.2 ainda implementam a PSR-0. Se você for usar um padrão de carregamento 
automático para uma nova aplicação ou pacote então é quase certo que você vai querer olhar para a PSR-4.
```
Nota do tradutor
* Aguardando atualização do repositório oficial sobre o uso da PSR-0 que foi 
marcada como descontinuada em 21/10/2014. 
```
* [Leia sobre os Namespaces][namespaces]
* [Leia sobre a PSR-0][psr0]
* [Leia sobre a PSR-4][psr4]
[namespaces]: http://php.net/language.namespaces
[psr0]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
[psr4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
php-the-right-way-gh-pages/_posts/03-04-01-Standard-PHP-Library.md
---
title: Standard PHP Library
isChild: true
anchor: standard_php_library
---
## Standard PHP Library {#standard_php_library_title}
A Standard PHP Library (SPL), ou Biblioteca Padrão do PHP, vem empacotada com o PHP e fornece uma coleção de classes e 
interfaces. Ela é composta principalmente por classes de estruturas de dados normalmente necessárias (pilha, fila, heap 
e outras) e iteradores que podem percorrer por essas estruturas de dados ou por suas próprias classes que implementem as 
interfaces SPL.
* [Leia sobre a SPL][spl]
[spl]: http://php.net/book.spl
php-the-right-way-gh-pages/_posts/03-05-01-Command-Line-Interface.md
---
title: Interface de Linha de Comando
isChild: true
anchor: interface_de_linha_de_comando
---
## Interface de Linha de Comando {#interface_de_linha_de_comando_title}
O PHP foi criado primariamente para escrever aplicações web, mas ele também é útil para criar scripts de linha de
comando (CLI). Programas PHP de linha de comando podem te ajudar a automatizar tarefas comuns como testes, publicação
e administração de aplicações.
Programas PHP CLI são poderosos pois você pode usar o código de sua aplicação diretamente sem precisar criar e
proteger uma GUI (Interface Gráfica do Usuário) web para isso. Apenas tenha a certeza de não colocar seus scripts PHP 
CLI na raiz pública do seu servidor web!
Tente executar o PHP a partir da sua linha de comando:
{% highlight console %}
> php -i
{% endhighlight %}
A opção `-i` irá mostrar a sua configuração do PHP da mesma forma que a função [`phpinfo`][phpinfo].
A opção `-a` fornece um shell interativo, similar ao IRB do ruby e ao shell interativo do python. Também existe um
número de outras [opções de linha comando][cli-options] úteis.
Vamos escrever um programa CLI "Hello, $name" simples. Para testá-lo, crie um arquivo chamado `hello.php`, como
mostrado a seguir.
{% highlight php %}
<?php
if ($argc != 2) {
 echo "Usage: php hello.php [name].\n";
 exit(1);
}
$name = $argv[1];
echo "Hello, $name\n";
{% endhighlight %}
O PHP define duas variáveis especiais baseadas nos argumentos que seu script receber. [`$argc`][argc] é uma variável
integer que contém a *quantidade* de argumentos e [`$argv`][argv] é uma variável array que contém o *valor* de cada
argumento. O primeiro argumento sempre é o nome do arquivo PHP do seu programa, no caso `hello.php`.
A expressão `exit()` é usada com um número diferente de zero para informar ao shell que o comando falhou. Códigos de
saída normalmente usados podem ser encontrados [aqui][exit-codes].
Para executar nosso script acima, a partir da linha de comando:
{% highlight console %}
> php hello.php
Usage: php hello.php [name]
> php hello.php world
Hello, world
{% endhighlight %}
 * [Aprenda sobre como executar o PHP a partir da linha de comando][php-cli]
 * [Aprenda sobre como configurar o Windows para executar o PHP a partir da linha de comando][php-cli-windows]
[phpinfo]: http://php.net/function.phpinfo
[cli-options]: http://php.net/features.commandline.options
[argc]: http://php.net/reserved.variables.argc
[argv]: http://php.net/reserved.variables.argv
[php-cli]: http://php.net/features.commandline
[php-cli-windows]: http://php.net/install.windows.commandline
[exit-codes]: http://gsp.com/cgi-bin/man.cgi?section=3&topic=sysexits
php-the-right-way-gh-pages/_posts/03-06-01-XDebug.md
---
title: XDebug
isChild: true
anchor: xdebug
---
## XDebug {#xdebug_title}
Uma das ferramentas mais úteis no desenvolvimento de software é um depurador apropriado.
Ele permite que você trace a
execução do seu código e monitore os itens na pilha de execução. XDebug, um depurador de PHP, pode ser utilizado por
várias IDEs para prover *breakpoints* e inspecionar a pilha. Ele também lhe permite que ferramentas como PHPUnit e
KCacheGrind realizem análise de cobertura e perfis de código.
Se você perceber que você está travado, disposto a recorrer a *var_dump*/*print_r*, e ainda assim não consegue resolver
o problema - talvez você devesse usar um depurador.
[Instalar o XDebug][xdebug-install] pode ser complicado, mas uma das características mais importantes é a "Depuração
Remota" - se você desenvolve seu código localmente e depois o testa dentro de uma VM (máquina virtual) ou em outro
servidor, a "Depuração Remota" é uma característica que você vai querer manter ativa desde o início.
Tradicionalmente, você modificará o VHost ou o .htaccess do seu Apache para incluir os seguintes valores:
{% highlight ini %}
php_value xdebug.remote_host=192.168.?.?
php_value xdebug.remote_port=9000
{% endhighlight %}
O "remote host" e o "remote port" vão corresponder ao seu computador local e a porta que você configurar para ser
escutada na sua IDE. É apenas uma questão de colocar a sua IDE em modo para "escutar por conexões", e carregar a URL:
 http://your-website.example.com/index.php?XDEBUG_SESSION_START=1
Sua IDE agora irá interceptar o estado atual enquanto seu script é executado, permitindo a você definir *breakpoints*
e inspecionar os valores na memória.
Depuradores gráficos deixam muito fácil o processo de percorrer o código, inspecionar variáveis e avaliar o código em
tempo de execução. Várias IDE's possuem incluso ou suportam um plugin para depurar graficamente com o XDebug. MacGDBp é 
gratuito tem o código fonte aberto uma GUI (Interface Gráfica do Usuário) stand-alone do XDebug para Mac.
 * [Aprenda sobre o XDebug][xdebug-docs]
 * [Aprenda sobre o MacGDBp][macgdbp-install]
[xdebug-docs]: http://xdebug.org/docs/
[xdebug-install]: http://xdebug.org/docs/install
[macgdbp-install]: http://www.bluestatic.org/software/macgdbp/
php-the-right-way-gh-pages/_posts/04-01-01-Dependency-Management.md
---
title: Gerenciamento de Dependência
anchor: gerenciamento_de_dependencia
---
# Gerenciamento de Dependência {#gerenciamento_de_dependencia_title}
Existem toneladas de bibliotecas PHP, frameworks, e componentes para você escolher. Seu projeto provavelmente irá usar 
muitos deles — eles são as dependências do projeto. Até recentemente, o PHP não possuía uma boa forma de gerenciar essas 
dependências de projeto. Mesmo se você as gerenciasse manualmente, ainda assim teria que se preocupar com autoloaders. 
Não mais.
Atualmente existem dois sistemas principais para gerenciamento de pacotes no PHP - o Composer e o PEAR. Qual deles é o 
certo para você? A resposta é: ambos.
 * Use o **Composer** quando estiver gerenciando as dependências de um único projeto.
 * Use o **PEAR** quando gerenciar dependências do PHP para o seu sistema inteiro.
Em geral, os pacotes Composer estarão disponíveis apenas em projetos que você especificar de forma explícita, enquanto
que um pacote PEAR estará disponível para todos os seus projetos PHP. Mesmo que o PEAR pareça ser o método mais fácil à 
primeira vista, existem vantagens em usar uma abordagem projeto-por-projeto para suas dependências.
php-the-right-way-gh-pages/_posts/04-02-01-Composer-and-Packagist.md
---
title: Composer e Packagist
isChild: true
anchor: composer_e_packagist
---
## Composer e Packagist {#composer_e_packagist_title}
O Composer é um gerenciador de dependências **brilhante** para o PHP. Liste as dependências do seu projeto em um
arquivo `composer.json` e, com poucos comandos simples, o Composer irá fazer o download das dependências do seu
projeto automaticamente e configurará o autoloading para você.
Já existem várias bibliotecas PHP que são compatíveis com o Composer, prontas para usar no seu projeto. Esses "pacotes"
estão listados no [Packagist][1], o repositório oficial das bibliotecas PHP compatíveis com o Composer.
### Como Instalar o Composer
Você pode instalar o Composer localmente (no seu diretório de trabalho atual; embora isso não seja o mais recomendado)
ou globalmente (e.g. /usr/local/bin). Vamos assumir que você queira instalar o Composer localmente. A partir do
diretório raiz do seu projeto:
{% highlight console %}
curl -s https://getcomposer.org/installer | php
{% endhighlight %}
Isso irá baixar o `composer.phar` (um arquivo PHP binário). Você pode executá-lo com o `php` para gerenciar as
dependências do seu projeto. <strong>Por favor, Observe:</strong> Se você passar o código baixado diretamente para um
interpretador, por favor leia primeiro o código online para confirmar que ele é seguro.
#### Instalação no Windows
Para usuários Windows a forma mais fácil de obter e executá-lo é usar o instalador [ComposerSetup][6], que realiza uma 
instalação global e configura seu `$PATH` de modo que você possa executar o comando `composer` em qualquer diretório 
pela linha de comando. 
### Como instalar o Composer (manualmente)
Instalar o Composer manualmente é uma técnica avançada; no entanto, existem várias razões pelas quais um
desenvolvedor poderia preferir esse método a usar a rotina de instalação interativa. A instalação interativa verifica
sua instalação do PHP para garantir que:
- uma versão suficiente do PHP esteja sendo usada
- arquivos `.phar` possam ser executados corretamente
- permissões em certos diretórios sejam suficientes
- certas extensões problemáticas não estejam carregadas
- certas configurações no `php.ini` não estejam definidas
Como uma instalação manual não executa nenhuma dessas verificações, você precisa decidir se o custo valerá a pena
para você. Se sim, segue abaixo como obter o Composer manualmente:
{% highlight console %}
curl -s https://getcomposer.org/composer.phar -o $HOME/local/bin/composer
chmod +x $HOME/local/bin/composer
{% endhighlight %}
O caminho `$HOME/local/bin` (ou um diretório de sua escolha) deve estar na sua variável de ambiente `$PATH`. Isso
fará com que o comando `composer` fique disponível.
Quando você vir a documentação dizendo para executar o Composer como `php composer.phar install`, você pode
substituir por isso:
{% highlight console %}
composer install
{% endhighlight %}
Esta seção assumirá que você tem globalmente instalado o composer.
### Como Definir e Instalar Dependências
O Composer mantém o controle de dependências do seu projeto em um arquivo chamado `composer.json`. Você pode
controlá-lo na mão se preferir ou usar o próprio Composer. O comando `composer require` adiciona uma dependência do
projeto e se você não tem um arquivo `composer.json`, ele será criado. Aqui está um exemplo que adiciona
o [Twig][2] como uma dependência do seu projeto.
{% highlight console %}
composer require twig/twig:~1.8
{% endhighlight %}
Outra alternativa é o comando `composer init` que guiará a criação completa do arquivo `composer.json` para
seu projeto. De qualquer maneira, uma vez criado o arquivo `composer.json` você pode chamar o Composer para baixar suas
dependências para o diretório `vendor/`. Isto também se aplica para projetos baixados que fornecem um arquivo
`composer.json`:
{% highlight console %}
composer install
{% endhighlight %}
Em seguida, adicione esta linha ao arquivo PHP principal da sua aplicação; isso dirá ao PHP para usar o autoloader do
Composer para as dependências do seu projeto.
{% highlight php %}
<?php
require 'vendor/autoload.php';
{% endhighlight %}
Agora você pode usar as dependências do seu projeto, e elas serão carregadas automaticamente sob demanda.
### Atualizando suas dependências
O Composer cria um arquivo chamado `composer.lock` que armazena a versão exata de cada pacote baixado quando você
executou `php composer.phar install`. Se você compartilhar
seu projeto com outros desenvolvedores e o arquivo
`composer.lock` é parte da sua distribuição, quando executarem `php composer.phar install` eles receberão as mesmas
versões como você.
Para atualizar suas dependências, execute `php composer.phar update`.
Isso é muito útil quando você define as versões requiridas. Por exemplo, a versão requerida de `~1.8` significa "qualquer
versão mais recente que `1.8.0`, mas menos recente do que `2.0.x-dev`". Você também pode usar o curinga `*` como `1.8.*`.
Agora o comando `php composer.phar update` do Composer atualizará todas as suas dependências para a versão mais recente
que se encaixa às restrições definidas.
### Notificações de Atualização
Para receber notificações sobre novas versões você pode se inscrever no [VersionEye][3], um serviço web que pode
monitorar sua conta GitHub e BitBucket para arquivos `composer.json` e envia emails com as novas versões do pacote.
### Verificando suas dependências para as questões de segurança
O [Security Advisories Checker][4] é um serviço web e uma ferramenta de linha de comando, ambos examinarão seu arquivo
`composer.lock` e dirão se você precisa atualizar alguma das dependências.
* [Aprenda sobre o Composer][5]
[1]: http://packagist.org/
[2]: http://twig.sensiolabs.org
[3]: https://www.versioneye.com/
[4]: https://security.sensiolabs.org/
[5]: http://getcomposer.org/doc/00-intro.md
[6]: https://getcomposer.org/Composer-Setup.exe
php-the-right-way-gh-pages/_posts/04-03-01-PEAR.md
---
title: PEAR
isChild: true
anchor: pear
---
## PEAR {#pear_title}
Outro gerenciador de pacotes veterano e que muitos desenvolvedores PHP gostam é o [PEAR][1]. Ele se comporta da mesma
maneira que o Composer, mas possui diferenças notáveis.
PEAR requer que cada pacote tenha uma estrutura específica, isso significa que o autor do pacote deve prepará-lo para
ser usado com PEAR. Não é possível usar um projeto que não foi preparado para o PEAR.
PEAR instala pacotes de forma global, ou seja, uma vez instalados ficam disponíveis para todos os projetos no servidor.
Isto pode ser bom se muitos projetos dependem dos mesmos pacotes com as mesmas versões, mas isso pode gerar problemas se
houver conflitos de versões entre os projetos.
### Como instalar o PEAR
Você pode instalar o PEAR baixando o instalador phar e executando-o. A documentação do PEAR tem [instruções de
instalação mais detalhadas][2] para todos sistemas operacionais.
Se você usa Linux, pode conferir no gerenciador de pacotes da sua distribuição. Debian e Ubuntu, por exemplo, tem um
pacote `php-pear`.
### Como instalar um pacote
Se o pacote está na [lista de pacotes do PEAR][3], você pode instalá-lo informando seu nome oficial:
{% highlight console %}
pear install foo
{% endhighlight %}
Se o pacote está hospedado em outro canal, você precisa, primeiro, descobrí-lo (`discover`) e especificá-lo
durante a instalação. Veja a [Documentação Usando Canais][4] para mais informações sobre este tópico.
* [Aprenda sobre PEAR][1]
### Manuseio de dependências PEAR com Composer
Se você já está usando [Composer][5] e também gostaria de instalar algum código PEAR, você pode usar o Composer para
manusear suas dependências PEAR. Este exemplo instalará um código a partir do `pear2.php.net`:
{% highlight json %}
{
 "repositories": [
 {
 "type": "pear",
 "url": "http://pear2.php.net"
 }
 ],
 "require": {
 "pear-pear2/PEAR2_Text_Markdown": "*",
 "pear-pear2/PEAR2_HTTP_Request": "*"
 }
}
{% endhighlight %}
A primeira seção `"repositories"` será usada para o Composer saber que deve "inicializar" (ou "descobrir" a terminologia 
PEAR) o repositório pear. Em seguida, na seção `"require"` terá `pear` como prefixo no nome do pacote, como:
> pear-channel/Package
O prefixo "pear" é padrão para evitar qualquer conflito, por exemplo, um canal pear pode ter o mesmo nome de um pacote
no vendor. Então, o nome curto do canal (ou a URL completa) pode ser usada para referenciar o canal em que o pacote se
encontra.
Quando este código for instalado, ficará disponível dentro do seu diretório vendor e disponível automaticamente através
do autoloader do Composer:
> vendor/pear-pear2.php.net/PEAR2_HTTP_Request/pear2/HTTP/Request.php
Para usar este pacote PEAR, basta referenciá-lo assim:
{% highlight php %}
<?php
$request = new pear2\HTTP\Request();
{% endhighlight %}
* [Aprenda mais sobre o uso do PEAR com Composer][6]
[1]: http://pear.php.net/
[2]: http://pear.php.net/manual/en/installation.getting.php
[3]: http://pear.php.net/packages.php
[4]: http://pear.php.net/manual/en/guide.users.commandline.channels.php
[5]: /#composer_and_packagist
[6]: http://getcomposer.org/doc/05-repositories.md#pear
php-the-right-way-gh-pages/_posts/05-01-01-Coding-Practices.md
---
title: Práticas de Codificação
anchor: praticas_de_codificacao
---
# Práticas de Codificação {#praticas_de_codificacao_title}
php-the-right-way-gh-pages/_posts/05-02-01-The-Basics.md
---
title: O Básico
isChild: true
anchor: o_basico
---
## O Básico {#o_basico_title}
PHP é uma grande linguagem que permite a programadores de todos os níveis produzirem código, não apenas rapidamente,
mas eficientemente. Entretando enquanto se avança na linguagem, nós frequentemente esquecemos do básico que tinhamos
aprendido no começo (ou passado o olho) em prol de atalhos e/ou maus hábitos. Para ajudar a combater esse problema
comum, esse seção é focada em lembrar aos programadores das práticas básicas de codificação no PHP.
* Continue lendo [O Básico]({{ site.baseurl }}pages/The-Basics.html)
php-the-right-way-gh-pages/_posts/05-03-01-Date-and-Time.md
---
title: Data e Horário
isChild: true
anchor: data_e_horario
---
## Data e Horário {#data_e_horario_title}
O PHP tem uma classe chamada DateTime para ajudar você com leitura, escrita, comparações e cálculos com datas e
horários. Existem muitas funções no PHP relacionadas a datas e horários além da DateTime, mas ela fornece uma boa
interface orientada a objetos para a maioria dos usos comuns. Ela pode tratar de fusos horários, mas isso vai além
dessa breve introdução.
Para começar a trabalhar com a DateTime, converta uma string bruta de data e hora para um objeto com o método _factory_
`createFromFormat()`, ou use `new DateTime` para obter a data e a hora atual. Use o método `format()` para converter
um objeto DateTime de volta para uma string para saída.
{% highlight php %}
<?php
$raw = '22. 11. 1968';
$start = DateTime::createFromFormat('d. m. Y', $raw);
echo "Start date: " . $start->format('Y-m-d') . "\n";
{% endhighlight %}
Cálculos com a DateTime são possíveis com a classe DateInterval. A DateTime tem métodos como o `add()` e o `sub()` que
recebem um DateInterval como argumento. Não escreva código que espera o mesmo número de segundos para todos os dia,
pois tanto as alterações de horário de verão quanto as de fuso horário irão quebrar essa suposição. Em vez disso use
intervalos de data. Para calcular diferenças entre datas use o método `diff()`. Ele retornará um novo DateInterval,
que é bem fácil de mostrar.
{% highlight php %}
<?php
// cria uma cópia de $start e adiciona um mês e 6 dias
$end = clone $start;
$end->add(new DateInterval('P1M6D'));
$diff = $end->diff($start);
echo "Difference: " . $diff->format('%m month, %d days (total: %a days)') . "\n";
// Diferença: 1 mês, 6 dias (total: 37 dias)
{% endhighlight %}
Com objetos DateTime, você pode usar a comparação padrão:
{% highlight php %}
<?php
if($start < $end) {
 echo "Start is before end!\n";
}
{% endhighlight %}
 
Um último exemplo para demonstrar a classe DatePeriod. Ela é usada para iterar por eventos recorrentes. Ela pode
receber dois objetos DateTime, um início e um fim, e o intervalo para o qual ele retornará todos os eventos 
intermediários.
{% highlight
php %}
<?php
// mostra todas as quintas-feiras entre $start e $end
$periodInterval = DateInterval::createFromDateString('first thursday');
$periodIterator = new DatePeriod($start, $periodInterval, $end, DatePeriod::EXCLUDE_START_DATE);
foreach($periodIterator as $date) {
 //mostra cada data no período
 echo $date->format('Y-m-d') . " ";
}
{% endhighlight %}
* [Leia sobre a classe DateTime][datetime]
* [Leia sobre formatação de datas][dateformat] (opções aceitas para formatos de strings de data)
[datetime]: http://php.net/book.datetime
[dateformat]: http://php.net/function.date
php-the-right-way-gh-pages/_posts/05-04-01-Design-Patterns.md
---
title: Design Patterns
isChild: true
anchor: design_patterns
---
## Design Patterns {#design_patterns_title}
Quando você está construindo sua aplicação web é muito útil utilizar padrões de codificação para formar a estrutura do
seu projeto. Usar "design patterns" (padrões de projeto) é útil pois eles facilitam bastante na hora de gerenciar seu
código e permite que outros desenvolvedores entendam rapidamente como tudo está se encaixando.
Se você utiliza um framework então a maior parte do código de alto nível e a estrutura do projeto serão baseados no 
framework, ou seja, uma grande parte das decisões de padrões de design do código já foram decididas para você. Mas ainda 
cabe a você escolher os melhores padrões a seguir no código na hora de utilizá-los no framework. Se, por outro lado, 
você não estiver utilizando uma framework para construir sua aplicação, então você terá que descobrir os padrões que 
melhor se encaixam para o tipo e tamanho da aplicação que você está construindo.
* Continue lendo em [Design Patterns]({{ site.baseurl }}pages/Design-Patterns.html)
php-the-right-way-gh-pages/_posts/05-05-01-PHP-and-UTF8.md
---
title: Trabalhando com UTF-8
isChild: true
anchor: php_e_utf8
---
## Trabalhando com UTF-8 {#php_e_utf8_title}
_Esta seção foi originalmente escrita por [Alex Cabal](https://alexcabal.com/) como 
[PHP Melhores Práticas](https://phpbestpractices.org/#utf-8) e tem sido usado como base para os nossos próprios conselhos 
sobre UTF-8_.
### Não existe um jeito fácil. Seja cuidadoso, detalhado e consistente.
Atualmente o PHP não possui suporte a Unicode em um nível baixo. Existem maneiras de garantir que strings UTF-8 sejam 
processadas OK, mas não é fácil e isto requer cavar quase todos os níveis da aplicação web desde o HTML passando pelo SQL, até o PHP. 
Vamos abordar para um resumo reve e prático.
### UTF-8 no nível do PHP
As operações básicas com strings, como concatenar duas strings e atribuição de strings a variáveis, não preciso de nada 
especial para o UTF-8. No entanto a maioria das funções de strings, como `strpos()` e `strlen()`, precisam de atenção 
especial. Essas funções têm, frequentemente, uma `mb_*` em contrapartida: por exemplo `mb_strpos()` e `mb_strlen()`. 
Estas funções de string `mb_*` são disponibilizados a você por meio do [Multibyte Extensão String] e são projetadas 
especificamente para operar em strings de caracteres Unicode.
Você deve usar as funções `mb_*` sempre que operar com strings Unicode. Por exemplo, se você usar `substr()` em uma 
string UTF-8, há uma boa chance de que o resultado terá alguns caracteres ilegíveis. A função correta de usar seria a 
contrapartida multibyte, `mb_substr()`.
A parte mais difícil é lembrar de usar as funções `mb_*` em todos os momentos. Se você esquecer mesmo que apenas uma 
vez, sua string Unicode tem uma chance de ser ilegível durante o processamento.
Nem todas as funções de string têm um 'mb_*` contrapartida. Se não houver uma para o que você quer fazer, então você 
pode estar sem sorte.
Você deve usar a função `mb_internal_encoding()` no topo de cada script PHP que você escreve (ou no topo de seu script 
global que seja incluído), e a função `mb_http_output()` logo após ele se seu script está enviando saída para um 
navegador. Definir explicitamente a codificação de suas strings em cada script vai lhe poupar muita dor de cabeça 
futuramente.
Além disso, muitas funções PHP que operam em cadeias de caracteres têm um parâmetro opcional que lhe permite especificar 
o caractere
codificação. Você deve sempre indicar explicitamente UTF-8 quando for dada a opção. Por exemplo, `htmlentities()` tem 
uma
opção para codificação de caracteres, e você deve sempre especificar UTF-8 se lidar com tais cordas. Note-se que a 
partir do PHP 5.4.0, UTF-8 é a codificação padrão para `htmlentities()` e `htmlspecialchars()`.
Finalmente, se você estiver criando um aplicativo distribuído e não tiver certeza de que a extensão `mbstring` será 
ativada, então considere o uso do pacote Composer [patchwork/utf8]. Isto irá usar a `mbstring` se estiver disponível, e 
criar fall back para funções UTF-8 que não estiverem.
[Multibyte Extensão String]: http://php.net/book.mbstring
[patchwork/utf8]: https://packagist.org/packages/patchwork/utf8
### UTF-8 no nível de banco de dados
Se o seu script PHP acessa o MySQL, há uma chance de suas strings serem armazenadas como strings não-UTF-8 no banco de 
dados, mesmo que você siga todas as precauções acima.
Para certificar-se de que suas strings irão do PHP para o MySQL como UTF-8, verifique se o banco de dados e as tabelas 
estão todos setados com o character set e o collation como `utf8mb4` e que você use o character set `utf8mb4` na string 
de conexão PDO. Veja o exemplo de código abaixo. Isto é _criticamente importante_.
Observe que você deve usar o character set `utf8mb4` para ter suporte completo de UTF-8 e não o character set `utf8`! 
Continue lendo para o porquê.
### UTF-8 no nível do navegador
Use a função `mb_http_output()` para garantir que o seu script PHP gere strings UTF-8 para o seu browser.
O navegador então será avisado pela resposta HTTP que esta página deve ser considerada como UTF-8. A abordagem 
histórica para fazer isso foi a inclusão da [tag `` charset](http://htmlpurifier.org/docs/enduser-utf8.html) na 
tag `` da sua página. Esta abordagem é perfeitamente válida, mas definir o charset no cabeçalho `Content-type` é 
realmente [muito mais rápido](https://developers.google.com/speed/docs/best-practices/rendering#SpecifyCharsetEarly).
{% highlight php%}
 PDO::ERRMODE_EXCEPTION,
 PDO::ATTR_PERSISTENT => false
 )
);
// Armazena a nossa string transformada como UTF-8 em nosso banco de dados
// Seu DB e tabelas estão com character set e collation utf8mb4, certo?
$handle = $link->prepare('insert into ElvishSentences (Id, Body) values (?, ?)');
$handle->bindValue(1, 1, PDO::PARAM_INT);
$handle->bindValue(2, $string);
$handle->execute();
// Recuperar a string que armazenamos apenas para provar se foi armazenada corretamente
$handle = $link->prepare('select * from ElvishSentences where Id = ?');
$handle->bindValue(1, 1, PDO::PARAM_INT);
$handle->execute();
// Armazena o resultado em um objeto que vamos saída mais tarde em nossa HTML
$result = $handle->fetchAll(PDO::FETCH_OBJ);
header('Content-Type: text/html; charset=UTF-8');
?>
 Body); // Isto deve emitir corretamente nossa string transformada como UTF-8 para o navegador
 }
 ?>
 
{% endhighlight %}
### Leitura adicional
* [Manual do PHP: Operações Strings](http://php.net/language.operators.string)
* [Manual do PHP: Funções para Strings](http://php.net/ref.strings)
 * [`strpos()`](http://php.net/function.strpos)
 * [`strlen()`](http://php.net/function.strlen)
 * [`substr()`](http://php.net/function.substr)
* [Manual do PHP: Funções multibyte de strings](http://php.net/ref.mbstring)
 * [`mb_strpos()`](http://php.net/function.mb-strpos)
 * [`mb_strlen()`](http://php.net/function.mb-strlen)
 * [`mb_substr()`](http://php.net/function.mb-substr)
 * [`mb_internal_encoding()`](http://php.net/function.mb-internal-encoding)
 * [`mb_http_output()`](http://php.net/function.mb-http-output)
* [`htmlentities()`](http://php.net/function.htmlentities)
 * [`htmlspecialchars()`](http://php.net/function.htmlspecialchars)
* [Dicas PHP e UTF-8](http://blog.loftdigital.com/blog/php-utf-8-cheatsheet)
* [Manuseando UTF-8 com o PHP](http://www.phpwact.org/php/i18n/utf-8)
* [Stack Overflow: Quais os fatores que fazem o PHP incompatível com Unicode?](http://stackoverflow.com/questions/571694/what-factors-make-php-unicode-incompatible)
* [Stack Overflow: Melhores práticas em PHP e MySQL com strings internacionais](http://stackoverflow.com/questions/140728/best-practices-in-php-and-mysql-with-international-strings)
* [Como ter suporte total a Unicode em bases de dados MySQL](http://mathiasbynens.be/notes/mysql-utf8mb4)
* [Trazendo Unicode para o PHP com `Portable UTF-8`](http://www.sitepoint.com/bringing-unicode-to-php-with-portable-utf8/)
php-the-right-way-gh-pages/_posts/06-01-01-Dependency-Injection.md
---
title: Dependency Injection
anchor: dependency_injection
---
# Dependency Injection (Injeção de Dependência) {#dependency_injection_title}
Fonte [Wikipedia](http://en.wikipedia.org/wiki/Dependency_injection):
> Dependency Injection é um Design Pattern que permite retirar as dependências hard-coded e torna possível mudá-las,
> seja em tempo de execução ou em tempo de compilação.
Esta citação torna o conceito muito mais complicado do que realmente é. Dependency Injection fornece um componente com
suas dependências, seja por injeção no construtor, chamada de método ou na definição de propriedades. É simples assim.
php-the-right-way-gh-pages/_posts/06-02-01-Basic-Concept.md
---
title: Conceito Básico
isChild: true
anchor: conceito_basico
---
## Conceito Básico {#conceito_basico_title}
Demostraremos o conceito com um simples exemplo.
Temos uma classe `Database` que requer um adaptador para se comunicar com o banco de dados. Instanciaremos o adaptador
no construtor e assim criamos uma forte de dependência. Isto dificulta os testes e significa que a classe `Database`
está fortemente acoplada ao adaptador.
{% highlight php %}
<?php
namespace Database;
class Database
{
 protected $adapter;
 public function __construct()
 {
 $this->adapter = new MySqlAdapter;
 }
}
class MysqlAdapter {}
{% endhighlight %}
Este código pode ser refatorado para usar a Dependency Injection para desacoplar a dependência.
{% highlight php %}
<?php
namespace Database;
class Database
{
 protected $adapter;
 public function __construct(MySqlAdapter $adapter)
 {
 $this->adapter = $adapter;
 }
}
class MysqlAdapter {}
{% endhighlight %}
Agora, damos a classe `Database` a sua dependência em vez de criar dentro dela. Poderiamos também, criar um método
que aceitaria um argumento da dependência e defini-la dessa forma, ou definir a propriedade `$adapter` como `public`
para defini-la diretamente.
php-the-right-way-gh-pages/_posts/06-03-01-Complex-Problem.md
---
title: Problema Complexo
isChild: true
anchor: problema_complexo
---
## Problema Complexo {#problema_complexo_title}
Se você já leu sobre Inversão de Dependência, então você provavelmente viu os termos *"Inversão de Controle"* ou
*"Princípio da Inversão de Dependência"*.
Estes são os problemas complexos que a Inversão de Dependência resolve.
### Inversão de Controle
Inversão de controle é como se diz, "invertendo o controle" de um sistema para manter os controles organizacionais
totalmente separados dos seus objetos.
Em termos de Dependency Injection, isto significa desacoplar as dependências para controlá-las e instanciá-las em outro 
lugar do sistema.
Por anos, os frameworks PHP usam a Inversão de Controle, no entanto, a questão é: que parte do controle está invertendo, 
e onde? Por exemplo, frameworks MVC, em geral, fornecem um super objeto ou um controlador base que outros controladores 
devem extender para obter acesso as suas dependências. Isto **é** Inversão de Controle, no entanto, em vez de desacoplar 
as dependências, este método simplesmente as mudou.
Dependency Injection permite resolver de forma mais elegante este problema apenas injetando a dependência que precisamos, 
quando precisamos dela, sem a necessidade de quaisquer dependências no código.
### Princípio da Inversão de Dependência
O Princípio da Inversão de Dependência é o "D", no S.O.L.I.D, define o princípio de design da orientação a objeto que 
afirma que *"Dependa de uma Abstração. Não depende de Objetos concretos"*. Simplificando, isto significa que nossas 
dependências devem ser classes de interfaces/contratos ou class abstratas em vez de implementações concretas.
Podemos facilmente refatorar o exemplo abaixo para seguir este princípio.
{% highlight php %}
<?php
namespace Database;
class Database
{
 protected $adapter;
 public function __construct(AdapterInterface $adapter)
 {
 $this->adapter = $adapter;
 }
}
interface AdapterInterface {}
class MysqlAdapter implements AdapterInterface {}
{% endhighlight %}
Existem vários benefícios para a classe `Database`, agora, dependendo de uma interface em vez de um objeto concreto.
Considerando que você trabalha em uma equipe e o adaptador está sendo trabalhado por um colega. No primeiro exemplo,
teriamos que esperar o colega dizer que terminou o adaptador antes que pudéssemos simulá-la(mock) nos testes unitários.
Agora, que a denpendência é uma interface/contrato podemos facilmente simulá-la(mock) sabendo que o colega vai
construir o adaptador com base neste contrato.
Um benefício ainda maior para este método é que nosso código, agora, está mais escalável. Se um ano depois decidir
migrar para um banco de dados diferente, podemos escrever um novo adaptador que implementa a interface original e
injetá-lo, não seria preciso nenhuma refatoração, pois o adaptador segue o contrato definido pela interface.
php-the-right-way-gh-pages/_posts/06-04-01-Containers.md
---
title: Containers
isChild: true
anchor: containers
---
## Containers {#containers_title}
A primeira coisa que você deve entender sobre os Containers da Dependency Injection é que eles não são a mesma coisa
que ela. Um container é um utilitário de conveniência que nos ajuda implementar a Dedepency Injection, no entanto, eles
podem ser, e muitas vezes são, uma implementação anti-pattern, Service Location (Serviço de Localização).
Injetar um container DI como um Localizador de Serviço para suas classes, sem dúvida, cria uma dependência difícil de
substituir no container. Isso também torna seu código menos transparente e, finalmente, mais difícil de testar.
A maioria dos frameworks têm seu próprio Container de Dependency Injection que permite ligar suas dependências em
conjunto, através de configuração.
O que isto significa, na prática, que você pode escrever o código da aplicação tão limpo e desacoplado como do framework
foi construído.
php-the-right-way-gh-pages/_posts/06-05-01-Further-Reading.md
---
title: Leitura Adicional
isChild: true
anchor: leitura_adicional
---
## Leitura Adicional {#leitura_adicional_title}
- [Aprenda sobre Dependency Injection e PHP](http://ralphschindler.com/2011/05/18/learning-about-dependency-injection-and-php)
- [O que é Dependency Injection?](http://fabien.potencier.org/article/11/what-is-dependency-injection)
- [Dependency Injection: uma analogia](http://mwop.net/blog/260-Dependency-Injection-An-analogy.html)
- [Dependency Injection: Huh?](http://net.tutsplus.com/tutorials/php/dependency-injection-huh/)
- [Dependency Injection como uma ferramenta para testes](http://www.happyaccidents.me/dependency-injection-as-a-tool-for-testing/)
php-the-right-way-gh-pages/_posts/07-01-01-Databases.md
---
title: Banco de Dados
anchor: banco_de_dados
---
# Bancos de Dados {#banco_de_dados_title}
Muitas vezes o seu código PHP usará um banco de dados para persistir informações. Você tem algumas
opções para
conectar e interagir com o seu banco de dados. A opção recomendada _até o PHP 5.1.0_ era usar os drivers nativos, como
o [mysqli], o [pgsql], [mssql] etc.
Drivers nativos são excelentes se você estiver usando apenas _um_ banco de dados em sua aplicação, mas se, por exemplo,
você estiver usando o MySQL e um pouco de MSSQL, ou você precisar conectar em um banco de dados Oracle, aí você não
poderá usar os mesmos drivers. Você precisará aprender um API totalmente nova para cada um dos bancos de dados &mdash;
e isso pode ficar chato.
## MySQL Extension
A extensão [mysql] para o PHP não está mais em desenvolvimento ativo e foi [oficialmente descontinuada no PHP 5.5.0]. Isso
significa que ela será removida dentro de alguns lançamentos das próximas versões. Se você estiver usando funções que
inicial com `mysql_*` como a `mysql_connect()` e a `mysql_query()` em suas aplicações você irá se deparar com uma
reescrita em algum momento no futuro, por isso a melhor opção é substituir o uso do mysql pelo mysqli ou pela PDO na sua
aplicação dentro de sua própria agenda de desenvolvimento, assim você não terá que correr lá na frente.
**Se você estiver começando do zero então não utilize de forma nenhuma a
extensão mysql: use a [extensão MySQLi][mysqli], ou use a [PDO].**
* [PHP: Choosing an API for MySQL](http://php.net/mysqlinfo.api.choosing)
* [PDO Tutorial for MySQL Developers](http://wiki.hashphp.org/PDO_Tutorial_for_MySQL_Developers)
## Extensão PDO
A [PDO] é uma biblioteca para abstração de conexões a bancos de dados &mdash; embutida no PHP desde a versão 5.1.0
&mdash; que fornece uma interface comum para conversar com vários bancos de dados diferentes. Por exemplo, você pode
usar basicamente o mesmo código para fazer a interface com o MySQL ou SQLite:
{% highlight php %}
<?php
// PDO + MySQL
$pdo = new PDO('mysql:host=example.com;dbname=database', 'user', 'password');
$statement = $pdo->query("SELECT some\_field FROM some\_table");
$row = $statement->fetch(PDO::FETCH_ASSOC);
echo htmlentities($row['some_field']);
// PDO + SQLite
$pdo = new PDO('sqlite:/path/db/foo.sqlite');
$statement = $pdo->query("SELECT some\_field FROM some\_table");
$row = $statement->fetch(PDO::FETCH_ASSOC);
echo htmlentities($row['some_field']);
{% endhighlight %}
A PDO não irá traduzir
suas consultas SQL ou emular funcionalidades que não existem; ela é feita puramente para conectar múltiplos tipos de
bancos de dados com a mesma API.
Mais importante, a `PDO` permite que você injete de forma segura entradas externas (e.g IDs) em suas consultas SQL
sem se preocupar com ataques de SQL injection.
Isso é possível usando instruções PDO (PDO statements) e parâmetros restritos (bound parameters).
Vamos assumir que um script PHP recebe um ID numérico como parâmetro de uma consulta. Este ID deve ser usado para
buscar um registro de um usuário no banco de dados. Essa é a forma `errada` de fazer isso:
{% highlight php %}
<?php
$pdo = new PDO('sqlite:/path/db/users.db');
$pdo->query("SELECT name FROM users WHERE id = " . $_GET['id']); // <-- NÃO!
{% endhighlight %}
Esse código é péssimo. Você está inserindo um parâmetro bruto na sua consulta SQL. Isso fará você ser hackeado num
piscar de olhos, usando uma prática chamada [SQL Injection](http://wiki.hashphp.org/Validation). Apenas imagine se um
hacker passar como parâmetro um `id` inventivo chamando uma URL como `http://domain.com/?id=1%3BDELETE+FROM+users`. 
Isso irá definir a variável `$_GET['id']` como `id=1;DELETE FROM users`, o que irá excluir todos os seus usuários. Em
vez disso, você deveria higienizar (sanitize) a entrada do ID usando parâmetros restritos da PDO.
{% highlight php %}
<?php
$pdo = new PDO('sqlite:/path/db/users.db');
$stmt = $pdo->prepare('SELECT name FROM users WHERE id = :id');
$stmt->bindParam(':id', $_GET['id'], PDO::PARAM_INT); //<-- Higienizado automaticamente pela PDO
$stmt->execute();
{% endhighlight %}
Esse é o código correto. Ele usa um parâmetro restrito em uma instrução PDO. Assim a entrada externa do ID é escapada
antes de ser introduzida no banco de dados, prevenindo contra potenciais ataques de SQL injection.
* [Leia mais sobre a PDO]
Você também deve estar ciente de que usam recursos do servidor e não é raro ter esses recursos esgotados se essas
conexões não forem implicitamente fechadas, entretanto isso é mais comum em outras linguagens. Com PDO você pode
implicitamente fechar as conexões pela destruição dos objetos garantindo que todas as referências a ele forem excluídas,
ex. atribuindo NULL a elas. Se você não fizer isso explicitamente o PHP irá fechar todas as conexões quando seu script
terminar - a não ser é claro que você esteja usando conexões persistentes.
* [Leia mais sobre conexões PDO]
[Leia mais sobre a PDO]: http://php.net/book.pdo
[Leia mais sobre conexões PDO]: http://php.net/pdo.connections
[oficialmente descontinuada no PHP 5.5.0]: http://php.net/migration55.deprecated
[SQL Injection]: http://wiki.hashphp.org/Validation
[pdo]: http://php.net/pdo
[mysql]: http://php.net/mysql
[mysqli]: http://php.net/mysqli
[pgsql]: http://php.net/pgsql
[mssql]: http://php.net/mssql
php-the-right-way-gh-pages/_posts/07-02-01-Interacting-via-Code.md
---
isChild: true
title: Interagindo com o banco de dados
anchor: interagindo_com_o_banco_de_dados
---
## Interagindo com o banco de dados {#interagindo_com_o_banco_de_dados_title}
Quando os desenvolvedores começam a aprender PHP, muitas vezes acabam misturando a interação com o banco de dados com a 
camada de apresentação, usando código que pode parecer com isso:
{% highlight php %}
<ul>
<?php
foreach ($db->query('SELECT * FROM table') as $row) {
 echo "<li>".$row['field1']." - ".$row['field1']."</li>";
}
?>
</ul>
{% endhighlight %}
Esta é uma má prática por várias razões, principalmente por ser difícil de depurar, testar, ler e ainda pode gerar na 
saída um monte de campos se não houver um limite.
Embora existam muitas outras soluções para fazer isso - dependendo se você preferir a 
[OOP](/#programacao_orientada_objetos) ou [programação funcional](/#programacao_funcional) - deve haver algum elemento 
de separação.
Considere o passo mais básico:
{% highlight php %}
<?php
function getAllFoos($db) {
 return $db->query('SELECT * FROM table');
}
foreach (getAllFoos($db) as $row) {
 echo "<li>".$row['field1']." - ".$row['field1']."</li>"; // BAD!!
}
{% endhighlight %}
Este é um bom começo. Coloque estes dois itens em dois arquivos diferentes e você terá alguma separação limpa.
Crie uma classe para colocar este método e você terá um "Modelo". Criando um arquivo `.php` simples para colocar a 
lógica de apresentação e você terá uma "View", que é quase um [MVC] - uma arquitura OOP comum para a maioria dos 
[frameworks](/#frameworks).
**foo.php**
{% highlight php %}
<?php
$db = new PDO('mysql:host=localhost;dbname=testdb;charset=utf8', 'username', 'password');
// Deixe seu modelo disponível
include 'models/FooModel.php';
// Crie uma instância
$fooList = new FooModel($db);
// Mostre a view
include 'views/foo-list.php';
{% endhighlight %}
**models/FooModel.php**
{% highlight php %}
<?php
class Foo()
{
 protected $db;
 public function __construct(PDO $db)
 {
 $this->db = $db;
 }
 public function getAllFoos() {
 return $this->db->query('SELECT * FROM table');
 }
}
{% endhighlight %}
**views/foo-list.php**
{% highlight php %}
<?php foreach ($fooList as $row): ?>
 <?= $row['field1'] ?> - <?= $row['field1'] ?>
<?php endforeach ?>
{% endhighlight %}
Isto é essenciamente o mesmo que a maioria dos frameworks modernos fazem, todos sejam eles um pouco mais manual. Você 
pode não precisar de tudo a todo momento, mas misturando muita lógica de apresentação e interação com o banco de dados 
pode ser um problema real se você quiser [testes unitários](/#testes_unitarios)
em sua aplicação.
[PHPBridge] tem um grande recurso chamado [Criando uma classe de dados] que aborda um tópico muito similar e é ótimo 
para os desenvolvedores se acostumar ao o conceito de interagir com o banco de dados.
[MVC]: http://code.tutsplus.com/tutorials/mvc-for-noobs--net-10488
[PHPBridge]: http://phpbridge.org/
[Criando uma classe de dados]: http://phpbridge.org/intro-to-php/creating_a_data_class
php-the-right-way-gh-pages/_posts/07-03-01-Abstraction-Layers.md
---
isChild: true
title: Camadas de Abstração
anchor: camadas_de_abstracao_de_banco_de_dados
---
## Camadas de Abstração {#camadas_de_abstracao_de_banco_de_dados_title}
Muitos frameworks fornecem sua própria camada de abstração que pode ou não sobrepor o [PDO][1]. Estes muitas vezes 
simulam características de um sistema de banco de dados que outro banco de dados não possui envolvendo suas consultas 
em métodos PHP, dando-lhe a abstração real do banco de dados em vez de apenas a abstração da conexão como o PDO oferece.
Isto obviamente adiciona um pequeno peso, mas se você estiver construindo uma aplicação portátil que precise trabalhar 
com MySQL, PostgreSQL e SQLite, então este pequeno peso vai valer a pena pela limpeza e menos linhas de código.
Algumas camadas de abstração foram construídas utilizando o padrão de namespaces da [PSR-0][psr0] ou [PSR-4][psr4] para 
que possa ser instalado em qualquer aplicação que você queira.
* [Aura SQL][6]
* [Doctrine2 DBAL][2]
* [Propel][7]
* [ZF2 Db][4]
[1]: http://php.net/book.pdo
[2]: http://www.doctrine-project.org/projects/dbal.html
[4]: http://packages.zendframework.com/docs/latest/manual/en/index.html#zend-db
[6]: https://github.com/auraphp/Aura.Sql
[7]: http://propelorm.org/
[psr0]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
[psr4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
php-the-right-way-gh-pages/_posts/08-01-01-Templating.md
---
title: Templates
anchor: templates
---
# Templates {#templates_title}
Os templates fornecem uma forma conveniente de separar seu controlador e a camada de domínio da sua camada de 
apresentação.
Eles contém geralmente o HTML de sua aplicação, mas também podem ser usados para outros formatos, como o XML.
São muitas vezes referidos como a camada de visão que faz parte do segundo componente do padrão de arquitetura de 
software [modelo-visão-controlador]({{ site.baseurl }}pages/Design-Patterns.html#model-view-controller) (MVC)
php-the-right-way-gh-pages/_posts/08-02-01-Benefits.md
---
isChild: true
title: Benefícios
anchor: templating_benefits
---
## Benefícios {#templating_benefits_title}
O principal benefício de se utilizar templates é a clara separação que eles criam entre a lógica de apresentação e o 
resto da sua aplicação. Templates têm a responsabilidade exclusiva de exibir o conteúdo formatado. Eles não são 
responsáveis por pesquisa de dados, persistência ou outras tarefas mais complexas. Isto leva a código mais limpo, mais 
legível que é especialmente útil em um ambiente de equipe, onde os desenvolvedores trabalham no código do lado do 
servidor (controladores, modelos) e designers trabalham no código do lado do cliente (markup).
Os templates também melhoram a organização do código de apresentação. Os templates são normalmente colocados em uma 
pasta "views", cada um definido dentro de um único arquivo. Essa abordagem incentiva a reutilização de código, onde 
grandes blocos de código são quebrados em pequenos pedaços reutilizáveis, chamados frequentemente de partials. Por 
exemplo, o cabeçalho e o rodapé do site de cada um pode ser definido como templates, que são então incluídos antes e 
depois de cada template de página.
Finalmente, dependendo da biblioteca que você usa, os templates podem oferecer mais segurança ao escapar automaticamente 
o conteúdo gerado pelo usuário. Algumas bibliotecas oferecem até mesmo sand-boxing, onde os criadores de templates só 
têm acesso à white-listed (lista branca) de variáveis e funções.
php-the-right-way-gh-pages/_posts/08-03-01-Plain-PHP-Templates.md
---
isChild: true
title: Templates Simples em PHP
anchor: plain_php_templates
---
## Templates Simples em PHP {#plain_php_templates_title}
Templates Simples em PHP são templates que usam código nativo do PHP. Eles são uma escolha natural já que o PHP é na 
realidade um linguagem de template por si só. Isso significa simplesmente que você pode combinar código PHP dentro de 
outro código, como HTML. Isso é benéfico para os desenvolvedores de PHP pois não há uma nova sintaxe para aprender, 
eles sabem as funções disponíveis e seus editores de código PHP já tem syntax highlighting and auto-completion 
embutidos. Além disso, estes templates tendem a ser muito mais rápido já que não é necessária a fase de compilação.
Cada framework moderno PHP emprega algum tipo de sistema de templates, a maioria usam PHP simples por padrão. Fora dos 
frameworks, bibliotecas como [Plates](http://platesphp.com/) ou [Aura.View](https://github.com/auraphp/Aura.View) 
tornam o trabalho mais fácil, oferecendo funcionalidade modernas ao template, tais como herança, layouts e extensões.
### Exemplo de um template simples em PHP
Utilizando a biblioteca [Plates](http://platesphp.com/).
{% highlight php %}
insert('header', ['title' => 'User Profile']) ?>
User Profile
Hello, escape($name)?>
insert('footer') ?>
{% endhighlight %}
### Exemplo de um template simples em PHP usando herança
Utilizando a biblioteca [Plates](http://platesphp.com/).
{% highlight php %}
 section('content')?>
{% endhighlight %}
{% highlight php %}
layout('template', ['title' => 'User Profile']) ?>
User Profile
Hello, escape($name)?>
{% endhighlight %}
php-the-right-way-gh-pages/_posts/08-04-01-Compiled-Templates.md
---
isChild: true
title: Templates Compilados
anchor: compiled_templates
---
## Templates Compilados {#compiled_templates_title}
Enquanto o PHP evoluiu para uma linguagem orientada a objetos madura, ele 
[não melhorou muito](http://fabien.potencier.org/article/34/templating-engines-in-php) como uma linguagem de templates.
Templates compilados, como [Twig](http://twig.sensiolabs.org/) ou [Smarty](http://www.smarty.net/)*, preenchem este 
vazio oferecendo uma nova sintaxe que foi direcionada especificamente para templating. De escape automático, à herança 
e estruturas de controle simplificadas, templates compilados são projetados para ser mais fácil de escrever, simples de 
ler e mais seguro de usar.
Templates compilados pode ser até compartilhados entre diferentes linguagens, [Mustache](http://mustache.github.io/) 
vem sendo um bom exemplo disso. Uma vez que esses templates devem ser compilados há uma pequena queda de performance, 
no entanto, este é mínimo quando o cache apropriado é usado.
** Enquanto Smarty oferece escape automático, este recurso NÃO está habilitado por padrão.*
### Exemplo simples de um template compilado
Utilizando a biblioteca [Twig](http://twig.sensiolabs.org/).
{% highlight html+jinja %}
{% raw %}
{% include 'header.html' with {'title': 'User Profile'} %}
User Profile
Hello, {{ name }}
{% include 'footer.html' %}
{% endraw %}
{% endhighlight %}
### Exemplo de templates compilados usando herança
Utilizando a biblioteca [Twig](http://twig.sensiolabs.org/).
{% highlight html+jinja %}
{% raw %}
// template.php
 {% block content %}{% endblock %}
{% endraw %}
{% endhighlight %}
{% highlight text %}
{% raw %}
// user_profile.php
{% extends "template.html" %}
{% block title %}User Profile{% endblock %}
{% block content %}
 User Profile
 Hello, {{ name }}
{% endblock %}
{% endraw %}
{% endhighlight %}
php-the-right-way-gh-pages/_posts/08-05-01-Further-Reading.md
---
isChild: true
title: Templates