operators - Riferimento-Cosa significa questo simbolo in PHP?




symbols php-5.3 (15)

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"

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 , quindi è più facile per noi fare riferimento a loro, non copiare il contenuto del manuale PHP.

¹ Nota: da gennaio 2013 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 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;
});

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

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)

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


Una panoramica degli operatori in PHP :

Operatori logici:

  • $ a && $ b: TRUE se entrambi $ a e $ b sono VERO.
  • $ a || $ b: TRUE se $ a o $ b è VERO.
  • $ a xor $ b: TRUE se $ a o $ b è VERO, ma non entrambi.
  • ! $ a: TRUE se $ a non è VERO.
  • $ a e $ b: TRUE se entrambi $ a e $ b sono VERO.
  • $ a o $ b: TRUE se $ a o $ b è VERO.

Operatori di confronto:

  • $ a == $ b: TRUE se $ a è uguale a $ b dopo il tipo di giocoleria.
  • $ a === $ b: TRUE se $ a è uguale a $ b e sono dello stesso tipo.
  • $ a! = $ b: TRUE se $ a non è uguale a $ b dopo il tipo di giocoleria.
  • $ a <> $ b: TRUE se $ a non è uguale a $ b dopo il tipo di giocoleria.
  • $ a! == $ b: TRUE se $ a non è uguale a $ b, o non sono dello stesso tipo.
  • $ a <$ b : TRUE se $ a è rigorosamente inferiore a $ b.
  • $ a> $ b : TRUE se $ a è strettamente superiore a $ 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 inferiore a, uguale ao maggiore di zero quando $ a è rispettivamente minore di, uguale o maggiore di $ b. Disponibile da PHP 7.
  • $ a? $ b: $ c : se $ a return $ b else return $ c ( operatore ternario )
  • $ a ?? $ c : come $ a? $ a: $ c ( operatore a coalescenza nulla - richiede PHP> = 7)

Operatori aritmetici:

  • - $ a : di fronte a $ a.
  • $ a + $ b : somma di $ a e $ b.
  • $ a - $ b : differenza tra $ a e $ b.
  • $ a * $ b : Prodotto di $ a e $ b.
  • $ a / $ b : Quoziente di $ a e $ b.
  • $ a% $ b : resto di $ a diviso per $ b.
  • $ a ** $ b : Risultato dell'aumento di $ a al potere di $ bth (introdotto in PHP 5,6)

Operatori incrementali / decrescenti:

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

Operatori bit a bit:

  • $ a & $ b : i bit impostati sia in $ a che in $ 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 sono impostati.
  • ~ $ a : i bit impostati in $ a non sono impostati e viceversa.
  • $ a << $ b : sposta i bit di $ a $ b passi a sinistra (ogni passaggio significa "moltiplica per due")
  • $ a >> $ b : sposta i bit di $ a $ b passi a destra (ogni passaggio significa "dividi per due")

Operatori di stringhe:

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

Operatori di array:

  • $ a + $ b : unione di $ a e $ 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 dello stesso tipo.
  • $ a! = $ b : TRUE 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 : come $ a = $ a + $ b
  • $ a - = $ b : come $ a = $ a - $ b
  • $ a * = $ b : come $ a = $ a * $ b
  • $ a / = $ b : come $ a = $ a / $ b
  • $ a% = $ b : come $ a = $ a% $ b
  • $ a ** = $ b : come $ a = $ a ** $ b
  • $ a. = $ b : come $ a = $ a. $ b
  • $ a & = $ b : come $ a = $ a & $ b
  • $ a | = $ b : come $ a = $ a | $ b
  • $ a ^ = $ b : come $ a = $ a ^ $ b
  • $ a << = $ b : come $ a = $ a << $ b
  • $ a >> = $ b : come $ a = $ a >> $ b

Nota

and operatore e / or operatore hanno 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.


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

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.


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


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


{} 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

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

Non è il nome più simpatico per un operatore, ma PHP 7 introduce la coalesce null molto 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 true e il terzo se non lo fa:

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

C'è anche una scorciatoia per ciò che ti permette di saltare il secondo elemento se è lo stesso del primo: echo $ count?: 10; // produce anche 10

In PHP 7 otteniamo anche il ?? L'operatore che invece di indicare una confusione estrema, ovvero il modo in cui userei solitamente due punti interrogativi, ci consente invece di mettere insieme una serie di valori. Leggendo da sinistra a destra, il primo valore che esiste e non è nullo è 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 in modo sicuro ricadendo su un dato valore predefinito se tale configurazione è mancante. È una specie di piccola funzionalità, ma è una che so che userò non appena le mie applicazioni passeranno a PHP 7.


Operatore coalescente Null (??)

Questo operatore è stato aggiunto in PHP 7.0 per il caso comune di dover utilizzare un operatore ternario insieme a isset() . Restituisce il suo primo operando se esiste e non è 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';
?>

Esistono molti modi per prevenire le iniezioni SQL e altri hack SQL. Puoi trovarlo facilmente su Internet (Ricerca Google). Ovviamente DOP è una delle buone soluzioni. Ma vorrei suggerirvi una buona prevenzione dei link da SQL Injection.

Che cos'è l'iniezione SQL e come prevenire

Manuale PHP per l'iniezione SQL

Spiegazione Microsoft di SQL injection e prevenzione in PHP

e altri come Preventing SQL injection con MySQL e PHP

Ora, perché è necessario impedire la query dall'iniezione SQL?

Vorrei farti sapere: Perché proviamo a prevenire l'SQL injection con un breve esempio qui sotto:

Query per la corrispondenza di autenticazione di accesso:

$query="select * from users where email='".$_POST['email']."' and password='".$_POST['password']."' ";

Ora, se qualcuno (un hacker) mette

$_POST['email']= [email protected]' OR '1=1

e password nulla ....

La query verrà analizzata nel sistema solo fino a:

$query="select * from users where email='[email protected]' OR '1=1';

L'altra parte verrà scartata. Quindi, cosa accadrà? Un utente non autorizzato (hacker) sarà in grado di accedere come amministratore senza avere la sua password. Ora, può fare tutto ciò che l'amministratore / persona email può fare. Vedi, è molto pericoloso se l'iniezione SQL non viene prevenuta.





php operators symbols php-5.3