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.

_ Alias ​​per gettext ()

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

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:

• Comprensione dell'incremento

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"