terug
x or y Of trueals een van x of y trueis. Als x=6, y=3 dan
(x < 10 or y > 10)retourneert true x || y Of trueals een van x of y trueis. Als x=6, y=3 dan
(x < 3 || y > 1)retourneert true a . b Aaneenschakeling Voeg twee strings samen: “Hi” . “Ha”

Antwoord 6, autoriteit 20%

Magische constanten: hoewel dit niet alleen symbolen zijn, maar een belangrijk onderdeel van deze tokenfamilie. Er zijn acht magische constanten die veranderen afhankelijk van waar ze worden gebruikt.

__LINE__: Het huidige regelnummer van het bestand.

__FILE__: Het volledige pad en de bestandsnaam van het bestand. Indien gebruikt in een include, wordt de naam van het opgenomen bestand geretourneerd. Sinds PHP 4.0.2 bevat __FILE__altijd een absoluut pad met opgeloste symlinks, terwijl het in oudere versies onder bepaalde omstandigheden een relatief pad bevatte.

__DIR__: De map van het bestand. Indien gebruikt in een include, wordt de directory van het opgenomen bestand geretourneerd. Dit komt overeen met dirname(__FILE__). Deze mapnaam heeft geen schuine streep aan het einde, tenzij het de hoofdmap is. (Toegevoegd in PHP 5.3.0.)

__FUNCTION__: De functienaam. (Toegevoegd in PHP 4.3.0) Vanaf PHP 5 retourneert deze constante de functienaam zoals deze is gedeclareerd (hoofdlettergevoelig). In PHP 4 is de waarde altijd in kleine letters.

__CLASS__: De klassenaam. (Toegevoegd in PHP 4.3.0) Vanaf PHP 5 retourneert deze constante de klassenaam zoals deze is gedeclareerd (hoofdlettergevoelig). In PHP 4 is de waarde altijd in kleine letters. De klassenaam bevat de naamruimte waarin deze is gedeclareerd (bijvoorbeeld Foo\Bar). Merk op dat vanaf PHP 5.4 __CLASS__ook in traits werkt. Bij gebruik in een eigenschapsmethode is __CLASS__de naam van de klasse waarin de eigenschap wordt gebruikt.

__TRAIT__: de eigenschapnaam. (Toegevoegd in PHP 5.4.0) Vanaf PHP 5.4 retourneert deze constante de eigenschap zoals deze is gedeclareerd (hoofdlettergevoelig). De eigenschapnaam bevat de naamruimte waarin deze is gedeclareerd (bijv. Foo\Bar).

__METHOD__: De naam van de klassemethode. (Toegevoegd in PHP 5.0.0) De naam van de methode wordt geretourneerd zoals deze is gedeclareerd (hoofdlettergevoelig).

__NAMESPACE__: de naam van de huidige naamruimte (hoofdlettergevoelig). Deze constante wordt gedefinieerd tijdens het compileren (toegevoegd in PHP 5.3.0).

Bron

Antwoord 7, autoriteit 13%

Type operators

instanceofwordt gebruikt om te bepalen of een PHP-variabele een geïnstantieerd object van een bepaalde klasse is.

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

Het bovenstaande voorbeeld geeft het volgende weer:

bool(true)
bool(false)

Reden:Bovenstaand voorbeeld $ais een object van de mclassdus gebruik alleen een mclassdata niet instantie van met de sclass

Voorbeeld met overerving

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

Het bovenstaande voorbeeld geeft het volgende weer:

bool(true)
bool(true)

Voorbeeld met kloon

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

Het bovenstaande voorbeeld geeft het volgende weer:

bool(true)
bool(true)

Antwoord 8, autoriteit 12%

Een overzicht van operators in PHP:

Logische operators:

• $a && $b :WAAR als zowel $a als $b WAAR zijn.
• $a || $b :WAAR als $a of $b WAAR is.
• $a xor $b :WAAR als $a of $b WAAR is, maar niet beide.
• ! $a :WAAR als $a niet WAAR is.
• $a en $b :WAAR als zowel $a als $b WAAR zijn.
• $a of $b :WAAR als $a of $b WAAR is.

Vergelijkende operators:

• $a == $b :WAAR als $a gelijk is aan $b na jongleren met typen.
• $a === $b :WAAR als $a gelijk is aan $b, en ze van hetzelfde type zijn.
• $a != $b :WAAR als $a niet gelijk is aan $b na het typen van jongleren.
• $a <> $b :TRUE als $a niet gelijk is aan $b na het jongleren met typen.
• $a !== $b :WAAR als $a niet gelijk is aan $b, of niet van hetzelfde type is.
• $a < $b: TRUE als $a strikt kleiner is dan $b.
• $a > $b: TRUE als $a strikt groter is dan $b.
• $a <= $b: WAAR als $a kleiner is dan of gelijk is aan $b.
• $a >= $b: WAAR als $a groter is dan of gelijk is aan $b.
• $a <=> $b: Een geheel getal kleiner dan, gelijk aan of groter dan nul wanneer $a respectievelijk kleiner dan, gelijk aan of groter dan $b is. Beschikbaar vanaf PHP 7.
• $a ? $b : $c: als $a retourneert $b anders $c retour (ternaire operator)
• $a ?? $c: Hetzelfde als $a ? $a : $c (nulcoalescentie operator– vereist PHP>=7)

Rekenkundige operatoren:

• -$a: Tegenovergestelde van $a.
• $a + $b: Som van $a en $b.
• $a – $b: Verschil van $a en $b.
• $a * $b: Product van $a en $b.
• $a / $b: Quotiënt van $a en $b.
• $a % $b: Rest van $a gedeeld door $b.
• $a ** $b: Resultaat van het verhogen van $a tot de macht $b’th (geïntroduceerd in PHP 5.6)

operators verhogen/verlagen:

• ++$a: Verhoogt $a met één en retourneert vervolgens $a.
• $a++: Retourneert $a en verhoogt vervolgens $a met één.
• –$a: Verlaagt $a met één en retourneert vervolgens $a.
• $a–: Retourneert $a en verlaagt vervolgens $a met één.

Bitwise-operators:

• $a & $b: Bits die zowel in $a als $b zijn ingesteld, worden ingesteld.
• $a | $b: Bits die zijn ingesteld in $a of $b worden ingesteld.
• $a ^ $b: Bits die zijn ingesteld op $a of $b, maar niet beide.
• ~ $a: Bits die zijn ingesteld in $a zijn niet ingesteld en vice versa.
• $a << $b: verschuif de bits van $a $b stappen naar links (elke stap betekent “vermenigvuldigen met twee”)
• $a >> $b: verschuif de bits van $a $b stappen naar rechts (elke stap betekent “delen door twee”)

String-operators:

• $a . $b: Aaneenschakeling van $a en $b.

array operators:

• $ A + $ B : Unie van $ A en $ B.
• $ A == $ B : TRUE Als $ A en $ B dezelfde sleutel / waardeparen hebben.
• $ A === $ B : TRUE Als $ A en $ B dezelfde sleutel / waardeparen in dezelfde volgorde en van dezelfde typen hebben.
• $ A! = $ B : TRUE Als $ A niet gelijk is aan $ b.
• $ A & LT; & GT; $ B : TRUE Als $ A niet gelijk is aan $ b.
• $ A! == $ B : TRUE Als $ A niet identiek is aan $ b.

Toewijzingsoperators:

• $ A = $ B : de waarde van $ B is toegewezen aan $ A
• $ A + = $ B : hetzelfde als $ A = $ A + $ B
• $ A – = $ B : hetzelfde als $ A = $ A – $ B
• * $ A = $ B : Hetzelfde als $ A = $ A * $ B
• $ A / = $ B : hetzelfde als $ A = $ A / $ B
• $ A% = $ B : hetzelfde als $ A = $ A% $ B
• ** $ A = $ B : hetzelfde als $ A = $ A ** $ B
• $ a. = $ B : hetzelfde als $ A = $ A. $ b
• $ A & amp; = $ B : hetzelfde als $ A = $ A & AMP; $ b
• $ A | = $ B : hetzelfde als $ A = $ A | $ b
• $ A ^ = $ B : hetzelfde als $ A = $ A ^ $ B
• $ a & lt; & lt; = $ b : hetzelfde als $ A = $ a & lt; & lt; $ b
• $ A & GT; & GT; = $ B : hetzelfde als $ A = $ A & GT; & GT; $ b
• $ a ?? = $ B : de waarde van $ B is toegewezen aan $ a als $ a null of niet gedefinieerd (null coalescing toewijzingsoperator – vereist PHP & GT; = 7.4)

Opmerking

De operator

anden de operator orhebben een lagere prioriteit dan de operator voor toewijzing =.

Dit betekent dat $a = true and false;gelijk is aan ($a = true) and false.

In de meeste gevallen wil je waarschijnlijk &&en ||gebruiken, die zich gedragen op een manier die bekend is uit talen als C, Java of JavaScript.

Antwoord 9, autoriteit 9%

Ruimteschipoperator <=>(toegevoegd in PHP 7)

Voorbeelden voor <=>ruimteschipoperator (PHP 7, Bron: PHP-handleiding):

Gehele getallen, drijvers, strings, arrays & objecten voor vergelijking van variabelen in drie richtingen.

// 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
// Comparison is case-sensitive
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

10, Autoriteit 6%

{}krullende beugels

• blokken – krullende beugels / geen krullende beugels?
• krullende beugels in touw in PHP
• PHP krullende beugels in array notatie

en sommige woorden over laatste bericht

$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

11, Autoriteit 6%

null coalescing operator (??)

Deze operator is toegevoegd in PHP 7,0 voor het gemeenschappelijk geval van het gebruiken van een ternaire operator in combinatie met isset(). Het retourneert zijn eerste operand als deze bestaat en niet nullis; Anders retourneert het zijn tweede 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';
?>

12, Autoriteit 5%

PHP-snaren:
PHP-snaren kunnen op vier manieren worden vermeld, niet slechts twee manieren:

1) Single Quote Snings:

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

2) Dubbele quote strings:

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

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

Antwoord 13, autoriteit 3%

Vraag:

Wat betekent “&” bedoel je hier in PHP?

PHP “&” operator

Maakt het leven gemakkelijker als we er eenmaal aan gewend zijn..(bekijk het voorbeeld hieronder zorgvuldig)

&controleert meestal of bits die zijn ingesteld in zowel $a als $b zijn ingesteld.

Is het je wel eens opgevallen hoe deze oproepen werken?

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

Dus achter al het bovenstaande is een spel van bitsgewijze operator en bits.

Een handig voorbeeld hiervan zijn eenvoudige configuraties zoals hieronder, dus een enkel integer veld kan duizenden combo’s voor je opslaan.

De meeste mensen hebben de documenten al gelezen, maar vertrouwden niet op de praktijk van deze bitsgewijze operators.

Voorbeeld waar je dol op zult zijn

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

14, Autoriteit 3%

==wordt gebruikt voor controle gelijkheid zonder overwegend variabele gegevenstype

===wordt gebruikt voor controle gelijkheid voor zowel de variabele waarde en gegevenstype

Voorbeeld

$a = 5

1. if ($a == 5)– zal evalueren naar true

2. if ($a == '5')– zal evalueren naar TRUE, want terwijl u dit beide waarde PHP vergelijkt, converteert intern die stringwaarde in gehele getal en vervolgens beide waarden vergelijken

3. if ($a === 5)– zal evalueren naar true

4. if ($a === '5')– evalueert onwaar, omdat de waarde 5 is, maar deze waarde 5 is geen geheel getal.

Antwoord 15, autoriteit 2%

Null Coalesce-operator “???” (Toegevoegd in PHP 7)

Niet de meest pakkende naam voor een operator, maar PHP 7 brengt de nogal handige null-coalescentie met zich mee, dus ik dacht ik deel een voorbeeld.

In PHP 5 hebben we al een ternaire operator, die een waarde test en vervolgens het tweede element retourneert als dat waar oplevert en het derde als dat niet het geval is:

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

Er is ook een afkorting voor die het mogelijk maakt om het tweede element over te slaan als het hetzelfde is als het eerste: echo $count ?: 10; // voert ook 10 uit

In PHP 7 krijgen we bovendien de ?? operator die, in plaats van extreme verwarring aan te geven, zoals ik gewoonlijk twee vraagtekens samen zou gebruiken, ons in staat stelt een reeks waarden aan elkaar te koppelen. Als u van links naar rechts leest, is de eerste waarde die bestaat en niet null is de waarde die wordt geretourneerd.

// $a is not set
$b = 16;
echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Deze constructie is handig om prioriteit te geven aan een of meer waarden die mogelijk afkomstig zijn van gebruikersinvoer of bestaande configuratie, en om veilig terug te vallen op een bepaalde standaard als die configuratie ontbreekt. Het is een beetje een kleine functie, maar het is er een waarvan ik weet dat ik deze zal gebruiken zodra mijn applicaties upgraden naar PHP 7.

Antwoord 16

Declaratie van het retourtype Nullable

PHP 7 voegt ondersteuning toe voor aangiften van het retourtype. Net als bij declaraties van het argumenttype, specificeren de declaraties van het retourtype het type waarde dat door een functie wordt geretourneerd. Dezelfde typen zijn beschikbaar voor aangiften van het retourtype als voor declaraties van het argumenttype.

Strikte typering heeft ook effect op aangiften van het retourtype. In de standaard zwakke modus worden geretourneerde waarden gedwongen naar het juiste type als ze nog niet van dat type zijn. In de sterke modus moet de geretourneerde waarde van het juiste type zijn, anders wordt er een TypeError gegenereerd.

Vanaf PHP 7.1.0 kunnen retourwaarden worden gemarkeerd als nullable door de typenaam vooraf te laten gaan door een vraagteken (?). Dit betekent dat de functie het opgegeven type of NULL retourneert.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

Bron

Antwoord 17

Drie DOTS als Splat Operator (…)(sinds PHP 5.6)

PHP heeft een operator “…” (Drie stippen) die Splat Operator wordt genoemd. Het wordt gebruikt om een willekeurig aantal parameters in een functie door te geven en dit type functie wordt Variadic Functions genoemd. Laten we voorbeelden nemen voor het gebruik van “…” (drie stippen).

Voorbeeld 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
echo calculateNumbers(10, 20, 30, 40, 50);
//Output 150
?>

Elke argumenten van de functie berekeningNumbers() passeren $params als een array bij gebruik van “… “.

Er zijn veel verschillende manieren om de operator “…” te gebruiken. Hieronder enkele voorbeelden:

Voorbeeld 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);
//Output 150
?>

Voorbeeld 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);
//Output 220
?>

Voorbeeld 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);
//Output 1650
?>

Antwoord 18

?-> NullSafe-operator

Toegevoegd in PHP 8.0

Het is de NullSafe Operator, het retourneert nullvoor het geval u functies probeert aan te roepen of waarden van nullkrijgt. Nullsafe-operator kan worden geketend en kan zowel op de methoden als op eigenschappen worden gebruikt.

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

Nullsafe-operator werkt niet met arraysleutels:

$drive['admin']?->getDriver()?->value //Warning: Trying to access array offset on value of type null
$drive = [];
$drive['admin']?->getAddress()?->value //Warning: Undefined array key "admin"

Antwoord 19

NullSafe-operator “?->” (mogelijk) sinds php8

In PHP8 is deze nieuwe operator geaccepteerd, je kunt de documentatie hiervinden. ?->het is de NullSafe Operator, het retourneert nullvoor het geval je probeert om functies aan te roepen of waarden van null…

Voorbeelden:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>

Antwoord 20

PHP-arrays:

Een array is een gegevensstructuur die een of meer vergelijkbare type waarden opslaat in een enkele waarde

• Numerieke array − Een array met een numerieke index. Waarden worden op lineaire wijze opgeslagen en toegankelijk gemaakt.

• Associatieve array − Een array met strings als index. Dit slaat elementwaarden op in samenhang met sleutelwaarden in plaats van in een strikte lineaire indexvolgorde.

• Multidimensionale array − Een array die een of meer arrays en waarden bevat, wordt benaderd met behulp van meerdere indices
Numerieke matrix

Deze arrays kunnen getallen, strings en elk object opslaan, maar hun index wordt weergegeven door getallen. Standaard begint de array-index vanaf nul.

Voorbeeld:

<html>
   <body>
      <?php
         /* First method to create array. */
         $numbers = array( 1, 2, 3, 4, 5);
         foreach( $numbers as $value ) {
            echo "Value is $value <br />";
         }
         /* Second method to create array. */
         $numbers[0] = "one";
         $numbers[1] = "two";
         $numbers[2] = "three";
         $numbers[3] = "four";
         $numbers[4] = "five";
         foreach( $numbers as $value ) {
            echo "Value is $value <br />";
         }
      ?>
   </body>
</html>

Uitvoer:

Value is 1 
Value is 2 
Value is 3 
Value is 4 
Value is 5 
Value is one 
Value is two 
Value is three 
Value is four 
Value is five

Associatieve arrays

De associatieve arrays lijken qua functionaliteit erg op numerieke arrays, maar ze verschillen qua index. Associatieve arrays hebben hun index als tekenreeks, zodat u een sterke associatie tussen sleutel en waarden kunt vaststellen.

Voorbeeld:

<html>
   <body>
      <?php
         /* First method to associate create array. */
         $salaries = array("mohammad" => 2000, "qadir" => 1000, "zara" => 500);
         echo "Salary of mohammad is ". $salaries['mohammad'] . "<br />";
         echo "Salary of qadir is ".  $salaries['qadir']. "<br />";
         echo "Salary of zara is ".  $salaries['zara']. "<br />";
         /* Second method to create array. */
         $salaries['mohammad'] = "high";
         $salaries['qadir'] = "medium";
         $salaries['zara'] = "low";
         echo "Salary of mohammad is ". $salaries['mohammad'] . "<br />";
         echo "Salary of qadir is ".  $salaries['qadir']. "<br />";
         echo "Salary of zara is ".  $salaries['zara']. "<br />";
      ?>
   </body>
</html>

Uitvoer:

Salary of mohammad is 2000
Salary of qadir is 1000
Salary of zara is 500
Salary of mohammad is high
Salary of qadir is medium
Salary of zara is low

Multidimensionale arrays

Een multidimensionale array, elk element in de hoofdarray kan ook een array zijn. En elk element in de subarray kan een array zijn, enzovoort. Waarden in de multidimensionale array zijn toegankelijk via meerdere indexen.

Voorbeeld

<html>
   <body>
      <?php
         $marks = array( 
            "mohammad" => array (
               "physics" => 35,
               "maths" => 30,   
               "chemistry" => 39
            ),
            "qadir" => array (
               "physics" => 30,
               "maths" => 32,
               "chemistry" => 29
            ),
            "zara" => array (
               "physics" => 31,
               "maths" => 22,
               "chemistry" => 39
            )
         );
         /* Accessing multi-dimensional array values */
         echo "Marks for mohammad in physics : " ;
         echo $marks['mohammad']['physics'] . "<br />"; 
         echo "Marks for qadir in maths : ";
         echo $marks['qadir']['maths'] . "<br />"; 
         echo "Marks for zara in chemistry : " ;
         echo $marks['zara']['chemistry'] . "<br />"; 
      ?>
   </body>
</html>

Uitvoer:

Marks for mohammad in physics : 35
Marks for qadir in maths : 32
Marks for zara in chemistry : 39

PHP-arrayfuncties

• matrix() -> Maakt een array

• array_change_key_case() -> Verandert alle sleutels in een array in kleine letters of hoofdletters

• array_chunk() -> Splitst een array in stukken arrays
  array_column() -> Retourneert de waarden uit een enkele kolom in de invoermatrix

• array_combine() -> Creëert een array door gebruik te maken van de elementen uit één “keys” array en één “values” array

• array_count_values() -> Telt alle waarden van een array

• array_diff() -> Vergelijk arrays en retourneert de verschillen (alleen waarden vergelijken)

• array_diff_assoc() -> Vergelijk arrays en geeft de verschillen terug (vergelijk sleutels en waarden)

• array_diff_key() -> Vergelijk arrays en geeft de verschillen terug (alleen sleutels vergelijken)

• array_diff_uassoc() -> Vergelijk arrays en retourneert de verschillen (vergelijk sleutels en waarden met behulp van een door de gebruiker gedefinieerde sleutelvergelijkingsfunctie)

• array_diff_ukey() -> Vergelijk arrays en geeft de verschillen terug (alleen sleutels vergelijken, met behulp van een door de gebruiker gedefinieerde sleutelvergelijkingsfunctie)

• array_fill() -> Vult een array met waarden

• Array_Fill_Keys () – & GT; Vult een array met waarden, opgeven van sleutels

• Array_Filter () – & GT; Filtert de waarden van een array met behulp van een callback-functie

• ARRAY_FLIP () – & GT; Flips / ruilt alle sleutels met hun bijbehorende waarden in een array

• Array_intersect () – & GT; Vergelijk arrays en retourneert de overeenkomsten (alleen de waarden vergelijken)

• array_intersect_assoc () – & GT; Vergelijk arrays en retourneert de overeenkomsten (vergelijk toetsen en waarden)

• array_intersect_key () – & GT; Vergelijk arrays en retourneert de overeenkomsten (alleen vergelijken toetsen)

• array_intersect_uassoc () – & GT; Vergelijk arrays en retourneert de overeenkomsten (vergelijk toetsen en waarden, met behulp van een door de gebruiker gedefinieerde sleutelvergelijking)

• Array_intersect_ukey () – & GT; Vergelijk arrays en retourneert de overeenkomsten (alleen vergelijken toetsen, met behulp van een door de gebruiker gedefinieerde sleutelvergelijking)

• Array_Key_Exists () – & GT; Controleert of de opgegeven toets in de array

  bestaat

• Array_Keys () – & GT; Retourneert alle sleutels van een array

• ARRAY_MAP () – & GT; Verzendt elke waarde van een array naar een door de gebruiker gemaakte functie, die nieuwe waarden

  retourneert

• Array_Merge () – & GT; Fuseert een of meer arrays in één array

• Array_Merge_Recursive () – & GT; Versiert een of meer arrays in één array recursief

• Array_Multisort () – & GT; Sorteert meerdere of multidimensionale arrays