Cos'è questo?

Questa è una raccolta di domande che sorgono di tanto in tanto sulla sintassi in PHP. Questo è anche un Wiki della comunità, quindi tutti sono invitati a partecipare alla gestione di questo elenco.

Perchè è questo?

In passato era difficile trovare domande sugli operatori e altri token di sintassi.¹
L'idea principale è quella di avere collegamenti a domande esistenti su Stack Overflow, quindi è più facile per noi fare riferimento a loro, non copiare sul contenuto del Manuale PHP.

Nota: da gennaio 2013 Stack Overflow supporta caratteri speciali . Basta racchiudere i termini di ricerca tra virgolette, ad es[php] "==" vs "==="

Cosa dovrei fare qui?

Se sei stato indicato qui da qualcuno perché hai fatto una domanda del genere, ti preghiamo di trovare la sintassi particolare di seguito. Le pagine collegate al manuale di PHP insieme alle domande collegate probabilmente risponderanno alla tua domanda allora. In tal caso, sei incoraggiato a votare la risposta. Questo elenco non è inteso come sostituto dell'aiuto fornito da altri.

La lista

Se il tuo token particolare non è elencato di seguito, potresti trovarlo nell'elenco dei token parser .

& Operatori o riferimenti bit a bit

• Cosa significa avviare una funzione PHP con una e commerciale?
• Comprensione dell'operatore PHP & (e commerciale, bit a bit e)
• Operatore PHP "&"
• Differenza tra & e && in PHP
• Cosa significa "&" qui in PHP?
• Cosa significa "&" in questo caso?
• Cosa significa il segno "&" in PHP?
• Cosa significa questa firma (&) in PHP?
• Come funziona l'operatore "&" in una funzione PHP?
• Cosa significa & in & 2 in PHP?
• Quando dovrei usare un operatore bit per bit?
• C'è mai la necessità di usare la e commerciale davanti a un oggetto? (& $)

=& Riferimenti

• Operatore di assegnazione di riferimento in PHP, = &
• Cosa significano gli operatori "= &" e "& =" in PHP?
• Cosa fanno gli operatori '& =' e '= &'?
• Cosa significa = & significa in PHP?

&= Operatori bit a bit

• Cosa significano gli operatori "= &" e "& =" in PHP?
• Cosa fanno gli operatori '& =' e '= &'?

&& Operatori logici

• 'AND' vs '&&' come operatore
• Differenza tra & e && in PHP
• C'è qualche differenza tra gli operatori "e" e "&&" in PHP?
• PHP - e / o parole chiave

% Operatori aritmetici

• Cosa significa il segno di percentuale in PHP?
• Cos'è l'operatore PHP% e come lo uso negli esempi del mondo reale?

!! Operatori logici

• Operatore doppio (!!) non in PHP

@ Operatori di controllo errori

• Qual è l'uso del simbolo @ in PHP?
• Simbolo "At" prima del nome della variabile in PHP: @ $ _ POST
• Funzioni PHP e funzioni @
• Dovrei usare @ nel mio codice PHP?
• Cosa significa @ in PHP?

?: Operatore ternario

• Cosa sono gli operatori PHP "?" e ":" chiamato e cosa fanno?
• ?: operator (l '"operatore Elvis") in PHP
• Dove posso leggere i condizionali eseguiti con "?" e ":" (due punti)?
• Utilizzo di PHP 5.3?: Operatore

?? Null Coalesce Operator (da PHP 7)

• Operatore a coalescenza nulla di C # (??) in PHP

?string ?int ?array ?bool ?float Dichiarazione del tipo restituibile nullable (dal PHP 7.1)

• Dichiarazione del tipo restituibile nullabile

: Sintassi alternativa per strutture di controllo , operatore ternario

• Che cos'è ":" in PHP?
• Cosa significa ":" in PHP?

:: Operatore Risoluzione Scope

• Cosa significano due due punti in PHP?
• Qual è il significato del nome del token PHP T_PAAMAYIM_NEKUDOTAYIM?
• Qual è la differenza tra :: (doppio punto) e -> (freccia) in PHP?
• Cosa sono esattamente i binding statici tardivi in ​​PHP?
• statica :: staticFunctionName ()
• T_PAAMAYIM_NEKUDOTAYIM imprevisto, in attesa di T_NS_Separator

\ Namespace

• Backslash in PHP: cosa significa?
• Cosa fa un \ (backslash) in PHP (5.3+)?

-> Classi E Oggetti

• Come si chiama l'operatore PHP "->" e come si dice quando si legge il codice ad alta voce?
• Dove utilizziamo l'operatore oggetto "->" in PHP?
• Qual è la differenza tra :: (doppio punto) e -> (freccia) in PHP?
• Cosa significa la sintassi PHP $ var1 -> $ var2?
• Cosa significa "->" / riferimento in PHP?

=> Array

• Che cosa significa "=>" in PHP?
• Uso di => in PHP
• Cosa significa $ k => $ v in foreach ($ ex as $ k => $ v)?

^ Operatori bit a bit

• Come funziona l'operatore bit a bit XOR ('^')?
• Cosa significa ^ in PHP?

>> Operatori bit a bit

• Cosa significa >> in PHP?

<< Operatori bit a bit

• Strano comportamento di stampa in PHP?

<<< Heredoc o Nowdoc

• Cosa significa <<< END in PHP?
• Espressione PHP <<< EOB
• In PHP, cosa rappresenta "<<<"?
• Utilizzando <<< CON in PHP
• Che cos'è questo tipo di sintassi in PHP?

= Operatori di assegnazione

• I 3 diversi uguali

== Operatori di confronto

• In che modo differiscono gli operatori di confronto di uguaglianza PHP (== doppio uguale) e identità (=== triplo uguale)?
• Operatori PHP! = E ==
• I 3 diversi uguali
• Tipo di giocoleria e (rigoroso) maggiore / minore rispetto ai confronti in PHP

=== Operatori di confronto

• Che cosa significa "==="?
• In che modo differiscono gli operatori di confronto di uguaglianza PHP (== doppio uguale) e identità (=== triplo uguale)?
• I 3 diversi uguali
• Tipo di giocoleria e (rigoroso) maggiore / minore rispetto ai confronti in PHP

!== Operatori di confronto

• Cosa significa! == operatore di confronto in PHP?
• C'è una differenza tra! == e! = In PHP?

!= Operatori di confronto

• Operatori PHP! = E ==
• C'è una differenza tra! == e! = In PHP?
• confronto,! == contro! =
• Qual è la differenza tra <> e! =

<> Operatori di confronto

• Operatore PHP <>
• Operatore <> di PHP
• Qual è la differenza tra <> e! =
• Tipo di giocoleria e (rigoroso) maggiore / minore rispetto ai confronti in PHP

<=> Operatori di confronto (dal PHP 7.0)

• Operatore di astronave (confronto a tre vie)

| Operatori bit a bit

• Qual è la differenza tra | e || gli operatori?
• Cosa fa usando una singola pipe '|' In una funzione argomento fare?

|| Operatori logici

• Qual è la differenza tra | e || gli operatori?
• PHP - e / o parole chiave
• Cosa fa esattamente || significare?
• Il comportamento dell'operatore o in PHP

~ Operatori bit a bit

• Cosa significa questo operatore ~ ​​qui?

+ Operatori aritmetici , operatori di array

• + operatore per array in PHP?

+=e -= operatori di assegnazione

• A cosa serve + =?
• Cosa significa `$ page - = 1` nel mio documento PHP?

++e -- operatori in aumento / decremento

• Capire l'incremento
• Risposta sotto

.= Operatori di assegnazione

• Qual è la differenza tra. = E + = in PHP?
• Per capire una linea di PHP

. Operatori di stringa

• Differenza tra punto e virgola quando si concatena con l'eco rispetto al ritorno?
• Cosa fa a. (punto) fare in PHP?

, Argomenti di funzione

• Differenza tra punto e virgola quando si concatena con l'eco rispetto al ritorno?

, Dichiarazioni variabili

• Cosa significano le virgole in una dichiarazione variabile?

$$ Variabili variabili

• Cosa significa $$ (dollaro o doppio dollaro) in PHP?
• cos'è "$$" in PHP
• $ funzione () e $$ variabile

` Operatore di esecuzione

• Come si chiamano i backtick?

<?= Tag aperti brevi

• Cosa significa questo simbolo in PHP <? =
• Che cosa significa "<? =" In PHP?
• Cosa significa <? =?

[] Array (sintassi breve da PHP 5.4)

• Array PHP ... Qual è / sono il significato di una parentesi vuota?
• Qual è il significato di []
• Php array_push () vs myArray []
• Cosa significa [] quando si legge da un array PHP?
• Stenografia per array: letterale $var = []array vuoto

<? Apertura e chiusura dei tag

• I tag brevi PHP sono accettabili da usare?

... Argomento disimballaggio (dal PHP 5.6)

** Esponenziazione (dal PHP 5.6)

# Commento in stile shell a una riga

• Posso usare gli hash per i commenti in PHP?

:? Tipi restituibili nullabili

• metodo php argomento tipo suggerimento con punto interrogativo (? tipo)

?-> Chiamate operatore NullSafe

• Cosa significa questo simbolo "? ->" in php, all'interno di un oggetto o di un valore nullo

Operatori di incremento / decremento

++ operatore di incremento

-- operatore decremento

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Questi possono andare prima o dopo la variabile.

Se posto prima della variabile, l'operazione di incremento / decremento viene eseguita prima sulla variabile, quindi il risultato viene restituito. Se inserito dopo la variabile, la variabile viene prima restituita, quindi viene eseguita l'operazione di incremento / decremento.

Per esempio:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Esempio dal vivo

Nel caso precedente ++$iviene utilizzato, poiché è più veloce. $i++avrebbe gli stessi risultati.

Il pre-incremento è un po 'più veloce perché aumenta realmente la variabile e dopo "restituisce" il risultato. Post-incremento crea una variabile speciale, copia lì il valore della prima variabile e solo dopo aver usato la prima variabile, sostituisce il suo valore con quello della seconda.

Tuttavia, è necessario utilizzare $apples--, dal primo momento, si desidera visualizzare il numero corrente di mele e quindi si desidera sottrarre uno da esso.

Puoi anche incrementare le lettere in PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Una volta zraggiunto aaè il prossimo, e così via.

Si noti che le variabili di carattere possono essere incrementate ma non decrementate e anche così sono supportati solo caratteri ASCII semplici (az e AZ).

Stack Overflow Posts:

• Capire l'incremento

Operatore bit a bit

Che cos'è un po? Un bit è una rappresentazione di 1 o 0. Fondamentalmente OFF (0) e ON (1)

Che cos'è un byte? Un byte è composto da 8 bit e il valore più alto di un byte è 255, il che significa che ogni bit è impostato. Vedremo perché il valore massimo di un byte è 255.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Questa rappresentazione di 1 byte

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 byte)

Alcuni esempi per una migliore comprensione

L'operatore "AND": &

$a =  9;
$b = 10;
echo $a & $b;

Ciò produrrebbe il numero 8. Perché? Bene, vediamo usando il nostro esempio di tabella.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

Quindi puoi vedere dalla tabella l'unico bit che condividono insieme è l'8 bit.

Secondo esempio

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

I due bit condivisi sono 32 e 4, che sommati restituiscono 36.

L'operatore "O": |

$a =  9;
$b = 10;
echo $a | $b;

Ciò produrrebbe il numero 11. Perché?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Noterai che abbiamo impostato 3 bit, nelle colonne 8, 2 e 1. Aggiungi quelli in su: 8 + 2 + 1 = 11.

<=> Operatore di astronave

Aggiunto in PHP 7

L' operatore spaziale <=> è l'ultimo operatore di confronto aggiunto in PHP 7. È un non associativa operatore binario con la stessa precedenza operatori di uguaglianza ( ==, !=, ===, !==). Questo operatore consente un confronto a tre vie più semplice tra operandi di sinistra e di destra.

L'operatore genera un'espressione intera di:

• 0 quando entrambi gli operandi sono uguali
• Meno di 0quando l'operando di sinistra è inferiore all'operando di destra
• Maggiore di 0quando l'operando di sinistra è maggiore dell'operando di destra

per esempio

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Una buona applicazione pratica dell'utilizzo di questo operatore sarebbe nei callback di tipo di confronto che dovrebbero restituire un numero intero zero, negativo o positivo basato su un confronto a tre vie tra due valori. La funzione di confronto passata usortè un esempio.

Prima di PHP 7 scrivevi ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Da PHP 7 puoi scrivere ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

_ Alias ​​per gettext ()

Il carattere di sottolineatura '_' come in _()è un alias della gettext()funzione.

Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

Costanti magiche : anche se questi non sono solo simboli ma parte importante di questa famiglia di token. Esistono otto costanti magiche che cambiano a seconda di dove vengono utilizzate.

__LINE__: Il numero di riga corrente del file.

__FILE__: Il percorso completo e il nome file del file. Se utilizzato all'interno di un'inclusione, viene restituito il nome del file incluso. A partire da PHP 4.0.2, __FILE__contiene sempre un percorso assoluto con collegamenti simbolici risolti, mentre nelle versioni precedenti conteneva un percorso relativo in alcune circostanze.

__DIR__: La directory del file. Se utilizzato all'interno di un'inclusione, viene restituita la directory del file incluso. Questo equivale a dirname(__FILE__). Questo nome di directory non ha una barra finale a meno che non sia la directory principale. (Aggiunto in PHP 5.3.0.)

__FUNCTION__: Il nome della funzione. (Aggiunto in PHP 4.3.0) A partire da PHP 5 questa costante restituisce il nome della funzione così come è stata dichiarata (sensibile al maiuscolo / minuscolo). In PHP 4 il suo valore è sempre in minuscolo.

__CLASS__: Il nome della classe. (Aggiunto in PHP 4.3.0) A partire da PHP 5 questa costante restituisce il nome della classe così come è stato dichiarato (sensibile al maiuscolo / minuscolo). In PHP 4 il suo valore è sempre in minuscolo. Il nome della classe include lo spazio dei nomi in cui è stato dichiarato (ad es Foo\Bar.). Nota che a partire da PHP 5.4 __CLASS__funziona anche nei tratti. Se utilizzato in un metodo tratto, __CLASS__è il nome della classe in cui viene utilizzato il tratto.

__TRAIT__: Il nome del tratto. (Aggiunto in PHP 5.4.0) A partire da PHP 5.4 questa costante restituisce il tratto com'era stato dichiarato (sensibile al maiuscolo / minuscolo). Il nome del tratto include lo spazio dei nomi in cui è stato dichiarato (ad es Foo\Bar.).

__METHOD__: Il nome del metodo di classe. (Aggiunto in PHP 5.0.0) Il nome del metodo viene restituito come dichiarato (sensibile al maiuscolo / minuscolo).

__NAMESPACE__: Il nome dello spazio dei nomi corrente (sensibile al maiuscolo / minuscolo). Questa costante è definita in fase di compilazione (aggiunta in PHP 5.3.0).

fonte

Operatori di tipo

instanceof viene utilizzato per determinare se una variabile PHP è un oggetto istanziato di una determinata classe.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

L'esempio sopra mostrerà:

bool(true)
bool(false)

Motivo: l' esempio sopra $aè un oggetto di mclasscosì usare solo un mclassdato non istanza di consclass

Esempio con eredità

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

L'esempio sopra mostrerà:

bool(true)
bool(true)

Esempio con Clone

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

L'esempio sopra mostrerà:

bool(true)
bool(true)

Una panoramica degli operatori in PHP :

Operatori logici:

• $ a && $ b: TRUE se sia $ a che $ b sono TRUE.
• $ a || $ b: TRUE se $ a o $ b è TRUE.
• $ a xo $ b: VERO se $ ao $ b è VERO, ma non entrambi.
• ! $ a: VERO se $ a non è VERO.
• $ ae $ b: TRUE se sia $ a che $ b sono TRUE.
• $ a o $ b: TRUE se $ a o $ b è TRUE.

Operatori di confronto:

• $ a == $ b: TRUE se $ a è uguale a $ b dopo la manipolazione del tipo.
• $ a === $ b: VERO se $ a è uguale a $ b e sono dello stesso tipo.
• $ a! = $ b: TRUE se $ a non è uguale a $ b dopo la manipolazione del tipo.
• $ a <> $ b: TRUE se $ a non è uguale a $ b dopo la manipolazione del tipo.
• $ a! == $ b: TRUE se $ a non è uguale a $ b o non sono dello stesso tipo.
• $ a <$ b : TRUE se $ a è strettamente inferiore a $ b.
• $ a> $ b : TRUE se $ a è strettamente maggiore di $ b.
• $ a <= $ b : TRUE se $ a è minore o uguale a $ b.
• $ a> = $ b : TRUE se $ a è maggiore o uguale a $ b.
• $ a <=> $ b : un numero intero minore di, uguale a o maggiore di zero quando $ a è rispettivamente minore di, uguale a o maggiore di $ b. Disponibile da PHP 7.
• $ a? $ b: $ c : se $ a restituisce $ b altrimenti restituisce $ c ( operatore ternario )
• $ a ?? $ c : uguale a $ a? $ a: $ c ( operatore null coalescente - richiede PHP> = 7)

Operatori aritmetici:

• - $ a : di fronte a $ a.
• $ a + $ b : somma di $ ae $ b.
• $ a - $ b : differenza di $ ae $ b.
• $ a * $ b : Prodotto di $ ae $ b.
• $ a / $ b : quoziente di $ ae $ b.
• $ a% $ b : resto di $ a diviso per $ b.
• $ a ** $ b : Risultato di innalzare $ a al $ b'th power (introdotto in PHP 5.6)

Operatori di incremento / decremento:

• ++ $ a : incrementa $ a di uno, quindi restituisce $ a.
• $ a ++ : restituisce $ a, quindi incrementa $ a di uno.
• - $ a : diminuisce di $ a di uno, quindi restituisce $ a.
• $ a-- : restituisce $ a, quindi diminuisce di $ a di uno.

Operatori bit a bit:

• $ a & $ b : i bit impostati in $ a e $ b sono impostati.
• $ a | $ b : i bit impostati in $ a o $ b sono impostati.
• $ a ^ $ b : bit impostati in $ a o $ b ma non entrambi.
• ~ $ a : i bit impostati in $ a non sono impostati e viceversa.
• $ a << $ b : sposta i bit di $ a $ b passi a sinistra (ogni passo significa "moltiplica per due")
• $ a >> $ b : sposta i bit di $ a $ b verso destra (ogni passo significa "dividi per due")

Operatori di stringa:

• $ a. $ b : concatenazione di $ ae $ b.

Operatori di array:

• $ a + $ b : unione di $ ae $ b.
• $ a == $ b : TRUE se $ a e $ b hanno le stesse coppie chiave / valore.
• $ a === $ b : TRUE se $ a e $ b hanno le stesse coppie chiave / valore nello stesso ordine e degli stessi tipi.
• $ a! = $ b : VERO se $ a non è uguale a $ b.
• $ a <> $ b : TRUE se $ a non è uguale a $ b.
• $ a! == $ b : TRUE se $ a non è identico a $ b.

Operatori di assegnazione:

• $ a = $ b : il valore di $ b è assegnato a $ a
• $ a + = $ b : uguale a $ a = $ a + $ b
• $ a - = $ b : uguale a $ a = $ a - $ b
• $ a * = $ b : uguale a $ a = $ a * $ b
• $ a / = $ b : uguale a $ a = $ a / $ b
• $ a% = $ b : uguale a $ a = $ a% $ b
• $ a ** = $ b : uguale a $ a = $ a ** $ b
• $ a. = $ b : uguale a $ a = $ a. $ b
• $ a & = $ b : uguale a $ a = $ a & $ b
• $ a | = $ b : uguale a $ a = $ a | $ b
• $ a ^ = $ b : uguale a $ a = $ a ^ $ b
• $ a << = $ b : uguale a $ a = $ a << $ b
• $ a >> = $ b : uguale a $ a = $ a >> $ b

Nota

andl'operatore e l' oroperatore hanno una precedenza inferiore rispetto all'operatore di assegnazione =.

Ciò significa che $a = true and false;è equivalente a ($a = true) and false.

Nella maggior parte dei casi probabilmente vorrai usare &&e ||, che si comportano in un modo noto da linguaggi come C, Java o JavaScript.

Operatore di astronave<=> (aggiunto in PHP 7)

Esempi per l' <=>operatore di astronave (PHP 7, fonte: Manuale PHP):

Numeri interi, float, stringhe, array e oggetti per il confronto a tre vie delle variabili.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
// Comparison is case-sensitive
echo "B" <=> "a"; // -1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

{} Parentesi graffe

• Blocchi: parentesi graffe / nessuna parentesi graffa?
• Parentesi graffe ricci in stringa in PHP
• Parentesi graffe ricci PHP in notazione di array

E alcune parole sull'ultimo post

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

Operatore a coalescenza nulla (??)

Questo operatore è stato aggiunto in PHP 7.0 per il caso comune di necessità di utilizzare un operatore ternario insieme a isset(). Restituisce il suo primo operando se esiste e non lo è NULL; altrimenti restituisce il suo secondo operando.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

Stringhe PHP: le stringhe PHP possono essere specificate in quattro modi, non solo in due modi:

1) Stringhe a virgoletta singola:

$string = 'This is my string'; // print This is my string

2) Stringhe con virgolette doppie:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (dal PHP 5.3.0):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

DOMANDA:

Cosa =>significa?

RISPOSTA:

=>È il simbolo che noi umani abbiamo deciso di usare per separare le "Key" => "Value"coppie negli array associativi.

elaborando:

Per capirlo, dobbiamo sapere cosa sono gli array associativi. La prima cosa che emerge quando un programmatore convenzionale pensa a un array ( in PHP ) sarebbe qualcosa di simile a:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Dove, se volessimo chiamare l'array in qualche parte successiva del codice, potremmo fare:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

Fin qui tutto bene. Tuttavia, come esseri umani, potremmo trovare difficile ricordare che l'indice [0]dell'array è il valore dell'anno 2016, l'indice [1]dell'array è un saluto e l'indice [2]dell'array è un valore intero semplice . L'alternativa che avremmo quindi è usare quella che viene chiamata matrice associativa . Un array associativo presenta alcune differenze rispetto a un array sequenziale ( che è quello che erano i casi precedenti poiché incrementano l'indice utilizzato in una sequenza predeterminata, aumentando di 1 per ciascun valore successivo ).

Differenze ( tra un array sequenziale e associativo ):

• Durando la dichiarazione di un array associativo, non si include solo il valuedi ciò che si desidera inserire nell'array, ma si inserisce anche il valore dell'indice (chiamato il key) che si desidera utilizzare quando si chiama l'array nelle parti successive del codice. La seguente sintassi viene utilizzata durante la sua dichiarazione: "key" => "value".

• Quando si utilizza l'array associativo, il keyvalore viene quindi inserito all'interno dell'indice dell'array per recuperare il desiderato value.

Per esempio:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

E ora, per ricevere lo stesso output di prima, il keyvalore verrebbe utilizzato nell'indice degli array:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

PUNTO FINALE:

Quindi, dall'esempio sopra, è abbastanza facile vedere che il =>simbolo è usato per esprimere la relazione di una matrice associativa tra ciascuna delle coppie keye valuein una matrice DURANTE l'inizio dei valori all'interno della matrice.

Domanda :

Cosa significa "&" qui in PHP?

Operatore PHP "&"

Rende la vita più facile una volta che ci abituiamo .. (controlla attentamente l'esempio sotto)

e di solito controlla i bit impostati sia in $ a che $ b.

hai mai notato come funzionano queste chiamate?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Quindi dietro tutto sopra c'è il gioco dell'operatore bit e bit.

Un caso utile di questi è la configurazione semplice come dare sotto, quindi un singolo campo intero può memorizzare migliaia di combo per te.

La maggior parte delle persone ha già letto i documenti ma non ha risolto il caso d'uso del mondo reale di questi operatori bit per bit.

Esempio che adorerai

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

== viene utilizzato per verificare l'uguaglianza senza considerare il tipo di dati variabile

===viene utilizzato per l'uguaglianza di controllo per entrambe la variabile valore e tipo di dati

Esempio

$a = 5

1. if ($a == 5) - valuterà come vero

2. if ($a == '5') - valuterà come vero, perché confrontando entrambi questi valori PHP converte internamente quel valore di stringa in numero intero e poi confronta entrambi i valori

3. if ($a === 5) - valuterà come vero

4. if ($a === '5') - verrà valutato come falso, poiché il valore è 5, ma questo valore 5 non è un numero intero.

Operatore Null Coalesce "??" (Aggiunto in PHP 7)

Non è il nome più incisivo per un operatore, ma PHP 7 porta in pratica la coalescenza nulla piuttosto utile, quindi ho pensato di condividere un esempio.

In PHP 5, abbiamo già un operatore ternario, che verifica un valore e quindi restituisce il secondo elemento se restituisce vero e il terzo in caso contrario:

echo $count ? $count : 10; // outputs 10

C'è anche una scorciatoia per ciò che ti permette di saltare il secondo elemento se è uguale al primo: echo $ count?: 10; // genera anche 10

In PHP 7 otteniamo inoltre il ?? operatore che, anziché indicare un'estrema confusione, è come utilizzare normalmente due punti interrogativi, invece ci consente di concatenare una serie di valori. Leggendo da sinistra a destra, il primo valore che esiste e non è null è il valore che verrà restituito.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Questo costrutto è utile per dare la priorità a uno o più valori provenienti forse dall'input dell'utente o dalla configurazione esistente e per ripiegare in modo sicuro su un dato valore predefinito se tale configurazione è mancante. È una specie di piccola funzionalità, ma so che userò non appena le mie applicazioni passeranno a PHP 7.

Dichiarazione del tipo restituibile nullabile

PHP 7 aggiunge il supporto per le dichiarazioni del tipo restituito. Analogamente alle dichiarazioni del tipo di argomento, le dichiarazioni del tipo restituito specificano il tipo di valore che verrà restituito da una funzione. Gli stessi tipi sono disponibili per le dichiarazioni del tipo di ritorno disponibili per le dichiarazioni del tipo di argomento.

La tipizzazione rigorosa ha anche un effetto sulle dichiarazioni del tipo restituito. Nella modalità debole predefinita, i valori restituiti verranno costretti al tipo corretto se non sono già di quel tipo. In modalità avanzata, il valore restituito deve essere del tipo corretto, altrimenti verrà lanciato un TypeError.

A partire da PHP 7.1.0, i valori di ritorno possono essere contrassegnati come nullable prefissando il nome del tipo con un punto interrogativo (?). Ciò significa che la funzione restituisce il tipo specificato o NULL.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

fonte

Tre DOT come operatore Splat (...) (dal PHP 5.6)

PHP ha un operatore "..." (Tre punti) che viene chiamato Operatore Splat. Viene utilizzato per passare un numero arbitrario di parametri in una funzione e questo tipo di funzione si chiama Variadic Functions. Facciamo degli esempi per usare "..." (Tre punti).

Esempio 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

Ogni argomento della funzione calcolaNumeri () passa attraverso $ params come un array quando usa "...".

Esistono molti modi diversi di utilizzare l'operatore "...". Di seguito alcuni esempi:

Esempio 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

Esempio 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

Esempio 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>

? -> Operatore NullSafe

Per il momento, è solo una proposta, puoi trovarla qui . È il NullSafe Operator, ritorna nullnel caso in cui si provi a richiamare funzioni o ottenere valori da null... Esempio

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

Operatore NullSafe "? ->" (possibilmente) da php8

Per il momento, è solo una proposta, puoi trovarla inserire la descrizione del link qui . ?->è il NullSafe Operator, ritorna nullnel caso in cui si tenta di richiamare funzioni o ottenere valori da null...

Esempi:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>