Opérateur Bitwise

qu'est Ce qu'un peu? Un bit est une représentation de 1 ou 0. Fondamentalement OFF(0) et(1)

qu'est Ce qu'un octet? Un octet est composé de 8 bits et la valeur la plus élevée d'un octet est 255, ce qui signifie que chaque bit est défini. Nous verrons pourquoi la valeur maximale d'un octet est de 255.

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

Cette représentation de 1 Byte

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

quelques exemples pour mieux comprendre

L'opérateur "ET": &

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

cela produirait le nombre 8. Pourquoi? Bien, voyons comment utiliser notre exemple de table.

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

donc vous pouvez voir de la table le seul peu qu'ils partagent ensemble est le 8 bit.

Second exemple

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

les deux les bits partagés sont 32 et 4, qui une fois additionnés rendent 36.

L'opérateur "Ou": |

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

cela produirait le nombre 11. Pourquoi?

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

, Vous remarquerez que nous avons 3 bits, 8, 2, et 1 colonnes. Additionnez ceux-ci: 8+2+1=11.

_ Alias pour gettext()

le caractère de soulignement" _ "comme dans _() est un alias de la fonction" 1519100920 gettext() .

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"

constantes magiques : bien que ce ne soient pas seulement des symboles, mais une partie importante de cette famille de symboles. Il y a huit constantes magiques qui changent selon l'endroit où ils sont utilisés.

__LINE__ : le numéro de ligne courant du fichier.

__FILE__ : le chemin complet et le nom du fichier. Si utilisé dans une include, le nom du fichier inclus est retourné. Depuis PHP 4.0.2, __FILE__ contient toujours un chemin absolu avec symlinks résolu alors que dans les versions plus anciennes il contenait un chemin relatif dans certaines circonstances.

__DIR__ : Le répertoire du fichier. S'il est utilisé dans une include, le répertoire du fichier inclus est retourné. Cela équivaut à dirname(__FILE__) . Ce nom de répertoire n'a pas de barre oblique, sauf s'il s'agit du répertoire racine. (Ajouté en PHP 5.3.0.)

__FUNCTION__ : le nom de la fonction. (Ajouté en PHP 4.3.0) à partir de PHP 5 cette constante renvoie le nom de la fonction telle qu'elle a été déclarée (sensible à la casse). En PHP 4, sa valeur est toujours plus faible.

__CLASS__ : le nom de la classe. (Ajouté en PHP 4.3.0) à partir de PHP 5 cette constante renvoie le nom de classe tel qu'il a été déclaré (sensible à la casse). En PHP 4, sa valeur est toujours plus faible. Le nom de classe inclut l'espace de nom dans lequel il a été déclaré (par exemple Foo\Bar ). Notez qu'à partir de PHP 5.4 __CLASS__ fonctionne aussi dans les traits. Lorsque utilisé dans un trait la méthode __CLASS__ est le nom de la classe le trait est utilisé dans.

__TRAIT__ : le nom du trait. (Ajouté en PHP 5.4.0) à partir de PHP 5.4 cette constante renvoie le trait tel qu'il a été déclaré (sensible à la casse). Le nom du trait inclut l'espace de nom dans lequel il a été déclaré (par exemple Foo\Bar ).

__METHOD__ : le nom de la méthode de la classe. (Ajouté en PHP 5.0.0) le nom de la méthode est retourné tel qu'il a été déclaré (sensible à la casse).

__NAMESPACE__ : Le nom de l'espace de noms courant (sensible à la casse). Cette constante est définie dans le temps de compilation (ajouté en PHP 5.3.0).

Source

<=> Conducteur De Vaisseau Spatial

ajouté en PHP 7

le spaceship operator <=> est le dernier opérateur de comparaison ajouté en PHP 7. C'est un non-associatif opérateur binaire avec la même priorité que les opérateurs d'égalité( == , != , === , !== ). Cet opérateur permet de plus simple comparaison à trois entre gauche et de la main droite opérandes.

l'opérateur résulte en une expression entière de:

• 0 lorsque les deux opérandes sont égales
• inférieure à 0 lorsque l'opérande de gauche est inférieure à l'opérande de droite
• supérieure à 0 lorsque l'opérande de gauche est supérieure à l'opérande de droite

p.ex.

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

une bonne application pratique de l'utilisation de cet opérateur serait en comparaison des callbacks de type qui sont censés retourner un entier zéro, négatif, ou positif basé sur une comparaison à trois sens entre deux valeurs. La fonction de comparaison passée à usort en est un exemple.

Avant PHP 7 vous écririez...

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

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

depuis PHP 7, vous pouvez écrire...

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

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

instanceof est utilisé pour déterminer si une variable PHP est un objet instancié d'une certaine classe.

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

l'exemple ci-dessus affichera:

bool(true)
bool(false)

raison: exemple ci-dessus $a est un objet du mclass ainsi utiliser seulement un mclass données non instance de avec le sclass

exemple avec héritage 1519220920"

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

l'exemple ci-dessus affichera:

bool(true)
bool(true)

exemple avec Clone

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

l'exemple ci-dessus affichera:

bool(true)
bool(true)

Un aperçu de opérateurs en PHP :

Opérateurs Logiques:

• $A & & $b : vrai si les deux $a et $b sont vrais.
• $a || $b : TRUE si $a ou $b est VRAI.
• $a xor $b: TRUE if soit $a soit $b est vrai, mais pas les deux.
• ! $ a : vrai si $a n'est pas vrai.
• $A et $b: vrai si les deux $a et $b sont vrais.
• $a ou $b: vrai si $a ou $b est vrai.

opérateurs de comparaison:

• $a == $b: vrai si $a est égal à $b après jonglage de type.
• $a === $b: vrai si $a est égal à $b, et ils sont du même type.
• $a != $b : TRUE si $a n'est pas égal à $b après jonglage de type.
• $ < > $b : TRUE si $a est égal à $b après le type de jonglage.
• $a != = $b : TRUE si $a est égal à $b, ou ils ne sont pas du même type.
• $a < $b : vrai si $a est strictement inférieur à $B.
• $a > $b : vrai si $a est strictement supérieur à $B.
• $a <= $b : vrai si $a est inférieur ou égal à $B.
• $a >= $b : vrai si $a est supérieur ou égal à $ B.
• $a <=> $b : Un entier inférieur, égal ou supérieur à zéro lorsque $a est respectivement inférieure, égale, ou supérieure à $b. Disponible depuis PHP 7.
• $a ? $b : $c : si $retour, $b else return $c ( opérateur ternaire )
• $a ?? $ c : pareil que $a ? $a: $ c ( null coalescence opérateur - nécessite PHP>=7)

Opérateurs Arithmétiques:

• -$a : à L'opposé de $A.
• $a + $b : somme de $A et $B.
• $a - $b : différence de $A et de $B.
• $a * $ b : produit de $A et $B.
• $a / $b : Quotient de $A et $B.
• $a % $b : reste de $a divisé par $B.
• $a ** $b : résultat de l'augmentation de $A à la puissance $B (introduit en PHP 5.6)

Opérateurs D'Incrémentation / Décrémentation:

• ++$a : incréments $a par un, puis renvoie $a.
• $a++ : renvoie $a, Puis augmente $a par un.
• --$a : Décrémente $un par un, puis retourne $a.
• $a-- : renvoie $A, puis décrémente $a par un.

Opérateurs Bitwise:

• $A & $B : les Bits qui sont définis en $a et $b sont définis.
• $a | $b : les Bits qui sont définis en $a ou $B sont définis.
• $a ^ $b : Bits qui sont définis en $a ou $B mais pas les deux.
• ~ $ : Bits qui sont définies dans $a ne sont pas définis, et vice versa.
• $a << $b : déplacer les bits de $ A $ B pas vers la gauche (chaque pas signifie "multiplier par deux")
• $a >> $b : déplacer les bits de $A $B pas à droite (chaque pas signifie" diviser par deux")

Opérateurs De Chaîne:

• $un . $ b : concaténation de $ A et $B.

Opérateurs De Réseau:

• $A + $b : Union de $ A et $B.
• $a == $b : vrai si $A et $b ont les mêmes paires clé/valeur.
• $a === $b : TRUE si $A et $b ont les mêmes couples clé/valeur dans le même ordre et du même type.
• $a != $ b : vrai si $a n'est pas égal à $B.
• $a <> $b : vrai si $a n'est pas égal à $B.
• $a != = $b : vrai si $a n'est pas identique à $ B.

Opérateurs D'Affectation:

• $a = $b : la valeur de $b est attribuée à $ a
• $a + = $b : identique à $A = $A + $B
• $a - = $b : identique à $A = $A - $B
• $a *= $b : identique à $A = $a * $B
• $a / = $b : identique à $a = $A / $ B
• $a %= $b : identique à $a = $a % $ b
• $a * * = $b : identique à $A = $A ** $B
• $un .= $b : identique à $A = $ a. $b
• $a & = $b : identique à $A = $A & $B
• $a / = $b : identique à $a = $A / $ B
• $a ^= $b : identique à $A = $ A ^ $ B
• $a < < = $b : identique à $A = $A < < < $B
• $a > > = $b : identique à $A = $A >> $B

Note

and et or ont une priorité inférieure à celle de l'opérateur d'affectation = .

cela signifie que $a = true and false; est équivalent à ($a = true) and false .

dans la plupart des cas, vous probablement vouloir utiliser && et || , qui se comportent d'une manière connue des langages comme C, Java ou JavaScript.

Spaceship Operator <=> (ajouté en PHP 7)

exemples pour <=> Spaceship operator (PHP 7, Source: PHP Manual):

entiers, flotteurs, chaînes, Tableaux et objets pour la comparaison à trois voies des variables.

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

{} accolades

• Blocs - accolades/pas d'accolades?
• broches bouclées en chaîne en PHP
• PHP accolades dans la notation de tableau

Et quelques mots sur le dernier 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

Chaînes de PHP: Les chaînes de caractères PHP peuvent être spécifiées de quatre façons et pas seulement de deux façons:

1) Chaîne De Citation Simple:

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

2) Double Chaîne De Citation:

$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 (depuis PHP 5.3.0):

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

Null coalescence de l'opérateur (??)

cet opérateur a été ajouté en PHP 7.0 pour le cas courant d'utilisation d'un opérateur ternaire en conjonction avec isset() . Il renvoie son premier opérande s'il existe et n'est pas NULL , sinon il renvoie son second opérande.

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

QUESTION:

que signifie => ?

réponse:

=> est le symbole que nous, les humains, avons décidé d'utiliser pour séparer les paires "Key" => "Value" dans les tableaux associatifs.

elaboration:

pour comprendre cela, nous devons savoir ce qui associatif Les tableaux sont. La première chose qui se présente lorsqu'un programmeur conventionnel pense à un tableau ( en PHP ) serait quelque chose de similaire à:

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

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

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

où comme, si nous voulions appeler le tableau dans une partie ultérieure du code, nous pourrions faire:

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

pour l'instant tout va bien. Cependant, en tant qu'humains, nous pourrions trouver difficile de se rappeler que l'index [0] du tableau est la valeur de année 2016, l'index [1] du tableau est un salutations , et l'index [2] du tableau est un simple valeur entière . La solution que nous aurions alors est d'utiliser ce qu'on appelle un Tableau Associatif . Un tableau associatif a quelques différences par rapport à un tableau séquentiel ( ce qui est ce que les cas précédents étaient puisqu'ils incrémentent l'indice utilisé dans une séquence prédéterminée, en incrémentant de 1 pour chaque valeur suivante ).

Différences ( entre un séquentielle et tableau associatif ):

• lors de la déclaration D'un tableau associatif, vous n'incluez pas seulement le value de ce que vous voulez mettre dans le tableau, mais vous mettez aussi la valeur d'index (appelée le key ) que vous voulez utiliser lorsque vous appelez le tableau dans les parties ultérieures du code. La syntaxe suivante est utilisée lors de sa déclaration: "key" => "value" .

• lors de l'utilisation du tableau associatif, la valeur key serait alors placée à l'intérieur de l'index du tableau pour récupérer le value désiré .

par exemple:

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

et maintenant, pour recevoir la même sortie qu'avant, la valeur key serait utilisée dans l'index des tableaux:

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

DERNIER POINT:

donc à partir de l'exemple ci-dessus, il est assez facile de voir que le symbole => est utilisé pour exprimer la relation d'un tableau associatif entre chacune des paires key et value dans un tableau pendant l'initiation des valeurs dans le tableau.

Question :

Quoi "&" signifie ici en PHP?

PHP "&" opérateur

Rend la vie plus facile une fois que nous y habituer..(cochez soigneusement l'exemple ci-dessous)

& habituellement, les bits de vérification qui sont définis à la fois dans $A et $b sont définis.

avez-vous remarqué comment ces appels fonctionnent?

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

donc derrière tout ce qui précède est jeu d'opérateur bitwise et bits.

un cas utile de ces Est des configurations faciles comme donner ci-dessous, de sorte qu'un seul champ entier Peut stocker des milliers de combos pour vous.

la plupart des gens ont déjà lu les docs mais n'ont pas relayé le cas d'utilisation réelle de ces opérateurs bitwise.

exemple que vous allez aimer

<?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 Fusionnent Opérateur php

le nul de La coalescence de l'opérateur (??) a été ajouté au PHP7 pour le cas courant de la nécessité d'utiliser un ternaire en conjonction avec isset(). Il renvoie son premier opérande s'il existe et n'est pas NULL sinon il renvoie son second opérande, tel que l'exemple suivant:

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

== est utilisé pour vérifier l'égalité sans compte tenu de la variable type de données

=== est utilisé pour vérifier l'égalité pour les les deux , la variable valeur* et **type de données

exemple

$a = 5

1. if ($a == 5) - va évaluer à vrai

2. if ($a == '5') - va évaluer à true, parce que tout en comparant Cette à la fois valeur php en interne convertir cette valeur de chaîne de caractères en entier et ensuite comparer les deux valeurs

3. if ($a === 5) - évaluera à vrai

4. if ($a === '5') - va évaluer à false, parce que la valeur est 5, mais cette valeur 5 n'est pas un entier.

Null Fusionnent opérateur "??"(Ajouté en PHP 7)

N'est pas le nom le plus accrocheur pour un opérateur, mais PHP 7 apporte la coalesce nulle assez pratique alors j'ai pensé que je partagerais un exemple.

en PHP 5, nous avons déjà un opérateur ternaire, qui teste une valeur, puis renvoie le deuxième élément si cela renvoie true et le troisième si ce n'est pas le cas:

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

Il ya aussi un raccourci pour ce qui vous permet de sauter le deuxième élément si c'est le même que le premier: echo $count ?: 10; // également sorties 10

en PHP 7 nous obtenons en outre le ?? l'opérateur qui, au lieu d'indiquer une confusion extrême, ce qui est la façon dont j'utiliserais habituellement deux points d'interrogation ensemble, nous permet plutôt d'enchaîner une chaîne de valeurs. En lisant de gauche à droite, la première valeur qui existe et n'est pas null, la valeur qui sera retournée.

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

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

cette construction est utile pour donner la priorité à une ou plusieurs valeurs provenant peut-être de l'entrée de l'utilisateur ou de la configuration existante, et tomber en toute sécurité sur un défaut donné si cette configuration est manquante. C'est une sorte de petite fonctionnalité, mais c'est une que je sais que je vais utiliser dès que mes applications de mise à niveau à PHP 7.

Voici les noms de tous les opérateurs PHP (TOKEN).

référence http://php.net/manual/en/tokens.php