Operator Bitowy

Co to jest bit? Bit jest reprezentacją 1 lub 0. Zasadniczo wyłączone(0) i włączone (1)

Co to jest bajt? Bajt składa się z 8 bitów, a najwyższa wartość bajtu to 255, co oznaczałoby, że każdy bit jest ustawiony. Przyjrzymy się, dlaczego maksymalna wartość bajtu wynosi 255.

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

Ta reprezentacja 1 bajtu

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

Kilka przykładów dla lepszego zrozumienia

Operator "i" : &

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

To wyświetli liczbę 8. Dlaczego? Cóż zobaczmy, używając naszego przykładu tabeli.

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

Więc widać z tabeli, że jedynym bitem, który dzielą razem, jest bit 8.

Drugi przykład

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

Dwa wspólne bity to 32 i 4, które po zsumowaniu zwracają 36.

Operator "Or": |

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

To daje liczbę 11. Dlaczego?

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

Zauważysz, że mamy ustawione 3 bity, w 8, 2 i 1 kolumny. Dodaj te: 8+2+1=11.

_ Alias dla gettext()

Znak podkreślenia ' _ ' jak w _() jest aliasem do gettext() funkcja.

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"

Stałe magiczne : chociaż nie są to tylko symbole, ale ważna część tej rodziny symboli. Istnieje osiem stałych magicznych, które zmieniają się w zależności od tego, gdzie są używane.

__LINE__: bieżący numer linii pliku.

__FILE__: pełna ścieżka i nazwa pliku. W przypadku użycia wewnątrz include zwracana jest nazwa dołączonego pliku. Od PHP 4.0.2, __FILE__ zawsze zawiera ścieżkę bezwzględną z rozwiązanymi dowiązaniami symbolicznymi, podczas gdy w starszych wersjach zawierała ścieżka względna w pewnych okolicznościach.

__DIR__: Katalog pliku. W przypadku użycia wewnątrz include zwracany jest katalog dołączonego pliku. Jest to równoważne dirname(__FILE__). Ta nazwa katalogu nie ma ukośnika końcowego, chyba że jest to katalog główny. (Dodano w PHP 5.3.0.)

__FUNCTION__: Nazwa funkcji. (Dodana w PHP 4.3.0) począwszy od PHP 5 ta stała zwraca nazwę funkcji tak, jak została zadeklarowana (rozróżnia wielkość liter). W PHP 4 jego wartość jest zawsze małe.

__CLASS__: Nazwa klasy. (Dodana w PHP 4.3.0) począwszy od PHP 5 ta stała zwraca nazwę klasy tak, jak została zadeklarowana (rozróżnia wielkość liter). W PHP 4 jego wartość jest zawsze mała. Nazwa klasy zawiera Przestrzeń nazw, w której została zadeklarowana (np. Foo\Bar). Zauważ, że od PHP 5.4 __CLASS__ działa również w traits. Gdy jest używana w metodzie trait, __CLASS__ jest nazwą klasy, w której dana cecha jest używana.

__TRAIT__: nazwa cechy. (Dodano w PHP 5.4.0) od wersji PHP 5.4 stała ta zwraca cecha tak jak została zadeklarowana(rozróżniana wielkość liter). Nazwa cechy Zawiera przestrzeń nazw, w której została zadeklarowana (np. Foo\Bar).

__METHOD__: nazwa metody klasy. (Dodane w PHP 5.0.0) nazwa metody jest zwracana tak, jak została zadeklarowana (rozróżniana wielkość liter).

__NAMESPACE__: nazwa bieżącej przestrzeni nazw (rozróżnia wielkość liter). Stała ta jest zdefiniowana w czasie kompilacji (dodana w PHP 5.3.0).

Źródło

<=> Operator Statku Kosmicznego

Dodany w PHP 7

Operator statku kosmicznego <=> jest najnowszym operatorem porównawczym dodanym w PHP 7. Jest operatorem binarnym Nie asocjacyjnym o takim samym pierwszeństwie jak operatory równości(==, !=, ===, !==). Operator ten pozwala na prostsze trójstronne porównanie operandów lewostronnych i prawostronnych.

Operator daje wyrażenie całkowite:

• 0 gdy obie operands are equal
• mniej niż 0 gdy operand lewostronny jest mniejszy niż operand prawostronny
• większe niż 0 gdy operand lewostronny jest większy niż operand prawostronny

Np.

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

Dobrym praktycznym zastosowaniem tego operatora byłoby wywołanie typu porównawczego, które oczekuje się, że zwróci zero, ujemną lub dodatnią liczbę całkowitą na podstawie trójstronnego porównania dwóch wartości. Funkcja porównywania przeszła do usort jest jednym z takich przykładów.

Przed PHP 7 piszesz...

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

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

Od PHP 7 można pisać...

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

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

Operatory Typu

instanceof jest używany do określenia, czy zmienna PHP jest instancyjnym obiektem pewnej klasy.

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

Powyższy przykład wyświetli:

bool(true)
bool(false)

Powód: powyższy przykład $a jest obiektem mclass, więc używaj tylko mclass danych, a nie instancji sclass

Przykład z dziedziczeniem

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

Powyższy przykład wyświetli:

bool(true)
bool(true)

Przykład z klonem

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

Powyższy przykład będzie wyjście:

bool(true)
bool(true)

Przegląd operatory w PHP:

Operatory Logiczne:

• $A && $B: TRUE jeśli obie $a i $B są prawdziwe.
• $A || $B: TRUE Jeśli albo $A albo $B jest prawdziwe.
• $a xor $B: TRUE Jeśli albo $A albo $b jest prawdziwe, ale nie oba.
• ! $a: TRUE Jeśli $a nie jest prawdą.
• $a i $B: TRUE jeśli obie $a i $B są prawdziwe.
• $A lub $b: TRUE Jeśli albo $A albo $b jest TRUE.

Operatory porównania:

• $A = = $B: TRUE Jeśli $a jest równe $B po typowaniu.
• $A = = = $B : TRUE Jeśli $a jest równe $B i są tego samego typu.
• $a != $B : TRUE Jeśli $a nie jest równe $B po typach.
• $A $b: TRUE Jeśli $a nie jest równe $B po typowaniu.
• $a != = $B: TRUE if $a nie jest równe $b lub nie są tego samego typu.
• $A : TRUE Jeśli $a jest ściśle mniejsze niż $b.
• $A > $B : TRUE Jeśli $a jest ściśle większa niż $b.
• $A : TRUE Jeśli $a jest mniejsze lub równe $b.
• $A > = $b : TRUE Jeśli $a jest większe lub równe $b.
• $A $b : liczba całkowita mniejsza, równa lub większa od zera, gdy $a jest odpowiednio mniejsza, równa lub większe niż $b. dostępne od PHP 7.
• $ a ? $b: $c : if $a return $B else return $c (operator Trójnik)
• $ a ?? $c : to samo co $a ? $a: $c (Operator koalescencji zerowej - wymaga PHP> = 7)

Operatory Arytmetyczne:

• - $a : przeciwieństwo $a.
• $A + $b : suma $a i $b.
• $A- $ b : różnica $a i $b.
• $A * $B : iloczyn $a i $b.
• $A / $B : iloraz $a i $b.
• $A % $b : reszta $a podzielona przez $b.
• W PHP 5.6 nie ma żadnych ograniczeń co do tego, czy w PHP 5.6 nie ma żadnych ograniczeń co do tego, czy w PHP 5.6 nie ma żadnych ograniczeń co do tego, czy w PHP 5.6 nie ma żadnych ograniczeń co do tego, czy w PHP 5.6 nie ma żadnych ograniczeń co do tego, czy w PHP 5.6 nie ma żadnych ograniczeń.]}

Operatory Zwiększające/Zmniejszające:

• ++$a : zwiększa $a o jeden, a następnie zwraca $a.
• $a++: Zwraca $a, następnie zwiększa $a o jeden.
• -- $a : zmniejsza $a o jeden, a następnie zwraca $a.
• $a--: Zwraca $a, a następnie zmniejsza $a o jeden.

Operatory Bitowe:

• $A & $b : ustawiane są bity w $a i $B.
• $A / $b : ustawiane są bity, które są ustawione w $a lub $B.
• $A ^ $b : bity, które są ustawione w $a lub $B, ale nie oba są ustawione.
• ~ $a : bity które są ustawione w $a nie są ustawione i vice versa.
• $A : przesunięcie bitów kroków $a $b w lewo (każdy krok oznacza "mnożenie przez dwa")
• $A > > $B : Przesuń bity kroków $a $b w prawo (każdy krok oznacza "podziel przez dwa")

Operatory Łańcuchowe:

• $a . $b : konkatenacja $a i $b.

Operatory Tablicy:

• $A + $b : Unia $a i $b.
• $A = = $B : TRUE Jeśli $a i $B mają te same pary klucz / wartość.
• $A = = = $B : TRUE Jeśli $a i $B mają te same pary klucz / wartość w tej samej kolejności i tego samego typu.
• $a != $b : TRUE Jeśli $a nie jest równe $b.
• $A $b : TRUE Jeśli $a nie jest równe $b.
• $a != = $b : TRUE Jeśli $a nie jest identyczne z $b.

Assignment Operatorzy:

• $A = $b : wartość $b jest przypisana do $a
• $A + = $ b : tak samo jak $A = $A + $ b
• $A - = $B : tak samo jak $A = $A - $ b
• $A * = $ b : tak samo jak $A = $a * $b
• $A / = $B : tak samo jak $A = $a / $b
• $A % = $ b : tak samo jak $A = $A % $b
• $A * * = $ b : tak samo jak $A = $a * * $b
• $a .= $b : tak samo jak $A = $a . $b
• $A &= $B : tak samo jak $A = $A & $b
• $A / = $B : tak samo jak $A = $a / $b
• $A ^ = $ b : tak samo jak $A = $a ^ $b
• $A : tak samo jak $A = $a
• $A > > = $b : tak samo jak $A = $A > > $b

Uwaga

and operator i Operator or mają niższy priorytet niż operator przypisania =.

Oznacza to, że $a = true and false; jest równoważne ($a = true) and false.

W większości przypadków prawdopodobnie będziesz chciał użyć && oraz ||, które zachowują się w sposób znany z języków takich jak C, Java czy JavaScript.

Operator statku kosmicznego <=> (Dodano w PHP 7)

Przykłady dla <=> operatora statku kosmicznego (PHP 7, źródło: Podręcznik PHP):

Liczby całkowite, pływaki, Łańcuchy, tablice i obiekty do trójdrożnego porównywania zmiennych.

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

{} klamry Kręcone

• klocki-kręcone szelki / no kręcone szelki?
• nawiasy klamrowe w łańcuchu w PHP
• PHP nawiasy klamrowe w notacji tablicy

I kilka słów o ostatnim poście

$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

Ciągi PHP: Ciągi PHP mogą być określone na cztery sposoby, a nie tylko na dwa sposoby:

1) Pojedyncze Ciągi Cytatów:

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

2) Podwójne Ciągi Cytatów:

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

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

Operator koalescencji zerowej (??)

Ten operator został dodany w PHP 7.0 w powszechnym przypadku konieczności użycia operatora trójdzielnego w połączeniu z isset(). Zwraca swój pierwszy operand, jeśli istnieje i nie jest NULL; w przeciwnym razie zwraca swój drugi operand.

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

Pytanie:

Co oznacza =>?

Odpowiedź:

=> jest symbolem, którego ludzie zdecydowali się użyć do oddzielenia "Key" => "Value" par w tablicach asocjacyjnych.

Aby to zrozumieć, musimy wiedzieć, czym są tablice asocjacyjne. Pierwszą rzeczą, która pojawia się, gdy konwencjonalny programista myśli o Tablicy (W PHP ), byłoby coś podobnego do:

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

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

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

Gdzie jak, jeśli my aby wywołać tablicę w jakiejś późniejszej części kodu, możemy zrobić:

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

Differences (between a sequential and associative array):

• Podczas deklaracji tablicy asocjacyjnej, nie tylko dołączasz value tego, co chcesz umieścić w tablicy, ale także umieszczasz wartość indeksu (zwaną key), której chcesz użyć podczas wywoływania tablicy w późniejszych częściach kodu. W deklaracji używana jest następująca składnia: "key" => "value".

• W przypadku użycia tablicy asocjacyjnej wartość key zostanie umieszczona wewnątrz indeksu tablicy, aby pobrać żądaną wartość value.

Na przykład:

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

I teraz, aby otrzymać to samo wyjście, co wcześniej, wartość key będzie używana w indeksie tablic:

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

PUNKT KOŃCOWY:

Więc od w powyższym przykładzie dość łatwo zauważyć, że symbol => jest używany do wyrażenia relacji tablicy asocjacyjnej pomiędzy każdą parą key i value w Tablicy podczas inicjacji wartości w tablicy.

Pytanie :

Co oznacza " & " w PHP?

Operator PHP " & "

& Zwykle ustawiane są bity, które są ustawione zarówno w $a, jak i $B.

Zauważyłeś w ogóle, jak działają te rozmowy?

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

Tak więc za wszystkim powyżej kryje się gra operatorów bitowych i bitów.

Jednym z użytecznych przypadków są proste konfiguracje, takie jak podaj poniżej, więc pojedyncze pole integer może przechowywać tysiące kombinacji dla Ciebie.

Większość ludzi już przeczytała dokumenty, ale nie określiła rzeczywistych przypadków użycia tych operatorów bitowych.

Przykład, który pokochasz

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

Operator zerowy (??) została dodana do PHP7 w powszechnym przypadku konieczności użycia trójnika w połączeniu z isset (). Zwraca swój pierwszy operand, jeśli istnieje i nie jest NULL, w przeciwnym razie zwraca swój drugi operand, taki jak Poniższy przykład:

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

== jest używany do sprawdzania równości bez biorąc pod uwagę zmienną typ danych

=== jest używany do sprawdzania równości dla zarówno zmiennej wartość * i * * typu danych

Przykład

$a = 5

1. if ($a == 5) - będzie oceniać na true

2. if ($a == '5') - obliczy wartość true, ponieważ podczas porównywania tej wartości php wewnętrznie konwertuje tę wartość na liczbę całkowitą, a następnie porównuje obie wartości

3. if ($a === 5) - będzie oceniać na true

4. if ($a === '5') - obliczy wartość false, ponieważ wartość 5, ale ta wartość 5 nie jest liczbą całkowitą.

Null coalesce operator "??"(Dodano w PHP 7)

Nie jest to najbardziej chwytliwa nazwa dla operatora, ale PHP 7 przynosi raczej poręczne koalesce null, więc pomyślałem, że podzielę się przykładem.

W PHP 5 mamy już operator trójkowy, który testuje wartość, a następnie zwraca drugi element, jeśli zwraca true, a trzeci, jeśli nie:

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

Istnieje również skrót tego, który pozwala pominąć drugi element, jeśli jest taki sam jak pierwszy: echo $count ?: 10; / / również wyświetla 10

W PHP 7 dodatkowo otrzymujemy ?? operator, który zamiast wskazywać skrajne zamieszanie, które jest jak zwykle używać dwóch znaków zapytania razem zamiast pozwala nam połączyć łańcuch wartości. Odczyt od lewej do prawej, pierwsza wartość, która istnieje i nie jest null jest wartością, która zostanie zwrócona.

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

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

Ten konstrukt jest przydatny do nadania priorytetu jednej lub większej liczbie wartości pochodzących być może z danych wejściowych użytkownika lub istniejącej konfiguracji, i bezpiecznie wraca do danej domyślnej, Jeśli tej konfiguracji nie ma. To trochę mała funkcja, ale wiem, że będę używać, gdy tylko moje aplikacje uaktualnią się do PHP 7.

Oto nazwy wszystkich operatorów PHP (TOKEN).

Odniesienie http://php.net/manual/en/tokens.php