Riferimento - Cosa significa questo simbolo in PHP?


4480

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


=& Riferimenti


&= Operatori bit a bit


&& Operatori logici


% Operatori aritmetici


!! Operatori logici


@ Operatori di controllo errori


?: Operatore ternario


?? Null Coalesce Operator (da PHP 7)


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


: Sintassi alternativa per strutture di controllo , operatore ternario


:: Operatore Risoluzione Scope


\ Namespace


-> Classi E Oggetti


=> Array


^ Operatori bit a bit


>> Operatori bit a bit


<< Operatori bit a bit


<<< Heredoc o Nowdoc


= Operatori di assegnazione


== Operatori di confronto


=== Operatori di confronto


!== Operatori di confronto


!= Operatori di confronto


<> Operatori di confronto


<=> Operatori di confronto (dal PHP 7.0)


| Operatori bit a bit


|| Operatori logici


~ Operatori bit a bit


+ Operatori aritmetici , operatori di array


+=e -= operatori di assegnazione


++e -- operatori in aumento / decremento


.= Operatori di assegnazione


. Operatori di stringa


, Argomenti di funzione

, Dichiarazioni variabili


$$ Variabili variabili


` Operatore di esecuzione


<?= Tag aperti brevi


[] Array (sintassi breve da PHP 5.4)


<? Apertura e chiusura dei tag


... Argomento disimballaggio (dal PHP 5.6)


** Esponenziazione (dal PHP 5.6)


# Commento in stile shell a una riga


:? Tipi restituibili nullabili


?-> Chiamate operatore NullSafe



36
So che questo non è strettamente PHP, ma che dire di includere un link a phpdoc.org per la sintassi dei commenti phpDocumentor, che è comunemente usata ed è anche impossibile cercare /**?
Mike,

8
Posso suggerire la parentesi quadra e la parentesi graffa?
Ajreal,

124
Ho riscontrato anche questo problema (non potendo cercare caratteri speciali), motivo per cui ho creato SymbolHound , un motore di ricerca che non ignora i caratteri speciali. L'ho anche pubblicato su StackApps .
dncrane,

1
Bene, dalla rubrica Perché è questo? , Immagino sia perché "L'idea principale è quella di avere collegamenti a domande esistenti su Stack Overflow, quindi è più facile per noi fare riferimento a loro".
Herbert,

3
Una domanda è stato chiesto oggi (Nov.20 / 15) stackoverflow.com/questions/33833259/what-is-rscat-in-php chiedendo : "Qual è $ rsCat in php" (che dovrebbe domanda ancora essere resi visibili e non cancellati) . Stranamente, non c'è un riferimento sulla $variabile, ma solo sulle $$variabili variabili. Credo che dovrebbe essere modificato da qualche parte.
Funk Forty Niner,

Risposte:


1172

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:


9
+1 per la nota che i decrementatori non funzionano sui personaggi, ma solo sui numeri
Mark Baker,

163
Per il bene di tutti, si prega di rimuovere le informazioni in grassetto sul pre-incremento che è infinitamente più veloce. Questo è il peggior esempio assoluto di ottimizzazione prematura e questo tipo di informazioni non dovrebbe essere nella testa delle persone se stanno appena iniziando a imparare il PHP.
Lotus Notes

14
@Loto - Lo considero un fatto divertente. Se sei un principiante di PHP, C ++, ecc., Sembra piuttosto strano che ++ i e i ++ siano abbastanza diversi da funzionare a velocità diverse. L'ho trovato affascinante.
Peter Ajtai,

12
@Peter Ajtai Sì, è interessante, ma dal modo in cui hai strutturato il tuo post lo fai sembrare uno dei fatti principali di PHP che è assolutamente vitale per usare la lingua.
Lotus Notes

4
Non sono sicuro se sono solo io o no, ma l'esempio della mela sembra un po 'fuorviante. 'Ho 10 mele. Ne ho appena mangiato uno ", mi fa credere che tu abbia avuto 11 mele, ma ora ne hai 10 perché ne hai appena mangiato uno anziché mangiarne uno dopo aver detto di averne 10, facendoti così avere 9, che è ciò che il codice implica.
さ り げ な い 告白

440

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.


6
Cosa succede se $ a assume un valore maggiore di 255?
Aycan Yaşıt,

@AycanYaşıt La maggior parte del sistema operativo utilizza sistemi a 32 e 64 bit, il che significa che il limite è molto più di 255 (8 bit).
Albert Samuel

@AycanYaşıt In realtà, la rappresentazione qui con una lunghezza di un byte non è nemmeno corretta, poiché anche il numero intero più piccolo è ancora a 64 bit (8 byte) in memoria su una moderna piattaforma a 64 bit.
Kaii

Perché and &è 0 0 0 0 1 0 0 0 ed or |è 0 0 0 0 1 0 1 1?
Vir,

285

<=> 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;
});

21
Non sono sicuro di quanto $a <=> $bsia diverso da$a - $b
rev

38
@AcidShout $a - $bfunziona per numeri, ma non per stringhe, oggetti o matrici.
Mccrumley,

44
@mcrumley No, è peggio di così. In generale $a - $bnon funziona nemmeno per i numeri; funziona solo per numeri interi . Non funziona per numeri non interi, perché usortesegue il cast dei valori di ritorno della funzione del comparatore a int, il che significa che 0,5 viene trasmesso a 0, il che significa che due numeri con una differenza inferiore a 1, come 4 e 4.6, possono (a seconda su cui uno viene passato come primo argomento alla funzione di confronto) confronta erroneamente come uguale.
Mark Amery,

5
@MarkAmery la guida alla migrazione non è il comportamento documentato dell'operatore. Per quello che vuoi guardare la sezione operatori di lingua del manuale per quel php.net/language.operators.comparison il comportamento reale dietro questo si basa su varie funzioni di confronto dell'API, come quando stai facendo strcmp per le stringhe, dove non è possibile garantire l'effettivo valore restituito in ogni singolo caso. Certo, è quasi sempre 1, 0 o -1, ma per i casi in cui non puoi garantirlo come nel wrapping dello strcmp di libc, offri lo stesso comportamento definito delle specifiche sottostanti per essere sicuro
Sherif

9
@MarkAmery Il punto qui non è permettere alle persone di fare affidamento su comportamenti indefiniti. Nel caso in cui qualcuno ottenga un valore che non sia esattamente 1, 0 o -1, si ottiene qualcuno che presenta una segnalazione di bug pensando che ci sia qualcosa di sbagliato nella lingua. Ecco perché documentiamo che tutto ciò che possiamo garantire è che il valore sarà inferiore , maggiore o uguale a 0 e non necessariamente 1, 0 e -1.
Sceriffo


273
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"

239

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


150

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)

7
Quanto sopra funziona anche con "interfacce". Ciò è utile per verificare la disponibilità di una particolare interfaccia.
Ryan Vincent,

133

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.


1
C'è un errore in $a ?? $c, dice che è lo stesso di $a ? $a : $c, ma l'operatore ternario controlla se il valore è vero, d'altra parte, la coalescenza nulla verifica i valori null, quindi, se $ a è 0, otterrai 0 (perché 0 è non nullo), ad esempio se hai: $a=0; $c=5;quindi $a?$a:$crestituisce 5 e $a??$crestituisce 0.
stramin

104

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


74

{} Parentesi graffe

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

4
notazione {''} per i nomi delle proprietà. echo $ films-> movie -> {'great-lines'} -> line; può essere utilizzato per accedere ai dati in SimpleXMLElement. Forse può essere usato anche in altri casi. php.net/manual/en/simplexml.examples-basic.php
Andrei

68

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';
?>

64

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

@ Rizier123: Cosa significa "Heredocs non può essere utilizzato per inizializzare le proprietà della classe. A partire da PHP 5.3, questa limitazione è valida solo per heredocs che contengono variabili."?
PHPFan

48

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.


36

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

30

== 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.


27

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.


12

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


7

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

?>

0

? -> 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

Aggiungendo questo sembra piuttosto prematuro, nessuno vedrà questo operatore in nessun codice live e potrebbe anche non essere aggiunto. Sarebbe meglio aspettare che i dettagli siano stati finalizzati e documentarli correttamente.
IMSoP

Stiamo già ricevendo domande al riguardo. : / Se la proposta fallisce, possiamo decidere se vale la pena mantenerla.
John Conde,

@JohnConde vedi? questo è quello che stavo dicendo ...
Berto99

@JohnConde Sarei tentato di chiuderli come fuori tema, perché chiedono un linguaggio di programmazione immaginario; o forse "questa domanda appartiene a un'altra parte della sequenza temporale, controlla le impostazioni sulla tua macchina del tempo";)
IMSoP

lol Il pensiero mi è passato per la mente. Mi sono chiesto se questo avrebbe offerto valore ai futuri visitatori e, per ora, la risposta è "sì". Ma ciò potrebbe cambiare ...
John Conde,

0

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
?>

Aggiungendo questo sembra piuttosto prematuro, nessuno vedrà questo operatore in nessun codice live e potrebbe anche non essere aggiunto. Sarebbe meglio aspettare che i dettagli siano stati finalizzati e documentarli correttamente.
IMSoP

@IMSoP Sono con te, ma sono stato invitato a farlo qui stackoverflow.com/questions/62178354/... ...
Berto99

Sembra che ora abbiamo due risposte a riguardo. Personalmente, avrei solo votato per chiudere l'altra domanda piuttosto che cercare di rispondere, perché in questo momento non esiste un tale operatore.
IMSoP

@IMSoP ci sono molte domande qui su StackOverflow sulla proposta C ++ e non sono state chiuse: nonostante ciò, sono con te per non aver pubblicato qui questo operatore per il momento
Berto99

Non so molto sul processo C ++ e quando è ragionevole discutere delle proposte, e per essere onesti questo sembra abbastanza probabile che abbia successo nella modifica dell'allenamento, ma in generale ci sono molte funzionalità proposte per PHP che non arrivano mai al lingua e sarebbe piuttosto confuso per gli utenti trovarli tutti negli elenchi di riferimento. Detto questo, in parte sono solo un vecchio scontroso qui: P
IMSoP
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.