Sintaxe e semântica do PHP - PHP syntax and semantics
A sintaxe e a semântica do PHP são o formato ( sintaxe ) e os significados relacionados ( semântica ) do texto e dos símbolos na linguagem de programação PHP . Eles formam um conjunto de regras que definem como um programa PHP pode ser escrito e interpretado.
Visão geral
Historicamente, o desenvolvimento do PHP tem sido um tanto aleatório. Para combater isso, o PHP Framework Interop Group (FIG) criou os documentos PHP Standards Recommendation (PSR) que ajudaram a trazer mais padronização para a linguagem desde 2009. Os padrões de codificação modernos estão contidos no PSR-1 (Basic Coding Standard) e PSR-2 (Guia de estilo de codificação).
Palavras-chave
Algumas palavras-chave representam coisas que parecem funções, outras parecem constantes, mas na verdade são construções de linguagem. É proibido usar quaisquer palavras-chave como constantes, nomes de classes, funções ou métodos. É permitido usá-los como nomes de variáveis, mas pode ser confuso.
__halt_compiler()
abstract
and
array()
as
break
-
callable
(a partir do PHP 5.4) case
catch
class
clone
const
continue
declare
default
die()
do
echo
else
elseif
empty()
enddeclare
endfor
endforeach
endif
endswitch
endwhile
eval()
exit()
extends
final
-
finally
(a partir do PHP 5.5) -
fn
(a partir do PHP 7.4) for
foreach
function
global
-
goto
(a partir do PHP 5.3) if
implements
include
include_once
instanceof
-
insteadof
(a partir do PHP 5.4) interface
isset()
list()
-
match
(a partir do PHP 8.0) -
namespace
(a partir do PHP 5.3) new
or
print
private
protected
public
require
require_once
return
static
switch
throw
-
trait
(a partir do PHP 5.4) try
unset()
use
var
while
xor
-
yield
(a partir do PHP 5.5) -
yield from
(a partir do PHP 7.0)
Construções básicas de linguagem
O PHP geralmente segue a sintaxe C , com exceções e aprimoramentos para seu uso principal no desenvolvimento web , que faz uso intenso da manipulação de strings . Variáveis PHP devem ser prefixadas por " $
". Isso permite que o PHP execute a interpolação de strings em strings entre aspas duplas , onde a barra invertida é suportada como um caractere de escape . Nenhum escape ou interpolação é feito em strings delimitadas por aspas simples . PHP também suporta uma função sprintf semelhante a C. O código pode ser modularizado em funções definidas com palavras-chave function
. O PHP suporta um estilo de codificação opcional orientado a objetos , com classes denotadas pela class
palavra - chave. As funções definidas dentro das classes às vezes são chamadas de métodos . Estruturas de controlo incluem: if
, while
, do/while
, for
, foreach
, e switch
. As instruções são encerradas por ponto-e-vírgula, não finais de linha.
Delimitadores
O processador PHP apenas analisa o código dentro de seus delimitadores . Qualquer coisa fora de seus delimitadores é enviada diretamente para a saída e não é analisada pelo PHP. Os únicos delimitadores de abertura / fechamento permitidos pelo PSR-1 são " <?php
" e " " ou e .
?>
<?=
?>
O objetivo das tags de delimitação é separar o código PHP dos dados não PHP (principalmente HTML). Embora raro na prática, o PHP irá executar código embutido em qualquer arquivo passado para seu interpretador, incluindo arquivos binários como arquivos PDF ou JPEG, ou em arquivos de log do servidor. Tudo fora dos delimitadores é ignorado pelo analisador PHP e é passado como saída.
Esses delimitadores recomendados criam documentos XHTML e outros XML formados corretamente . Isso pode ser útil se os documentos de código-fonte precisarem ser processados de outras maneiras durante a vida do software.
Se a validação XML adequada não for um problema e um arquivo contiver apenas código PHP, é preferível omitir a ?>
tag de fechamento ( ) do PHP no final do arquivo.
Tags não recomendadas
Outros delimitadores podem ser usados em alguns servidores, embora a maioria não seja mais compatível. Exemplos são:
- "
<script language="php">
" e "</script>
" (removido no PHP7) - Tags de abertura curta (
<?
) (configuradas com ashort_open_tag
configuração ini)- Uma forma especial da
<?
tag é<?=
, que ecoa automaticamente a próxima instrução. Antes do PHP 5.4.0, isso também era controladoshort_open_tag
, mas está sempre disponível em versões posteriores.
- Uma forma especial da
-
Tags de estilo ASP (
<%
ou<%=
) (removidas no PHP7)
Variáveis e comentários
As variáveis são prefixadas com um símbolo de dólar e um tipo não precisa ser especificado com antecedência. Ao contrário dos nomes de funções e classes, os nomes de variáveis diferenciam maiúsculas de minúsculas. As strings entre aspas duplas ( ""
) e heredoc permitem incorporar o valor de uma variável na string. Como em C, as variáveis podem ser convertidas em um tipo específico prefixando o tipo entre parênteses. O PHP trata as novas linhas como espaços em branco , na forma de uma linguagem de forma livre . O operador de concatenação é .
(ponto). Os elementos da matriz são acessados e definidos com colchetes em ambas as matrizes associativas e indexadas. Os colchetes podem ser usados para acessar os elementos da matriz, mas não para atribuir.
O PHP tem três tipos de sintaxe de comentário : /* */
que serve como bloco de comentários e //
também #
que é usada para comentários embutidos. Muitos exemplos usam a função de impressão em vez da função de eco . Ambas as funções são quase idênticas; a principal diferença é que print é mais lento do que echo porque o primeiro retornará um status indicando se foi bem-sucedido ou não, além do texto para a saída, enquanto o último não retorna um status e retorna apenas o texto para a saída.
Programa mais simples
O exemplo de código usual " Hello World " para PHP é:
<?php
echo "Hello World!\n";
?>
O exemplo acima produz o seguinte:
Hello World!
Em vez de usar <?php
e a echo
instrução, um "atalho" opcional é o uso de em vez de que ecoa dados implicitamente. Por exemplo:
<?=
<?php
<!DOCTYPE html>
<html>
<head>
<title>PHP "Hello, World!" program</title>
</head>
<body>
<p><?="Hello World!"?></p>
</body>
</html>
O exemplo acima também ilustra que o texto não contido nas tags PHP será gerado diretamente.
Operadores
PHP suporta: operadores aritméticos , operadores de atribuição , operadores bit a bit , operadores de comparação , operadores de controle de erro, operadores de execução, operadores de incremento / decremento , operadores lógicos , operadores de string , operadores de array, operadores de atribuição condicional .
Estruturas de controle
Declarações condicionais
Se ... mais
A sintaxe de uma instrução PHP if ... else é a seguinte:
if (condition) {
// statements;
} elseif (condition2) {
// statements;
} else {
// statements;
}
Para declarações únicas, os colchetes podem ser omitidos e, se opcionalmente, condensados em uma única linha:
if (condition) dosomething();
elseif (condition2) dosomethingelse();
else doyetathirdthing();
Operadores ternários
$abs = $value >= 0 ? $value : -$value;
/* Equivalent to */
if ($value >= 0) {
$abs = $value;
} else {
$abs = -$value;
}
Operador de elvis
Já que o PHP 5.3 suporta o operador Elvis ( ?:
), no qual é possível omitir a parte intermediária do operador ternário.
$c = $a ?: $b;
/* Equivalent to */
$c = $a ? $a : $b;
Operador de coalescência nula
Desde a versão 7.0, o PHP também suporta o operador Null coalescing ( ??
).
$a = $b ?? $c;
/* Equivalent to */
$a = isset($b) ? $b : $c;
Desde a versão 7.4, o PHP também suporta o operador Null coalescing com a ??=
sintaxe.
$a ??= $b;
/* Equivalent to */
$a = $a ?? $b;
Desde a versão 8.0, o PHP também suporta o operador de navegação segura ( ?->
).
$variable = $object?->method();
/* Equivalent to */
$variable = $object !== null ? $object->method() : null;
Interruptor
Um exemplo da sintaxe de uma instrução switch PHP é o seguinte:
switch (expr) {
case 0:
// statements;
break;
case 1:
// statements;
break;
case 2:
// statements;
break;
default:
// statements;
}
Observe que, ao contrário de C , os valores na instrução case podem ser de qualquer tipo, não apenas inteiros.
Partida
PHP 8 apresenta a match
expressão. A expressão de correspondência é conceitualmente semelhante a uma switch
instrução e é mais compacta para alguns casos de uso.
echo match (1) {
0 => 'Foo',
1 => 'Bar',
2 => 'Baz',
};
//> Bar
rotações
For loop
A sintaxe PHP de um loop for é a seguinte:
for (initialization; condition; afterthought) {
// statements;
}
Loop while
A sintaxe para um loop while de PHP é a seguinte:
while (condition) {
// statements;
}
Faça while loop
A sintaxe para um loop do while do PHP é a seguinte:
do {
// statements;
} while (condition);
Para cada loop
A sintaxe de um PHP para cada loop é a seguinte:
foreach ($set as $value) {
// statements;
}
Sintaxe alternativa para estruturas de controle
O PHP oferece uma sintaxe alternativa usando dois pontos ao invés da sintaxe padrão de chaves (de " {...}
"). Esta sintaxe afeta os seguintes estruturas de controle: if
, while
, for
, foreach
, e switch
. A sintaxe varia apenas ligeiramente da sintaxe das chaves. Em cada caso, o sinal de abertura ( {
) é substituído com dois pontos ( :
) e o próximo cinta é substituído por endif;
, endwhile;
, endfor;
, endforeach;
, ou endswitch;
, respectivamente. A mistura de estilos de sintaxe no mesmo bloco de controle não é suportada. Um exemplo de sintaxe para uma instrução if
/ elseif
é o seguinte:
if (condition):
// code here
elseif (condition):
// code here
else:
// code here
endif;
Esse estilo às vezes é chamado de sintaxe de modelo, pois geralmente é mais fácil de ler ao combinar PHP e HTML ou JavaScript para saída condicional:
<html>
<?php if ($day == 'Thursday'): ?>
<div>Tomorrow is Friday!</div>
<?php elseif ($day == 'Friday'): ?>
<div>TGIF</div>
<?php else: ?>
<div>ugh</div>
<?php endif; ?>
</html>
Manipulação de exceção
O método de tratamento de exceções de tempo de execução em PHP é herdado de C ++.
function inv($x)
{
if ($x == 0) {
throw new Exception('Division by zero');
}
return 1 / $x;
}
try {
echo inv(2); // prints 0.5
echo inv(0); // throw an exception
echo inv(5); // will not run
} catch (Exception $e) {
echo $e->getMessage(); // prints Division by zero
}
// Continue execution
echo "Hello"; // prints Hello
Tipos de dados
Tipos escalares
PHP suporta quatro tipos escalares: bool
, int
, float
, string
.
boleano
PHP tem um tipo booleano nativo , denominado " bool
", semelhante aos tipos booleanos nativos em Java e C ++ . Usando as regras de conversão de tipo booleano, valores diferentes de zero são interpretados como true
e zero como false
, como em Perl . Ambas as constantes true
e false
não diferenciam maiúsculas de minúsculas.
Inteiro
PHP armazena números inteiros em um intervalo dependente da plataforma. Esse intervalo é normalmente o de inteiros assinados de 32 ou 64 bits. Variáveis inteiras podem ser atribuídas usando notações decimais (positiva e negativa), octal e hexadecimal .
$a = 1234; // decimal number
$b = 0321; // octal number (equivalent to 209 decimal)
$c = 0x1B; // hexadecimal number (equivalent to 27 decimal)
$d = 0b11; // binary number (equivalent to 3 decimal)
$e = 1_234_567; // decimal number (as of PHP 7.4.0)
Flutuador
Os números reais também são armazenados em uma faixa específica da plataforma. Eles podem ser especificados usando notação de ponto flutuante ou duas formas de notação científica .
$a = 1.234;
$b = 1.2e3; // 1200
$c = 7E-5; // 0.00007
$d = 1_234.567; // as of PHP 7.4.0
Fragmento
Suporta PHP strings
, que pode ser usado com aspas simples, aspas duplas, nowdoc ou sintaxe heredoc .
Strings entre aspas duplas suportam interpolação de variável:
$age = '23';
echo "John is $age years old"; // John is 23 years old
Sintaxe de colchetes:
$f = "sqrt";
$x = 25;
echo "a$xc\n"; // Warning: Undefined variable $xc
echo "a{$x}c\n"; // prints a25c
echo "a${x}c\n"; // also prints a25c
echo "$f($x) is {$f($x)}\n"; // prints sqrt(25) is 5
Tipos especiais
PHP suporta dois tipos especiais: null
, resource
. O null
tipo de dados representa uma variável sem valor. O único valor no null
tipo de dados é NULL . A constante NULL não faz distinção entre maiúsculas e minúsculas. Variáveis do resource
tipo " " representam referências a recursos de fontes externas. Normalmente, eles são criados por funções de uma extensão específica e só podem ser processados por funções da mesma extensão. Os exemplos incluem recursos de arquivo, imagem e banco de dados.
Tipos compostos
PHP suporta quatro tipos de compostos: array
, object
, callable
, iterable
.
Variedade
Os arrays podem conter elementos mistos de qualquer tipo, incluindo recursos, objetos. Matrizes multidimensionais são criadas atribuindo matrizes como elementos de matriz. PHP não possui um tipo de array verdadeiro. Os arrays PHP são nativamente esparsos e associativos . Arrays indexados são simplesmente hashes usando inteiros como chaves.
Matriz indexada:
$season = ["Autumn", "Winter", "Spring", "Summer"];
echo $season[2]; // Spring
Matriz associativa:
$salary = ["Alex" => 34000, "Bill" => 43000, "Jim" => 28000];
echo $salary["Bill"]; // 43000
Matriz multidimensional:
$mark = [
"Alex" => [
"biology" => 73,
"history" => 85
],
"Jim" => [
"biology" => 86,
"history" => 92
]
];
echo $mark["Jim"]["history"]; // 92
Objeto
O object
tipo de dados é uma combinação de variáveis, funções e estruturas de dados no paradigma de programação orientada a objetos .
class Person
{
//...
}
$person = new Person();
Callable
Desde a versão 5.3 o PHP tem funções de primeira classe que podem ser usadas, por exemplo, como um argumento para outra função.
function runner(callable $function, mixed ...$args)
{
return $function(...$args);
}
$f = fn($x, $y) => $x ** $y;
function sum(int|float ...$args)
{
return array_sum($args);
}
echo runner(fn($x) => $x ** 2, 2); // prints 4
echo runner($f, 2, 3); // prints 8
echo runner('sum', 1, 2, 3, 4); // prints 10
Iterável
Iterable
tipo indica que a variável pode ser usada com foreach
loop. Pode ser qualquer objeto array
ou generator
ou que esteja implementando a Traversable
interface interna especial .
function printSquares(iterable $data)
{
foreach ($data as $value) {
echo ($value ** 2) . " ";
}
echo "\n";
}
// array
$array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// generator
$generator = function (): Generator {
for ($i = 1; $i <= 10; $i++) {
yield $i;
}
};
// object
$arrayIterator = new ArrayIterator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
printSquares($array); // 1 4 9 16 25 36 49 64 81 100
printSquares($generator()); // 1 4 9 16 25 36 49 64 81 100
printSquares($arrayIterator); // 1 4 9 16 25 36 49 64 81 100
Tipos de união
Tipos de união foram introduzidos no PHP 8.0
function foo(string|int $foo): string|int {}
Funções
O PHP tem centenas de funções básicas e milhares mais de extensões. Antes da versão 5.3.0 do PHP, as funções não são funções de primeira classe e só podem ser referenciadas por seus nomes, enquanto o PHP 5.3.0 introduz encerramentos. As funções definidas pelo usuário podem ser criadas a qualquer momento e sem serem prototipadas. As funções podem ser definidas dentro de blocos de código, permitindo uma decisão em tempo de execução se uma função deve ou não ser definida. Não há conceito de funções locais. As chamadas de função devem usar parênteses com exceção das funções construtoras de classe de argumento zero chamadas com o new
operador PHP , onde parênteses são opcionais.
Um exemplo de definição de função é o seguinte:
function hello($target='World')
{
echo "Hello $target!\n";
}
hello(); // outputs "Hello World!"
hello('Wikipedia'); // outputs "Hello Wikipedia!"
As chamadas de função podem ser feitas por meio de variáveis, onde o valor de uma variável contém o nome da função a ser chamada. Isto é ilustrado no exemplo seguinte:
function hello()
{
return 'Hello';
}
function world()
{
return "World!";
}
$function1 = 'hello';
$function2 = 'world';
echo "{$function1()} {$function2()}";
Um valor padrão para parâmetros pode ser atribuído na definição da função, mas antes do PHP 8.0 não suportava parâmetros nomeados ou salto de parâmetro. Alguns desenvolvedores de PHP expressaram publicamente seu desapontamento com essa decisão. Outros sugeriram soluções alternativas para essa limitação.
Argumentos nomeados
Argumentos nomeados foram introduzidos no PHP 8.0
function power($base, $exp)
{
return $base ** $exp;
}
// Using positional arguments:
echo power(2, 3); // prints 8
// Using named arguments:
echo power(base: 2, exp: 3); // prints 8
echo power(exp: 3, base: 2); // prints 8
Declaração de tipo
Especificar os tipos de parâmetros de função e valores de retorno de função é suportado desde o PHP 7.0.
Declaração de tipo de retorno:
function sum($a, $b): float
{
return $a + $b;
}
var_dump(sum(1, 2)); // prints float(3)
Digitação de parâmetros:
function sum(int $a, int $b)
{
return $a + $b;
}
var_dump(sum(1, 2)); // prints int(3)
var_dump(sum(1.6, 2.3)); // prints int(3)
Digitação estrita
Sem a digitação estrita ativada:
$f1 = fn ($a, $b): int => $a + $b;
$f2 = fn (int $a, int $b) => $a + $b;
var_dump($f1(1.3, 2.6)); // prints int(3)
var_dump($f1(1, '2')); // prints int(3)
var_dump($f2(1.3, 2.6)); // prints int(3)
var_dump($f2(1, '2')); // prints int(3)
Com a digitação estrita ativada:
declare(strict_types=1);
$f1 = fn ($a, $b): int => $a + $b;
$f2 = fn (int $a, int $b) => $a + $b;
var_dump($f1(1.3, 2.6)); // Fatal error: Return value must be of type int, float returned
var_dump($f1(1, '2')); // prints int(3)
var_dump($f2(1.3, 2.6)); // Fatal error: Argument #1 ($a) must be of type int, float given
var_dump($f2(1, '2')); // Fatal error: Argument #2 ($b) must be of type int, string given
Funções anônimas
PHP suporta funções anônimas verdadeiras a partir da versão 5.3. Nas versões anteriores, o PHP só suportava funções quase anônimas por meio da create_function()
função.
$x = 3;
$func = function($z) { return $z * 2; };
echo $func($x); // prints 6
Desde a versão 7.4, o PHP também suporta a sintaxe de funções de seta ( =>
).
$x = 3;
$func = fn($z) => $z * 2;
echo $func($x); // prints 6
Fechamentos
Criação de fechamentos
$add = fn($x) => fn($y) => $y + $x;
/* Equivalent to */
$add = function ($x) {
return function ($y) use ($x) {
return $y + $x;
};
};
usando
$f = $add(5);
echo $f(3); // prints 8
echo $add(2)(4); // prints 6
Geradores
Usando geradores, podemos escrever código que usa foreach para iterar em um conjunto de dados sem ter que criar um array na memória, o que pode resultar em sobrecarga de memória ou tempo de processamento significativo para geração.
Objetos
Funcionalidade básica de programação orientada a objetos foi adicionada no PHP 3. O tratamento de objetos foi completamente reescrito para o PHP 5, expandindo o conjunto de recursos e melhorando o desempenho. Nas versões anteriores do PHP, os objetos eram tratados como tipos primitivos . A desvantagem desse método era que todo o objeto era copiado quando uma variável era atribuída ou passada como parâmetro para um método. Na nova abordagem, os objetos são referenciados por identificador e não por valor. O PHP 5 introduziu variáveis e métodos de membros privados e protegidos , junto com classes abstratas e classes finais , bem como métodos abstratos e métodos finais . Ele também introduziu uma maneira padrão de declarar construtores e destruidores , semelhante àquela de outras linguagens orientadas a objetos, como C ++ , e um modelo de tratamento de exceção padrão . Além disso, o PHP 5 adicionou interfaces e permite que várias interfaces sejam implementadas. Existem interfaces especiais que permitem que os objetos interajam com o sistema de tempo de execução. Os objetos que implementam ArrayAccess podem ser usados com a sintaxe de array e os objetos que implementam Iterator ou IteratorAggregate podem ser usados com a construção de linguagem foreach . O método estático e os recursos de variável de classe no Zend Engine 2 não funcionam da maneira que alguns esperariam. Não há nenhum recurso de tabela virtual no mecanismo, portanto, as variáveis estáticas são associadas a um nome em vez de uma referência em tempo de compilação.
Este exemplo mostra como definir uma classe Foo
,, que herda de classe Bar
. O método myStaticMethod
é um método estático público que pode ser chamado com Foo::myStaticMethod();
.
class Foo extends Bar
{
function __construct()
{
$doo = "wah dee dee";
}
public static function myStaticMethod()
{
$dee = "dee dee dum";
}
}
Se o desenvolvedor criar uma cópia de um objeto usando a palavra reservada clone , o motor Zend verificará se um método __clone () foi definido ou não. Caso contrário, ele chamará um __clone () padrão que copiará as propriedades do objeto. Se um método __clone () for definido, ele será responsável por configurar as propriedades necessárias no objeto criado. Por conveniência, o mecanismo fornecerá uma função que importa as propriedades do objeto de origem, para que o programador possa começar com uma réplica por valor do objeto de origem e apenas substituir as propriedades que precisam ser alteradas.