variable - reference function php




Référence-Que signifie ce symbole en PHP? (12)

Opérateur binaire

C'est quoi un peu? Un bit est une représentation de 1 ou 0. Fondamentalement, OFF (0) et ON (1)

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

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

Cette représentation de 1 octet

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

Quelques exemples pour une meilleure compréhension

L'opérateur "AND": &

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

Cela produirait le nombre 8. Pourquoi? Eh bien voyons en utilisant 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|
------------------------------------------- 

Vous pouvez donc voir sur la table que le seul bit qu'ils partagent ensemble est le bit 8.

Deuxième exemple

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

Les deux bits partagés sont 32 et 4, qui, une fois ajoutés, renvoient 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 définis, dans les colonnes 8, 2 et 1. Additionnez-les: 8 + 2 + 1 = 11.

Qu'est-ce que c'est?

Ceci est une collection de questions qui reviennent de temps en temps sur la syntaxe en PHP. C’est aussi un wiki de la communauté, donc tout le monde est invité à participer au maintien de cette liste.

Pourquoi est-ce?

Auparavant, il était difficile de trouver des questions sur les opérateurs et les autres jetons de syntaxe.¹
L'idée principale est d'avoir des liens vers des questions existantes sur Stack Overflow, afin de nous permettre de les référencer plus facilement, sans copier le contenu du manuel PHP.

¹ Remarque: depuis janvier 2013, Stack Overflow prend en charge les caractères spéciaux . Entourez simplement les termes de recherche entre guillemets, par exemple [php] "==" vs "==="

Que dois-je faire ici?

Si quelqu'un vous a indiqué ici parce que vous avez posé une telle question, veuillez trouver la syntaxe particulière ci-dessous. Les pages liées au manuel PHP ainsi que les questions liées répondront probablement à votre question à ce moment-là. Si tel est le cas, vous êtes invité à relire la réponse. Cette liste ne vise pas à remplacer l'aide fournie par les autres.

La liste

Si votre jeton ne figure pas dans la liste ci-dessous, vous pouvez le trouver dans la liste des jetons d’analyseur .

Opérateurs ou References niveau du bit

=& References

&= Opérateurs sur les bits

&& Opérateurs logiques

% opérateurs arithmétiques

!! Opérateurs logiques

@ Opérateurs de contrôle d'erreur

?: Opérateur ternaire

?? Opérateur NULL Coalesce (depuis PHP 7)

: Syntaxe alternative pour les structures de contrôle , opérateur ternaire

:: Opérateur de résolution de portée

\ Namespaces

-> Classes Et Objets

=> Arrays

^ Opérateurs bit à bit

>> Opérateurs bit à bit

<< Opérateurs de bits

<<< Heredoc ou Nowdoc

= Opérateurs d'assignation

== Opérateurs de comparaison

=== Opérateurs de comparaison

!== Opérateurs de comparaison

!= Opérateurs de comparaison

<> Opérateurs de comparaison

<=> Opérateurs de comparaison (depuis PHP 7.0)

  • Opérateur de vaisseau spatial (comparaison à trois voies)

| Opérateurs de bits

|| Opérateurs logiques

~ Opérateurs de bits

+ Opérateurs arithmétiques , Opérateurs de tableaux

+= et -= opérateurs d'assignation

++ et -- Opérateurs d'incrémentation / décrémentation

.= Opérateurs d'assignation

. Opérateurs de cordes

, Arguments de fonction

, Déclarations variables

$$ variables variables

` exécution

<?= Tags ouverts courts

[] Arrays (syntaxe courte depuis PHP 5.4)

<? Balises d'ouverture et de fermeture

... Déballage des arguments (depuis PHP 5.6)

** Exponentiation (depuis PHP 5.6)

# Commentaire en ligne de commande


Opérateurs de type

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 de la mclass . mclass données mclass , pas une instance de la sclass

Exemple avec héritage

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

<=> Opérateur de vaisseau spatial

Ajouté en PHP 7

L' opérateur de vaisseau spatial <=> est le dernier opérateur de comparaison ajouté en PHP 7. Il s'agit d'un opérateur binaire non associatif ayant la même priorité que les opérateurs d'égalité ( == != , === !== ). Cet opérateur permet une comparaison tridirectionnelle plus simple entre les opérandes gauche et droit.

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

  • 0 lorsque les deux opérandes sont égaux
  • Inférieur à 0 lorsque l'opérande gauche est inférieur à l'opérande droit
  • Supérieur à 0 lorsque l'opérande gauche est supérieur à l'opérande droit

par exemple

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

Une bonne application pratique de l'utilisation de cet opérateur serait dans les rappels de type comparaison censés renvoyer un entier zéro, négatif ou positif basé sur une comparaison à trois voies entre deux valeurs. La fonction de comparaison transmise à usort 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;
});

Opérateur de vaisseau spatial <=> (ajouté en PHP 7)

Exemples pour <=> opérateur de vaisseau spatial (PHP 7, Source: Manuel PHP):

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

==est utilisé pour vérifier l'égalité sans prendre en compte le type de données variable

===est utilisé pour l' égalité de contrôle pour les deux la variable valeur * et ** type de données

Exemple

$a = 5

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

  2. if ($a == '5') - sera évalué à true, car en comparant cette valeur, php convertit en interne cette valeur de chaîne en entier, puis compare les deux valeurs

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

  4. if ($a === '5') - sera évalué à false, car la valeur est 5, mais cette valeur 5 n'est pas un entier.



Incrémentation / décrémentation des opérateurs

++ opérateur incrément

-- opérateur de décrémentation

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.

Ceux-ci peuvent aller avant ou après la variable.

Si elle est placée avant la variable, l'opération d'incrémentation / décrémentation est effectuée sur la variable puis le résultat est renvoyé. Si elle est placée après la variable, la variable est d' abord renvoyée, puis l'opération d'incrémentation / décrémentation est effectuée.

Par exemple:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Exemple en direct

Dans le cas ci-dessus, ++$i est utilisé car il est plus rapide. $i++ aurait les mêmes résultats.

La pré-incrémentation est un peu plus rapide car elle incrémente réellement la variable et après elle "retourne" le résultat. La post-incrémentation crée une variable spéciale, y copie la valeur de la première variable et remplace celle-ci uniquement après l'utilisation de la première.

Cependant, vous devez utiliser $apples-- , puisque vous voulez d’abord afficher le nombre actuel de pommes, puis vous voulez en soustraire une.

Vous pouvez également incrémenter des lettres en PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Une fois que z est atteint, aa est le suivant, et ainsi de suite.

Notez que les variables de caractère peuvent être incrémentées mais pas décrémentées. Néanmoins, seuls les caractères ASCII ordinaires (az et AZ) sont pris en charge.

Messages de débordement de pile:


Chaînes PHP: Les chaînes PHP peuvent être spécifiées de quatre manières différentes:

1) Chaînes de devis simples:

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

2) Cordes à double 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 Coalesce Operator php

L'opérateur de coalescence nul (??) a été ajouté à PHP7 pour le cas habituel d'utilisation d'un ternaire avec isset (). Il retourne son premier opérande s'il existe et n'est pas NULL, sinon, il retourne son deuxième opérande, comme dans l'exemple suivant:

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

Opérateur de coalescence nul (??)

Cet opérateur a été ajouté dans PHP 7.0 pour le cas habituel d'utilisation d'un opérateur ternaire avec isset() . Il retourne son premier opérande s'il existe et n'est pas NULL ; sinon, il retourne son deuxième 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 "&" ici en PHP?

Opérateur PHP "&"

Facilite la vie une fois que nous nous y sommes habitués .. (vérifiez l'exemple ci-dessous avec soin)

& vérifie généralement les bits définis dans $ a et $ b sont définis.

Avez-vous même 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 se cache un jeu d’opérateurs et de bits.

Un cas utile parmi ceux-ci est la configuration simple comme celle donnée ci-dessous, de sorte qu'un seul champ entier peut stocker des milliers de combinaisons pour vous.

La plupart des gens ont déjà lu la documentation, mais n'ont pas précisé le cas d'utilisation réel de ces opérateurs au niveau des bits.

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

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