mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-11-26 20:34:32 +03:00
Merge pull request #396 from abdala/master
[php/pt-br] php translated to pt-br
This commit is contained in:
Nami-Doc
commit
8e51de061b
700
pt-br/php-pt.html.markdown
Normal file
700
pt-br/php-pt.html.markdown
Normal file
@ -0,0 +1,700 @@
|
||||
---
|
||||
language: php
|
||||
contributors:
|
||||
- ["Malcolm Fell", "http://emarref.net/"]
|
||||
- ["Trismegiste", "https://github.com/Trismegiste"]
|
||||
translators:
|
||||
- ["Abdala Cerqueira", "http://abda.la"]
|
||||
- ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
|
||||
lang: pt-br
|
||||
filename: learnphp-pt.php
|
||||
---
|
||||
|
||||
Este documento descreve PHP 5+.
|
||||
|
||||
```php
|
||||
<?php // O código PHP deve estar incluso na tag <?php
|
||||
|
||||
// Se o arquivo PHP só contém código PHP, a melhor prática
|
||||
// é omitir a tag de fechamento PHP.
|
||||
|
||||
// Duas barras iniciam o comentário de uma linha.
|
||||
|
||||
# O hash (aka pound symbol) também inicia, mas // é mais comum
|
||||
|
||||
/*
|
||||
O texto envolto por barra-asterisco e asterisco-barra
|
||||
faz um comentário de múltiplas linhas
|
||||
*/
|
||||
|
||||
// Utilize "echo" ou "print" para imprimir a saída
|
||||
print('Olá '); // Imprime "Olá " sem quebra de linha
|
||||
|
||||
// () são opcionais para print e echo
|
||||
echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
|
||||
// (Todas as declarações devem terminar com um ponto e vírgula)
|
||||
|
||||
// Qualquer coisa fora da tag <?php é impresso automaticamente
|
||||
?>
|
||||
Olá mundo novamente!
|
||||
<?php
|
||||
|
||||
|
||||
/************************************
|
||||
* Tipos e variáveis
|
||||
*/
|
||||
|
||||
// Variáveis começam com o símbolo $.
|
||||
// Um nome de variável válido se inicia com uma letra ou sublinhado,
|
||||
// seguido por qualquer quantidade de letras, números ou sublinhados.
|
||||
|
||||
// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
|
||||
$boolean = true; // ou TRUE ou True
|
||||
$boolean = false; // ou FALSE ou False
|
||||
|
||||
// Inteiros
|
||||
$int1 = 12; // => 12
|
||||
$int2 = -12; // => -12
|
||||
$int3 = 012; // => 10 (um 0 denota um número octal)
|
||||
$int4 = 0x0F; // => 15 (um 0x denota um literal hex)
|
||||
|
||||
// Flutuantes - Floats (aka doubles)
|
||||
$float = 1.234;
|
||||
$float = 1.2e3;
|
||||
$float = 7E-10;
|
||||
|
||||
// Excluir variável
|
||||
unset($int1)
|
||||
|
||||
// Aritmética
|
||||
$soma = 1 + 1; // 2
|
||||
$diferenca = 2 - 1; // 1
|
||||
$produto = 2 * 2; // 4
|
||||
$quociente = 2 / 1; // 2
|
||||
|
||||
// Taquigrafia aritmética
|
||||
$numero = 0;
|
||||
$numero += 1; // Incrementa $number em 1
|
||||
echo $numero++; // Imprime 1 (incrementa após a avaliação)
|
||||
echo ++$numero; // Imprime 3 (incrementa antes da avaliação)
|
||||
$numero /= $float; // Divide e atribui o quociente de $numero
|
||||
|
||||
// Strings podem ser colocadas entre aspas simples
|
||||
$sgl_quotes = '$String'; // => '$String'
|
||||
|
||||
// Evite o uso de aspas duplas, exceto para incorporar outras variáveis
|
||||
$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
|
||||
|
||||
// Os caracteres especiais só são escapados entre aspas duplas
|
||||
$escapado = "Este contém um \t caractere tab.";
|
||||
$naoescapado = 'Este contém somente a barra e o t: \t';
|
||||
|
||||
// Coloque uma variável entre chaves se necessário
|
||||
$dinheiro = "Eu tenho $${numero} no banco.";
|
||||
|
||||
// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
|
||||
$nowdoc = <<<'FIM'
|
||||
múltiplas linhas
|
||||
string
|
||||
FIM;
|
||||
|
||||
// Heredocs farão a análise
|
||||
$heredoc = <<<FIM
|
||||
múltiplas linhas
|
||||
$sgl_quotes
|
||||
FIM;
|
||||
|
||||
// Concatenação de string é feita com .
|
||||
echo 'Esta string ' . 'é concatenada';
|
||||
|
||||
|
||||
/********************************
|
||||
* Constantes
|
||||
*/
|
||||
|
||||
// Uma constante é definida usando define()
|
||||
// e nunca pode ser mudada durante a execução!
|
||||
|
||||
// Um nome de constante válida começa com uma letra ou sublinhado,
|
||||
// seguido por qualquer quantidade de letras, números ou sublinhados.
|
||||
define("FOO", "alguma coisa");
|
||||
|
||||
// Acesso a uma constante é possível usando diretamente o nome escolhido
|
||||
echo 'Isto sairá '.FOO;
|
||||
|
||||
|
||||
/********************************
|
||||
* Arrays
|
||||
*/
|
||||
|
||||
// Todos os arrays em PHP são arrays associativos (hashmaps),
|
||||
|
||||
// Funciona com todas as versões do PHP
|
||||
$associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
|
||||
|
||||
// PHP 5.4 introduziu uma nova sintaxe
|
||||
$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
|
||||
|
||||
echo $associativo['Um']; // imprime 1
|
||||
|
||||
// Uma lista de literais atribui chaves inteiras implicitamente
|
||||
$array = ['Um', 'Dois', 'Tres'];
|
||||
echo $array[0]; // => "Um"
|
||||
|
||||
// Adiciona um elemento no final do array
|
||||
$array[] = 'Quatro';
|
||||
|
||||
// Remove um elemento do array
|
||||
unset($array[3]);
|
||||
|
||||
/********************************
|
||||
* Saída
|
||||
*/
|
||||
|
||||
echo('Olá Mundo!');
|
||||
// Imprime Olá Mundo! para stdout.
|
||||
// Stdout é uma página web se executado em um navegador.
|
||||
|
||||
print('Olá Mundo!'); // O mesmo que o echo
|
||||
|
||||
// echo é atualmente um construtor de linguagem, então você pode
|
||||
// remover os parênteses.
|
||||
echo 'Olá Mundo!';
|
||||
print 'Olá Mundo!'; // O print também é
|
||||
|
||||
$paragrafo = 'parágrafo';
|
||||
|
||||
echo 100; // Imprime valores escalares diretamente
|
||||
echo $paragrafo; // ou variáveis
|
||||
|
||||
// Se a abertura de tags curtas está configurada, ou sua versão do PHP é
|
||||
// 5.4.0 ou maior, você pode usar a sintaxe de echo curto
|
||||
?>
|
||||
<p><?= $paragrafo ?></p>
|
||||
<?php
|
||||
|
||||
$x = 1;
|
||||
$y = 2;
|
||||
$x = $y; // $x agora contém o mesmo valor de $y
|
||||
$z = &$y;
|
||||
// $z agora contém uma referência para $y. Mudando o valor de
|
||||
// $z irá mudar o valor de $y também, e vice-versa.
|
||||
// $x irá permanecer inalterado com o valor original de $y
|
||||
|
||||
echo $x; // => 2
|
||||
echo $z; // => 2
|
||||
$y = 0;
|
||||
echo $x; // => 2
|
||||
echo $z; // => 0
|
||||
|
||||
// Despeja tipos e valores de variável para o stdout
|
||||
var_dump($z); // imprime int(0)
|
||||
|
||||
// Imprime variáveis para stdout em formato legível para humanos
|
||||
print_r($array); // imprime: Array ( [0] => Um [1] => Dois [2] => Tres )
|
||||
|
||||
/********************************
|
||||
* Lógica
|
||||
*/
|
||||
$a = 0;
|
||||
$b = '0';
|
||||
$c = '1';
|
||||
$d = '1';
|
||||
|
||||
// assert lança um aviso se o seu argumento não é verdadeiro
|
||||
|
||||
// Estas comparações serão sempre verdadeiras, mesmo que os tipos
|
||||
// não sejam os mesmos.
|
||||
assert($a == $b); // igualdade
|
||||
assert($c != $a); // desigualdade
|
||||
assert($c <> $a); // alternativa para desigualdade
|
||||
assert($a < $c);
|
||||
assert($c > $b);
|
||||
assert($a <= $b);
|
||||
assert($c >= $d);
|
||||
|
||||
// A seguir, só serão verdadeiras se os valores correspondem e são do mesmo tipo.
|
||||
assert($c === $d);
|
||||
assert($a !== $d);
|
||||
assert(1 == '1');
|
||||
assert(1 !== '1');
|
||||
|
||||
// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
|
||||
|
||||
$inteiro = 1;
|
||||
echo $inteiro + $inteiro; // => 2
|
||||
|
||||
$string = '1';
|
||||
echo $string + $string; // => 2 (strings são coagidas para inteiros)
|
||||
|
||||
$string = 'one';
|
||||
echo $string + $string; // => 0
|
||||
// Imprime 0 porque o operador + não pode fundir a string 'um' para um número
|
||||
|
||||
// Tipo de fundição pode ser utilizado para tratar uma variável
|
||||
// como um outro tipo
|
||||
|
||||
$booleano = (boolean) 1; // => true
|
||||
|
||||
$zero = 0;
|
||||
$booleano = (boolean) $zero; // => false
|
||||
|
||||
// Há também funções dedicadas para fundir a maioria dos tipos
|
||||
$inteiro = 5;
|
||||
$string = strval($inteiro);
|
||||
|
||||
$var = null; // valor Null
|
||||
|
||||
|
||||
/********************************
|
||||
* Estruturas de controle
|
||||
*/
|
||||
|
||||
if (true) {
|
||||
print 'Eu fico impresso';
|
||||
}
|
||||
|
||||
if (false) {
|
||||
print 'Eu não\'t';
|
||||
} else {
|
||||
print 'Eu fico impresso';
|
||||
}
|
||||
|
||||
if (false) {
|
||||
print 'Não fica impresso';
|
||||
} elseif(true) {
|
||||
print 'Fica';
|
||||
}
|
||||
|
||||
// operadores ternários
|
||||
print (false ? 'Não fica impresso' : 'Fica');
|
||||
|
||||
$x = 0;
|
||||
if ($x === '0') {
|
||||
print 'Não imprime';
|
||||
} elseif($x == '1') {
|
||||
print 'Não imprime';
|
||||
} else {
|
||||
print 'Imprime';
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Esta sintaxe alternativa é útil para modelos (templates)
|
||||
?>
|
||||
|
||||
<?php if ($x): ?>
|
||||
Isto é exibido se o teste for verdadeiro.
|
||||
<?php else: ?>
|
||||
Isto é apresentado caso contrário.
|
||||
<?php endif; ?>
|
||||
|
||||
<?php
|
||||
|
||||
// Use switch para salvar alguma lógica.
|
||||
switch ($x) {
|
||||
case '0':
|
||||
print 'Switch faz coerção de tipo';
|
||||
break; // Você deve incluir uma pausa, ou você vai cair
|
||||
// no caso 'dois' e 'tres'
|
||||
case 'dois':
|
||||
case 'tres':
|
||||
// Faz alguma coisa, se a variável é 'dois' ou 'tres'
|
||||
break;
|
||||
default:
|
||||
// Faz algo por padrão
|
||||
}
|
||||
|
||||
// While, do...while e for são repetições provavelmente familiares
|
||||
$i = 0;
|
||||
while ($i < 5) {
|
||||
echo $i++;
|
||||
}; // Imprime "01234"
|
||||
|
||||
echo "\n";
|
||||
|
||||
$i = 0;
|
||||
do {
|
||||
echo $i++;
|
||||
} while ($i < 5); // Imprime "01234"
|
||||
|
||||
echo "\n";
|
||||
|
||||
for ($x = 0; $x < 10; $x++) {
|
||||
echo $x;
|
||||
} // Imprime "0123456789"
|
||||
|
||||
echo "\n";
|
||||
|
||||
$rodas = ['bicicleta' => 2, 'carro' => 4];
|
||||
|
||||
// Repetições foreach podem iterar sobre arrays
|
||||
foreach ($rodas as $contador_rodas) {
|
||||
echo $contador_rodas;
|
||||
} // Imprime "24"
|
||||
|
||||
echo "\n";
|
||||
|
||||
// Você pode iterar sobre as chaves, bem como os valores
|
||||
foreach ($rodas as $veiculo => $contador_rodas) {
|
||||
echo "O $veiculo tem $contador_rodas rodas";
|
||||
}
|
||||
|
||||
echo "\n";
|
||||
|
||||
$i = 0;
|
||||
while ($i < 5) {
|
||||
if ($i === 3) {
|
||||
break; // Sai da repetição
|
||||
}
|
||||
echo $i++;
|
||||
} // Imprime "012"
|
||||
|
||||
for ($i = 0; $i < 5; $i++) {
|
||||
if ($i === 3) {
|
||||
continue; // Ignora esta iteração da repetição
|
||||
}
|
||||
echo $i;
|
||||
} // Imprime "0124"
|
||||
|
||||
|
||||
/********************************
|
||||
* Functions
|
||||
*/
|
||||
|
||||
// Define a função com "function":
|
||||
function minha_funcao () {
|
||||
return 'Olá';
|
||||
}
|
||||
|
||||
echo minha_funcao(); // => "Olá"
|
||||
|
||||
// Um nome de função válido começa com uma letra ou sublinhado,
|
||||
// seguido por qualquer quantidade de letras, números ou sublinhados.
|
||||
|
||||
function adicionar($x, $y = 1) { // $y é opcional e o valor padrão é 1
|
||||
$resultado = $x + $y;
|
||||
return $resultado;
|
||||
}
|
||||
|
||||
echo adicionar(4); // => 5
|
||||
echo adicionar(4, 2); // => 6
|
||||
|
||||
// $resultado não é acessível fora da função
|
||||
// print $resultado; // Dá uma aviso.
|
||||
|
||||
// Desde o PHP 5.3 você pode declarar funções anônimas
|
||||
$inc = function ($x) {
|
||||
return $x + 1;
|
||||
};
|
||||
|
||||
echo $inc(2); // => 3
|
||||
|
||||
function foo ($x, $y, $z) {
|
||||
echo "$x - $y - $z";
|
||||
}
|
||||
|
||||
// Funções podem retornar funções
|
||||
function bar ($x, $y) {
|
||||
// Utilize 'use' para trazer variáveis de fora
|
||||
return function ($z) use ($x, $y) {
|
||||
foo($x, $y, $z);
|
||||
};
|
||||
}
|
||||
|
||||
$bar = bar('A', 'B');
|
||||
$bar('C'); // Imprime "A - B - C"
|
||||
|
||||
// Você pode chamar funções nomeadas usando strings
|
||||
$nome_funcao = 'add';
|
||||
echo $nome_funcao(1, 2); // => 3
|
||||
// Útil para dinamicamente determinar qual função será executada.
|
||||
// Ou utilize call_user_func(callable $callback [, $parameter [, ... ]]);
|
||||
|
||||
/********************************
|
||||
* Includes (Incluir)
|
||||
*/
|
||||
|
||||
<?php
|
||||
// PHP dentro de arquivos incluídos também deve começar com uma tag
|
||||
// de abertura do PHP.
|
||||
|
||||
include 'meu-arquivo.php';
|
||||
// O código meu-arquivo.php já está disponível no escopo atual.
|
||||
// Se o arquivo não pode ser incluído (por exemplo, arquivo não encontrado),
|
||||
//um aviso é emitido.
|
||||
|
||||
include_once 'meu-arquivo.php';
|
||||
// Se o código no meu-arquivo.php foi incluído em outro lugar, ele não vai
|
||||
// ser incluído novamente. Isso evita vários erros de declaração de classe
|
||||
|
||||
require 'meu-arquivo.php';
|
||||
require_once 'meu-arquivo.php';
|
||||
// Faz o mesmo que o include(), exceto que o require() irá causar um erro fatal
|
||||
// se o arquivo não puder ser incluído
|
||||
|
||||
// Conteúdo de meu-include.php:
|
||||
<?php
|
||||
|
||||
return 'Qualquer coisa que você quiser.';
|
||||
// Fim do arquivo
|
||||
|
||||
// Includes e requires também podem retornar um valor.
|
||||
$valor = include 'meu-include.php';
|
||||
|
||||
// Arquivos são incluídos com base no caminho determinado ou,
|
||||
// se este não for passado, com base na diretiva de configuração include_path.
|
||||
// Se o arquivo não é encontrado no include_path, o include vai finalmente
|
||||
// verificar no próprio diretório do script chamado e no diretório
|
||||
// de trabalho atual antes de falhar.
|
||||
/* */
|
||||
|
||||
/********************************
|
||||
* Classes
|
||||
*/
|
||||
|
||||
// As classes são definidas com a palavra-chave class
|
||||
|
||||
class MinhaClasse
|
||||
{
|
||||
const MINHA_CONST = 'valor'; // Uma constante
|
||||
|
||||
static $valorEstatico = 'estatico';
|
||||
|
||||
// Variáveis estáticas e sua visibilidade
|
||||
public static $valorEstaticoPublico = 'estaticoPublico';
|
||||
// Acessível somente dentro da classe
|
||||
private static $valorEstaticoPrivado = 'estaticoPrivado';
|
||||
// Acessível a partir da classe e subclasses
|
||||
protected static $valorEstaticoProtegido = 'estaticoProtegido';
|
||||
|
||||
// Propriedades devem declarar a sua visibilidade
|
||||
public $propriedade = 'publica';
|
||||
public $propInstancia;
|
||||
protected $prot = 'protegida'; // Acessível a partir da classe e subclasses
|
||||
private $priv = 'privada'; // Acessível somente dentro da classe
|
||||
|
||||
// Criar um construtor com o __construct
|
||||
public function __construct($propInstancia) {
|
||||
// Acesse variável de instância utilizando $this
|
||||
$this->propInstancia = $propInstancia;
|
||||
}
|
||||
|
||||
// Métodos são declarados como funções dentro de uma classe
|
||||
public function meuMetodo()
|
||||
{
|
||||
print 'MinhaClasse';
|
||||
}
|
||||
|
||||
//palavra-chave final faz uma função não poder ser sobrescrita
|
||||
final function voceNaoPodeMeSobrescrever()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Declarando propriedades ou métodos de classe como estáticos faz deles
|
||||
* acessíveis sem precisar instanciar a classe. A propriedade declarada
|
||||
* como estática não pode ser acessada com um objeto
|
||||
* instanciado da classe (embora métodos estáticos possam).
|
||||
*/
|
||||
|
||||
public static function meuMetodoEstatico()
|
||||
{
|
||||
print 'Eu sou estatico';
|
||||
}
|
||||
}
|
||||
|
||||
echo MinhaClasse::MINHA_CONST; // Imprime 'valor';
|
||||
echo MinhaClasse::$valorEstatico; // Imprime 'estatico';
|
||||
MinhaClasse::meuMetodoEstatico(); // Imprime 'Eu sou estatico';
|
||||
|
||||
// Instantiate classes using new
|
||||
$minha_classe = new MinhaClasse('Uma propriedade de instância');
|
||||
// Os parênteses são opcionais, se não passar algum argumento.
|
||||
|
||||
// Acesse membros da classe utilizando ->
|
||||
echo $minha_classe->propriedade; // => "publica"
|
||||
echo $minha_classe->instanceProp; // => "Uma propriedade de instância"
|
||||
$minha_classe->meuMetodo(); // => "MinhaClasse"
|
||||
|
||||
|
||||
// Estender classes usando "extends"
|
||||
class MinhaOutraClasse extends MinhaClasse
|
||||
{
|
||||
function imprimePropriedadeProtegida()
|
||||
{
|
||||
echo $this->prot;
|
||||
}
|
||||
|
||||
// Sobrescrever um método
|
||||
function meuMetodo()
|
||||
{
|
||||
parent::meuMetodo();
|
||||
print ' > MinhaOutraClasse';
|
||||
}
|
||||
}
|
||||
|
||||
$minha_outra_classe = new MinhaOutraClasse('Propriedade de instância');
|
||||
$minha_outra_classe->imprimePropriedadeProtegida(); // => Prints "protegida"
|
||||
$minha_outra_classe->myMethod(); // Prints "MinhaClasse > MinhaOutraClasse"
|
||||
|
||||
final class VoceNaoPodeMeEstender
|
||||
{
|
||||
}
|
||||
|
||||
// Você pode usar "métodos mágicos" para criar getters e setters
|
||||
class MinhaClasseMapa
|
||||
{
|
||||
private $propriedade;
|
||||
|
||||
public function __get($chave)
|
||||
{
|
||||
return $this->$chave;
|
||||
}
|
||||
|
||||
public function __set($chave, $valor)
|
||||
{
|
||||
$this->$chave = $valor;
|
||||
}
|
||||
}
|
||||
|
||||
$x = new MinhaClasseMapa();
|
||||
echo $x->propriedade; // Irá usar o método __get()
|
||||
$x->propriedade = 'Algo'; // Irá usar o método __set()
|
||||
|
||||
// Classes podem ser abstratas (usando a palavra-chave abstract) ou
|
||||
// implementar interfaces (usando a palavra-chave implements).
|
||||
// Uma interface é declarada com a palavra-chave interface.
|
||||
|
||||
interface InterfaceUm
|
||||
{
|
||||
public function fazAlgo();
|
||||
}
|
||||
|
||||
interface InterfaceDois
|
||||
{
|
||||
public function fazOutraCoisa();
|
||||
}
|
||||
|
||||
// interfaces podem ser estendidas
|
||||
interface InterfaceTres extends InterfaceDois
|
||||
{
|
||||
public function fazOutroContrato();
|
||||
}
|
||||
|
||||
abstract class MinhaClasseAbstrata implements InterfaceUm
|
||||
{
|
||||
public $x = 'fazAlgo';
|
||||
}
|
||||
|
||||
class MinhaClasseConcreta extends MinhaClasseAbstrata implements InterfaceDois
|
||||
{
|
||||
public function fazAlgo()
|
||||
{
|
||||
echo $x;
|
||||
}
|
||||
|
||||
public function fazOutraCoisa()
|
||||
{
|
||||
echo 'fazOutraCoisa';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Classes podem implementar mais de uma interface
|
||||
class UmaOutraClasse implements InterfaceUm, InterfaceDois
|
||||
{
|
||||
public function fazAlgo()
|
||||
{
|
||||
echo 'fazAlgo';
|
||||
}
|
||||
|
||||
public function fazOutraCoisa()
|
||||
{
|
||||
echo 'fazOutraCoisa';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/********************************
|
||||
* Traits (Traços)
|
||||
*/
|
||||
|
||||
// Traits estão disponíveis a partir de PHP 5.4.0 e
|
||||
// são declarados usando "trait"
|
||||
|
||||
trait MeuTraco
|
||||
{
|
||||
public function meuMetodoDeTraco()
|
||||
{
|
||||
print 'Eu tenho MeuTraco';
|
||||
}
|
||||
}
|
||||
|
||||
class MinhaClasseTracada
|
||||
{
|
||||
use MeuTraco;
|
||||
}
|
||||
|
||||
$cls = new MinhaClasseTracada();
|
||||
$cls->meuMetodoDeTraco(); // Imprime "Eu tenho MeuTraco"
|
||||
|
||||
|
||||
/********************************
|
||||
* Namespaces (Espaço nominal)
|
||||
*/
|
||||
|
||||
// Esta seção é separada porque a declaração de espaços nominais
|
||||
// deve ser a primeira instrução em um arquivo. Vamos fingir, aqui não é o caso
|
||||
|
||||
<?php
|
||||
|
||||
// Por padrão, as classes existem no espaço nominal global e podem
|
||||
// ser explicitamente chamadas com uma barra invertida.
|
||||
|
||||
$cls = new \MinhaClasse();
|
||||
|
||||
|
||||
|
||||
// Definir o espaço nominal para o arquivo
|
||||
namespace Meu\Espaconominal;
|
||||
|
||||
class MinhaClasse
|
||||
{
|
||||
}
|
||||
|
||||
// (de outro arquivo)
|
||||
$cls = new Meu\Espaconominal\MinhaClasse;
|
||||
|
||||
//Ou de dentro de outro espaço nominal.
|
||||
namespace Meu\Outro\Espaconominal;
|
||||
|
||||
use My\Espaconominal\MinhaClasse;
|
||||
|
||||
$cls = new MinhaClasse();
|
||||
|
||||
//Ou você pode usar como apelido de espaço nominal;
|
||||
|
||||
namespace Meu\Outro\Espaconominal;
|
||||
|
||||
use Meu\Espaconominal as OutroEspaconominal;
|
||||
|
||||
$cls = new OutroEspaconominal\MinhaClasse();
|
||||
|
||||
*/
|
||||
|
||||
```
|
||||
|
||||
## Mais informações
|
||||
|
||||
Visite a [documentação oficial do PHP](http://www.php.net/manual/)
|
||||
para referência e participação da comunidade.
|
||||
|
||||
Se você estiver interessado em melhores práticas atualizadas, visite
|
||||
[PHP The Right Way](http://www.phptherightway.com/).
|
||||
|
||||
Se você está vindo de uma linguagem com bom gerenciamento de pacotes, confira
|
||||
[Composer](http://getcomposer.org/).
|
||||
|
||||
Para os padrões comuns, visite o Grupo de Interoperabilidade de Framework PHP
|
||||
[PSR standards](https://github.com/php-fig/fig-standards).
|
||||
Loading…
Reference in New Issue
Block a user