Riferimento-Cosa significa questo simbolo in PHP?




operators symbols (12)

Cos'è questo?

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

Perchè è questo?

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

¹ Nota: da gennaio 2013 Stack Overflow supporta caratteri speciali . Basta racchiudere i termini di ricerca tra virgolette, ad esempio [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 PHP insieme alle domande collegate probabilmente risponderanno alla tua domanda. Se è così, sei incoraggiato a cambiare la risposta. Questo elenco non è inteso come sostituto dell'aiuto fornito dagli altri.

La lista

Se il tuo particolare token non è elencato di seguito, potresti trovarlo nella lista dei token del parser .

Operatori o References bit a bit

=& References

&= Operatori bit a bit

&& Operatori logici

% Operatori aritmetici

!! Operatori logici

@ Operatori di controllo degli errori

?: Operatore ternario

?? Null Coalesce Operator (dal PHP 7)

: Sintassi alternativa per le strutture di controllo , operatore ternario

:: Operatore di risoluzione dell'oscilloscopio

\ Namespaces

-> Classi e oggetti

=> Arrays

^ 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 comparazione (dal PHP 7.0)

  • Operatore di astronave (confronto a tre vie)

| Operatori bit a bit

|| Operatori logici

~ Operatori bit a bit

+ Operatori aritmetici , operatori di array

+= e -= Operatori di assegnazione

++ e -- Operatori di incremento / decremento

.= Operatori di assegnazione

. Operatori di stringhe

, Argomenti funzionali

, Dichiarazioni variabili

$$ Variabili variabili

` Operatore esecutivo

<?= Tag aperti brevi

[] Arrays (sintassi breve da PHP 5.4)

<? Tag di apertura e chiusura

... Spacchettamento di argomenti (dal PHP 5.6)

** Exponentiation (da PHP 5.6)

# Commento sullo shell di una sola riga


Operatore bit a bit

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

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. Osserveremo il motivo per cui 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;

Questo 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 dal tavolo l'unico bit che condividono è 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 quando aggiunti insieme restituiscono 36.

L'operatore "Or": |

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

Questo 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 3 bit impostati, nelle colonne 8, 2 e 1. Aggiungili: 8 + 2 + 1 = 11.


Tipo Operatori

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 uscirà:

bool(true)
bool(false)

Causa: sopra Esempio $a è un oggetto di mclass quindi usa solo un dato di mclass non istanza di con lo sclass

Esempio con ereditarietà

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

L'esempio sopra uscirà:

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 uscirà:

bool(true)
bool(true)

<=> Operatore di astronave

Aggiunto in PHP 7

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

L'operatore produce un'espressione intera di:

  • 0 quando entrambi gli operandi sono uguali
  • Meno di 0 quando l'operando di sinistra è inferiore all'operando di destra
  • Maggiore di 0 quando 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 in tipi di callback 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 a usort è uno di questi esempi.

Prima di PHP 7 dovresti scrivere ...

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

Spaceship Operator <=> (Aggiunto in PHP 7)

Esempi per <=> operatore Spaceship (PHP 7, Source: PHP Manual):

Integer, float, stringhe, matrici 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

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

==è usato per controllare l'uguaglianza senza considerare il tipo di dati variabile

===è usato per controllare l'uguaglianza sia per il valore della variabile * che per il tipo di dati

Esempio

$a = 5

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

  2. if ($a == '5') - valuterà a vero, perché mentre confrontando questo valore php internamente converti quel valore stringa in numero intero e poi confronti entrambi i valori

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

  4. if ($a === '5') - valuterà a false, perché il valore è 5, ma questo valore 5 non è un numero intero.



Operatori incrementali / decrescenti

++ operatore di incremento

-- Operatore decrementa

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 messo prima della variabile, l'operazione di incremento / decremento viene eseguita prima sulla variabile, quindi viene restituito il risultato. Se messo 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 sopra ++$i viene utilizzato, poiché è più veloce. $i++ avrebbe gli stessi risultati.

Il pre-incremento è un po 'più veloce, perché aumenta effettivamente la variabile e dopo di ciò' restituisce 'il risultato. Post-incremento crea una variabile speciale, copia lì il valore della prima variabile e solo dopo che la prima variabile è stata utilizzata, sostituisce il suo valore con la seconda.

Tuttavia, è necessario utilizzare $apples-- , poiché prima 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 che z è raggiunto 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).

Posts:


Costanti magiche : Sebbene questi non siano solo simboli ma parte importante di questa famiglia di token. Ci sono otto costanti magiche che cambiano a seconda di dove sono usate.

__LINE__ : il numero di riga corrente del file.

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

__DIR__ : la directory del file. Se utilizzato all'interno di un include, viene restituita la directory del file incluso. Questo è equivalente a dirname(__FILE__) . Questo nome di directory non ha una barra finale a meno che non sia la directory root. (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 è stato dichiarato (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 ). Si noti che dal PHP 5.4 __CLASS__ funziona anche nei tratti. Quando usato in un metodo tratto, __CLASS__ è il nome della classe in cui è usato il tratto.

__TRAIT__ : il nome del tratto. (Aggiunto in PHP 5.4.0) A partire da PHP 5.4 questa costante restituisce il tratto come è 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 è stato 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).

Source


Domanda :

Cosa significa "&" qui in PHP?

PHP "&" operatore

Rende la vita più facile una volta che ci siamo abituati ad esso .. (controlla l'esempio sotto con attenzione)

e di solito i bit di controllo impostati in $ a e $ b sono impostati.

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 questo, c'è il gioco dell'operatore bit e dei bit.

Un caso utile di questi è una facile configurazione 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 relazionato il caso d'uso del mondo reale di questi operatori bit a bit.

Esempio che amerai

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

Null Coalesce Operator php

L'operatore null coalescing (??) è stato aggiunto a PHP7 per il caso comune di dover usare un ternario in congiunzione con isset (). Restituisce il suo primo operando se esiste e non è NULL altrimenti restituisce il suo secondo operando, come nell'esempio seguente:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

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

1) Stringhe di quotazioni singole:

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

2) Corde per doppia citazione:

$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

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
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"






php-5.3