PHP
Utför på en array

Tillämpa en funktion på varje element i en matris

array_map() att tillämpa en funktion på varje objekt i en matris. Detta kommer att returnera en ny grupp.

$array = array(1,2,3,4,5);
//each array item is iterated over and gets stored in the function parameter.
$newArray = array_map(function($item) {
    return $item + 1;
}, $array);

$newArray nu är array(2,3,4,5,6); .

I stället för att använda en anonym funktion kan du använda en namngivna funktion. Ovanstående kan skrivas som:

function addOne($item) {
    return $item + 1;
}

$array = array(1, 2, 3, 4, 5);
$newArray = array_map('addOne', $array);

Om den nämnda funktionen är en klassmetod måste samtalet för funktionen inkludera en hänvisning till ett klassobjekt tillhör metoden:

class Example {
    public function addOne($item) {
        return $item + 1;
    }

    public function doCalculation() {
        $array = array(1, 2, 3, 4, 5);
        $newArray = array_map(array($this, 'addOne'), $array);
    }
}

Ett annat sätt att tillämpa en funktion på varje objekt i en matris är array_walk() och array_walk_recursive() . Återuppringningen som skickas till dessa funktioner tar både nyckel / index och värde för varje matrisobjekt. Dessa funktioner returnerar inte en ny matris, utan en boolean för framgång. För att till exempel skriva ut alla element i en enkel matris:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function($value, $key) {
    echo $value . ' ';
});
// prints "1 2 3 4 5"

Värdeparametern för återuppringningen kan skickas genom referens, så att du kan ändra värdet direkt i den ursprungliga arrayen:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function(&$value, $key) {
    $value++;
});

$array nu är array(2,3,4,5,6);

För kapslade matriser kommer array_walk_recursive() att gå djupare in i varje sub-array:

$array = array(1, array(2, 3, array(4, 5), 6);
array_walk_recursive($array, function($value, $key) {
    echo $value . ' ';
});
// prints "1 2 3 4 5 6"

Obs : array_walk och array_walk_recursive låter dig ändra värdet på arrayobjekt, men inte nycklarna. Att skicka knapparna med referens till återuppringningen är giltigt men har ingen effekt.

Dela upp matris i bitar

array_chunk () delar upp en matris i bitar

Låt oss säga att vi har följt en-dimensionell matris,

$input_array = array('a', 'b', 'c', 'd', 'e');

Nu använder du array_chunk () på ovanstående PHP-array,

$output_array = array_chunk($input_array, 2);

Ovanstående kod kommer att göra bitar av 2 arrayelement och skapa en flerdimensionell matris som följer.

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [0] => c
            [1] => d
        )

    [2] => Array
        (
            [0] => e
        )

)

Om alla elementen i matrisen inte är jämnt dividerade med storleksstorleken kommer det sista elementet i utmatningsgruppen att vara kvarstående element.

Om vi passerar det andra argumentet som mindre än 1 kommer E_WARNING att kastas och utmatningsfältet blir NULL .

Implodera en matris i sträng

implode() kombinerar alla matrisvärden men förlorar all nyckelinfo:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", $arr); // AA BB CC

Imploderingstangenter kan göras med array_keys() :

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", array_keys($arr)); // a b c

Implodering av nycklar med värden är mer komplex men kan göras med funktionell stil:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", array_map(function($key, $val) { 
    return "$key:$val"; // function that glues key to the value
}, array_keys($arr), $arr)); 

// Output: a:AA b:BB c:CC

array_reduce

array_reduce reducerar matrisen till ett enda värde. I grund och array_reduce kommer array_reduce att gå igenom varje objekt med resultatet från sista iterationen och producera nytt värde till nästa iteration.

Användning: array_reduce ($array, function($carry, $item){...}, $defaul_value_of_first_carry)

• $ carry är resultatet från den sista iterationsrundan.
• $ item är värdet på den aktuella positionen i matrisen.

Summan av matrisen

$result = array_reduce([1, 2, 3, 4, 5], function($carry, $item){
    return $carry + $item;
});

resultat: 15

Det största antalet i array

$result = array_reduce([10, 23, 211, 34, 25], function($carry, $item){
        return $item > $carry ? $item : $carry;
});

resultat: 211

Är alla artiklar mer än 100

$result = array_reduce([101, 230, 210, 341, 251], function($carry, $item){
        return $carry && $item > 100;
}, true); //default value must set true

resultat: true

Är någon vara mindre än 100

$result = array_reduce([101, 230, 21, 341, 251], function($carry, $item){
        return $carry || $item < 100;
}, false);//default value must set false

resultat: true

Som implode ($ array, $ piece)

$result = array_reduce(["hello", "world", "PHP", "language"], function($carry, $item){
        return !$carry ? $item : $carry . "-" . $item ;
});

resultat: "hello-world-PHP-language"

om du gör en implode-metod kommer källkoden att vara:

function implode_method($array, $piece){
    return array_reduce($array, function($carry, $item) use ($piece) {
            return !$carry ? $item : ($carry . $piece . $item);
    });
}

$result = implode_method(["hello", "world", "PHP", "language"], "-");

resultat: "hello-world-PHP-language"

"Destructuring" -uppsättningar med lista ()

Använd lista () för att snabbt tilldela en lista med variabla värden i en matris. Se även kompakt ()

// Assigns to $a, $b and $c the values of their respective array elements in           $array with keys numbered from zero
list($a, $b, $c) = $array;

Med PHP 7.1 (för närvarande i beta) kan du använda kortlistasyntax :

// Assigns to $a, $b and $c the values of their respective array elements in $array with keys numbered from zero
[$a, $b, $c] = $array;

// Assigns to $a, $b and $c the values of the array elements in $array with the keys "a", "b" and "c", respectively
["a" => $a, "b" => $b, "c" => $c] = $array;

Tryck ett värde på en matris

Det finns två sätt att driva ett element till en matris: array_push och $array[] =

Array_push används så här:

$array = [1,2,3];
$newArraySize = array_push($array, 5, 6); // The method returns the new size of the array
print_r($array); // Array is passed by reference, therefore the original array is modified to contain the new elements

Den här koden kommer att skrivas ut:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

$array[] = används så här:

$array = [1,2,3];
$array[] = 5;
$array[] = 6;
print_r($array);

Den här koden kommer att skrivas ut:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)