Ich habe ein Array wie folgt:

array("a" => 2, "b" => 4, "c" => 2, "d" => 5, "e" => 6, "f" => 2)

Jetzt möchte ich dieses Array nach einer Bedingung filtern und nur die Elemente behalten, bei denen der Wert gleich 2 ist, und alle Elemente löschen, bei denen der Wert NICHT 2 ist.

Mein erwartetes Ergebnisarray wäre also:

array("a" => 2, "c" => 2, "f" => 2)

_{Hinweis: Ich möchte die Schlüssel aus dem ursprünglichen Array behalten.}

Wie kann ich das mit PHP machen? Irgendwelche eingebauten Funktionen?

$fullArray = array('a'=>2,'b'=>4,'c'=>2,'d'=>5,'e'=>6,'f'=>2);


function filterArray($value){
    return ($value == 2);
}

$filteredArray = array_filter($fullArray, 'filterArray');

foreach($filteredArray as $k => $v){
    echo "$k = $v";
}

Sie müssen Ihr Array irgendwie durchlaufen und jedes Element nach Ihrer Bedingung filtern. Dies kann mit verschiedenen Methoden erfolgen.

Schleifen while / for / foreach Methode

Durchlaufen Sie Ihr Array mit einer beliebigen Schleife, die Sie möchten while, for oder foreach. Dann überprüfen Sie einfach Ihren Zustand und entweder unset() die Elemente, wenn sie Ihre Bedingung nicht erfüllen, oder schreiben Sie die Elemente, die die Bedingung erfüllen, in ein neues Array.

Schleife

//while loop
while(list($key, $value) = each($array)){
    //condition
}

//for loop
$keys = array_keys($array);
for($counter = 0, $length = count($array); $counter < $length; $counter++){
    $key = $keys[$counter];
    $value = $array[$key];
    //condition 
}

//foreach loop
foreach($array as $key => $value){
    //condition
}

Zustand

Platzieren Sie einfach Ihre Bedingung in der Schleife, in der der Kommentar steht //condition ist. Die Bedingung kann einfach überprüfen, was Sie wollen, und dann können Sie beides unset() die Elemente, die Ihre Bedingung nicht erfüllen, und das Array mit neu indizieren array_values() wenn Sie möchten, oder schreiben Sie die Elemente in ein neues Array, die die Bedingung erfüllen.

//Pseudo code
//Use one of the two ways
if(condition){  //1. Condition fulfilled
    $newArray[ ] = $value;
            //↑ Put '$key' there, if you want to keep the original keys
            //Result array is: $newArray

} else {        //2. Condition NOT fulfilled
    unset($array[$key]);
    //Use array_values() after the loop if you want to reindex the array
    //Result array is: $array
}

array_filter() Methode

Eine andere Methode ist die Verwendung von array_filter() eingebaute Funktion. Es funktioniert im Allgemeinen ziemlich genau wie die Methode mit einer einfachen Schleife.

Sie müssen nur zurückkehren TRUE wenn Sie das Element im Array behalten möchten und FALSE wenn Sie das Element aus dem Ergebnisarray löschen möchten.

//Anonymous function
$newArray = array_filter($array, function($value, $key){
    //condition
}, ARRAY_FILTER_USE_BOTH);

//Function name passed as string
function filter($value, $key){
    //condition
}
$newArray = array_filter($array, "filter", ARRAY_FILTER_USE_BOTH);

//'create_function()', NOT recommended
$newArray = array_filter($array, create_function('$value, $key', '/* condition */'), ARRAY_FILTER_USE_BOTH);

preg_grep() Methode

preg_grep() ist ähnlich wie array_filter() nur dass es nur reguläre Ausdrücke verwendet, um das Array zu filtern. Sie können also möglicherweise nicht alles damit machen, da Sie nur einen regulären Ausdruck als Filter verwenden können und Sie nur nach Werten oder mit etwas mehr Code nach Schlüsseln filtern können.

Beachten Sie auch, dass Sie die Flagge passieren können PREG_GREP_INVERT als dritter Parameter, um die Ergebnisse zu invertieren.

//Filter by values
$newArray = preg_grep("/regex/", $array);

Gemeinsame Bedingungen

Es gibt viele allgemeine Bedingungen, die verwendet werden, um ein Array zu filtern, von denen alle auf den Wert und/oder Schlüssel des Arrays angewendet werden können. Ich werde hier nur einige davon auflisten:

//Odd values
return $value & 1;

//Even values
return !($value & 1);

//NOT null values
return !is_null($value);

//NOT 0 values
return $value !== 0;

//Contain certain value values
return strpos($value, $needle) !== FALSE;  //Use 'use($needle)' to get the var into scope

//Contain certain substring at position values
return substr($value, $position, $length) === $subString;

//NOT 'empty'(link) values
array_filter($array);  //Leave out the callback parameter

Sie können über die Kopien der Schlüssel iterieren, um sie verwenden zu können unset() in der Schleife:

foreach (array_keys($array) as $key) {
    if ($array[$key] != 2)  {
        unset($array[$key]);
    }
}

Der Vorteil dieser Methode ist die Speichereffizienz, wenn Ihr Array große Werte enthält – sie werden nicht dupliziert.

BEARBEITEN Ich habe gerade festgestellt, dass Sie eigentlich nur die Schlüssel benötigen, die einen Wert von 2 haben (Sie kennen den Wert bereits):

$keys = array();
foreach ($array as $key => $value) {
    if ($value == 2)  {
        $keys[] = $key;
    }
}

Dies sollte funktionieren, aber ich bin mir nicht sicher, wie effizient es ist, da Sie wahrscheinlich am Ende viele Daten kopieren.

$newArray = array_intersect_key(
                  $fullarray, 
                  array_flip(array_keys($fullarray, 2))
            );

Ich denke, die bissigste, lesbarste eingebaute Funktion ist: array_intersect()

Code: (Demo)

$array = array("a" => 2, "b" => 4, "c" => 2, "d" => 5, "e" => 6, "f" => 2);
var_export(array_intersect($array, [2]));

Ausgabe:

array (
  'a' => 2,
  'c' => 2,
  'f' => 2,
)

Stellen Sie nur sicher, dass Sie den 2. Parameter als Array deklarieren, da dies der erwartete Werttyp ist.

Jetzt ist nichts falsch daran, eine foreach-Schleife zu schreiben oder zu verwenden array_filter()sie haben nur eine ausführlichere Syntax.

array_intersect() ist auch sehr einfach zu erweitern (zusätzliche “qualifizierende” Werte hinzufügen), indem dem 2. Parameterarray weitere Werte hinzugefügt werden.

Dies kann mit einem Verschluss gehandhabt werden. Die folgende Antwort ist inspiriert von PHP der richtige Weg:

//This will create an anonymous function that will filter the items in the array by the value supplied
function cb_equal_to($val)
{
    return function($item) use ($val) {
        return $item == $val;
    };
}

$input = array("a" => 2, "b" => 4, "c" => 2, "d" => 5, "e" => 6, "f" => 2);

// Use array_filter on a input with a selected filter function
$filtered_array = array_filter($input, cb_equal_to(2));

Inhalt von $filtered_array wäre jetzt

array ( ["a"] => 2 ["c"] => 2 ["f"] => 2 ) 

  foreach ($aray as $key => $value) {
    if (2 != $value) {
      unset($array($key));
    }
  }

  echo 'Items in array:' . count($array);