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 a short_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 controlado short_open_tag , mas está sempre disponível em versões posteriores.
  • 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;
Operador de navegação segura

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.

Veja também

Referências