PHP: Wie verwende ich array_filter (), um Array-Schlüssel zu filtern?

Die Rückruffunktion in array_filter()übergibt nur die Werte des Arrays, nicht die Schlüssel.

Wenn ich habe:

$my_array = array("foo" => 1, "hello" => "world");

$allowed = array("foo", "bar");

Was ist der beste Weg, um alle Schlüssel zu löschen $my_array, die sich nicht im $allowedArray befinden?

Gewünschte Ausgabe:

$my_array = array("foo" => 1);

PHP 5.6 eingeführt einen dritten Parameter array_filter(), flag, dass Sie einstellen können , ARRAY_FILTER_USE_KEYum Filter mit Schlüssel statt Wert:

$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
    $my_array,
    function ($key) use ($allowed) {
        return in_array($key, $allowed);
    },
    ARRAY_FILTER_USE_KEY
);

Dies ist array_intersect_key($my_array, array_flip($allowed))natürlich nicht so elegant wie , bietet jedoch die zusätzliche Flexibilität, einen beliebigen Test für den Schlüssel durchzuführen, z. B. $allowedkönnte Regex-Muster anstelle von einfachen Zeichenfolgen enthalten.

Sie können auch ARRAY_FILTER_USE_BOTHden Wert und den Schlüssel an Ihre Filterfunktion übergeben lassen. Hier ist ein erfundenes Beispiel, das auf dem ersten basiert, aber beachten Sie, dass ich nicht empfehlen würde, Filterregeln auf $alloweddiese Weise zu codieren :

$my_array = ['foo' => 1, 'bar' => 'baz', 'hello' => 'wld'];
$allowed  = ['foo' => true, 'bar' => true, 'hello' => 'world'];
$filtered = array_filter(
    $my_array,
    function ($val, $key) use ($allowed) { // N.b. $val, $key not $key, $val
        return isset($allowed[$key]) && (
            $allowed[$key] === true || $allowed[$key] === $val
        );
    },
    ARRAY_FILTER_USE_BOTH
); // ['foo' => 1, 'bar' => 'baz']

Mit array_intersect_keyund array_flip:

var_dump(array_intersect_key($my_array, array_flip($allowed)));

array(1) {
  ["foo"]=>
  int(1)
}

Ich musste dasselbe tun, aber mit einem komplexeren array_filterSchlüssel.

Hier ist, wie ich es gemacht habe, mit einer ähnlichen Methode.

// Filter out array elements with keys shorter than 4 characters
$a = array(
  0      => "val 0", 
  "one"  => "val one", 
  "two"  => "val two", 
  "three"=> "val three", 
  "four" => "val four", 
  "five" => "val five", 
  "6"    => "val 6"
); 

$f = array_filter(array_keys($a), function ($k){ return strlen($k)>=4; }); 
$b = array_intersect_key($a, array_flip($f));
print_r($b);

Dies gibt das Ergebnis aus:

Array
(
    [three] => val three
    [four] => val four
    [five] => val five
)

Hier ist eine flexiblere Lösung mit einem Verschluss:

$my_array = array("foo" => 1, "hello" => "world");
$allowed = array("foo", "bar");
$result = array_flip(array_filter(array_flip($my_array), function ($key) use ($allowed)
{
    return in_array($key, $allowed);
}));
var_dump($result);

Ausgänge:

array(1) {
  'foo' =>
  int(1)
}

In der Funktion können Sie also andere spezifische Tests durchführen.

Wenn Sie nach einer Methode suchen, um ein Array nach einer in Schlüsseln vorkommenden Zeichenfolge zu filtern, können Sie Folgendes verwenden:

$mArray=array('foo'=>'bar','foo2'=>'bar2','fooToo'=>'bar3','baz'=>'nope');
$mSearch='foo';
$allowed=array_filter(
    array_keys($mArray),
    function($key) use ($mSearch){
        return stristr($key,$mSearch);
    });
$mResult=array_intersect_key($mArray,array_flip($allowed));

Das Ergebnis von print_r($mResult)ist

Array ( [foo] => bar [foo2] => bar2 [fooToo] => bar3 )

Eine Anpassung dieser Antwort, die reguläre Ausdrücke unterstützt

function array_preg_filter_keys($arr, $regexp) {
  $keys = array_keys($arr);
  $match = array_filter($keys, function($k) use($regexp) {
    return preg_match($regexp, $k) === 1;
  });
  return array_intersect_key($arr, array_flip($match));
}

$mArray = array('foo'=>'yes', 'foo2'=>'yes', 'FooToo'=>'yes', 'baz'=>'nope');

print_r(array_preg_filter_keys($mArray, "/^foo/i"));

Ausgabe

Array
(
    [foo] => yes
    [foo2] => yes
    [FooToo] => yes
)

So erhalten Sie den aktuellen Schlüssel eines Arrays bei Verwendung array_filter

Unabhängig davon, wie ich Vincents Lösung für Mačeks Problem mag, wird sie nicht wirklich verwendet array_filter. Wenn Sie von einer Suchmaschine hierher gekommen sind, haben Sie vielleicht nach so etwas gesucht ( PHP> = 5.3 ):

$array = ['apple' => 'red', 'pear' => 'green'];
reset($array); // Unimportant here, but make sure your array is reset

$apples = array_filter($array, function($color) use ($&array) {
  $key = key($array);
  next($array); // advance array pointer

  return key($array) === 'apple';
}

Es übergibt das Array, das Sie filtern, als Referenz auf den Rückruf. Da array_filterdas Array herkömmlicherweise nicht durch Erhöhen des öffentlichen internen Zeigers durchlaufen wird, müssen Sie es selbst weiterentwickeln.

Wichtig ist hierbei, dass Sie sicherstellen müssen, dass Ihr Array zurückgesetzt wird, da Sie sonst möglicherweise genau in der Mitte beginnen.

In PHP> = 5.4 können Sie den Rückruf noch kürzer machen:

$apples = array_filter($array, function($color) use ($&array) {
  return each($array)['key'] === 'apple';
}

Hier ist eine weniger flexible Alternative mit unset () :

$array = array(
    1 => 'one',
    2 => 'two',
    3 => 'three'
);
$disallowed = array(1,3);
foreach($disallowed as $key){
    unset($array[$key]);
}

Das Ergebnis des print_r($array)Seins:

Array
(
    [2] => two
)

Dies gilt nicht, wenn Sie die gefilterten Werte für die spätere Verwendung aufbewahren möchten, aber aufgeräumter, wenn Sie sicher sind, dass dies nicht der Fall ist .

Ab PHP 5.6 können Sie das ARRAY_FILTER_USE_KEYFlag verwenden in array_filter:

$result = array_filter($my_array, function ($k) use ($allowed) {
    return in_array($k, $allowed);
}, ARRAY_FILTER_USE_KEY);

Andernfalls können Sie diese Funktion ( von TestDummy ) verwenden:

function filter_array_keys(array $array, $callback)
{
    $matchedKeys = array_filter(array_keys($array), $callback);

    return array_intersect_key($array, array_flip($matchedKeys));
}

$result = filter_array_keys($my_array, function ($k) use ($allowed) {
    return in_array($k, $allowed);
});

Und hier ist eine erweiterte Version von mir, die einen Rückruf oder direkt die Schlüssel akzeptiert:

function filter_array_keys(array $array, $keys)
{
    if (is_callable($keys)) {
        $keys = array_filter(array_keys($array), $keys);
    }

    return array_intersect_key($array, array_flip($keys));
}

// using a callback, like array_filter:
$result = filter_array_keys($my_array, function ($k) use ($allowed) {
    return in_array($k, $allowed);
});

// or, if you already have the keys:
$result = filter_array_keys($my_array, $allowed));

Zu guter Letzt können Sie auch ein einfaches verwenden foreach:

$result = [];
foreach ($my_array as $key => $value) {
    if (in_array($key, $allowed)) {
        $result[$key] = $value;
    }
}

Vielleicht ein Overkill, wenn Sie es nur einmal brauchen, aber Sie können die YaLinqo- Bibliothek * verwenden, um Sammlungen zu filtern (und andere Transformationen durchzuführen). Diese Bibliothek ermöglicht die Durchführung von SQL-ähnlichen Abfragen für Objekte mit fließender Syntax. Seine whereFunktion akzeptiert einen Calback mit zwei Argumenten: einem Wert und einem Schlüssel. Zum Beispiel:

$filtered = from($array)
    ->where(function ($v, $k) use ($allowed) {
        return in_array($k, $allowed);
    })
    ->toArray();

(Die whereFunktion gibt einen Iterator zurück. Wenn Sie also nur foreacheinmal mit der resultierenden Sequenz iterieren müssen ,->toArray() kann diese entfernt werden.)

_{* von mir entwickelt}

Array Filter Funktion von PHP:

array_filter ( $array, $callback_function, $flag )

$ array - Dies ist das Eingabearray

$ callback_function - Die zu verwendende Rückruffunktion ， Wenn die Rückruffunktion true zurückgibt , wird der aktuelle Wert aus dem Array in das Ergebnisarray zurückgegeben.

$ flag - Dies ist ein optionaler Parameter , der bestimmt, welche Argumente an die Rückruffunktion gesendet werden. Wenn dieser Parameter leer ist, verwendet die Rückruffunktion Array-Werte als Argument. Wenn Sie einen Array-Schlüssel als Argument senden möchten, verwenden Sie $ flag als ARRAY_FILTER_USE_KEY . Wenn Sie sowohl Schlüssel als auch Werte senden möchten, sollten Sie $ flag als ARRAY_FILTER_USE_BOTH verwenden .

Zum Beispiel: Betrachten Sie ein einfaches Array

$array = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);

Wenn Sie ein Array basierend auf dem Array-Schlüssel filtern möchten , müssen Sie ARRAY_FILTER_USE_KEY als dritten Parameter der Array-Funktion array_filter verwenden.

$get_key_res = array_filter($array,"get_key",ARRAY_FILTER_USE_KEY );

Wenn Sie das Array basierend auf dem Array-Schlüssel und dem Array-Wert filtern möchten , müssen Sie ARRAY_FILTER_USE_BOTH als dritten Parameter der Array-Funktion array_filter verwenden.

$get_both = array_filter($array,"get_both",ARRAY_FILTER_USE_BOTH );

Beispiel für Rückruffunktionen:

 function get_key($key)
 {
    if($key == 'a')
    {
        return true;
    } else {
        return false;
    }
}
function get_both($val,$key)
{
    if($key == 'a' && $val == 1)
    {
        return true;
    }   else {
        return false;
    }
}

Es wird ausgegeben

Output of $get_key is :Array ( [a] => 1 ) 
Output of $get_both is :Array ( [a] => 1 ) 

Mit dieser Funktion können Sie ein mehrdimensionales Array filtern

function filter_array_keys($array,$filter_keys=array()){

    $l=array(&$array);
    $c=1;
    //This first loop will loop until the count var is stable//
    for($r=0;$r<$c;$r++){
        //This loop will loop thru the child element list//
        $keys = array_keys($l[$r]);

        for($z=0;$z<count($l[$r]);$z++){
            $object = &$l[$r][$keys[$z]];

            if(is_array($object)){
                $i=0;
                $keys_on_array=array_keys($object);
                $object=array_filter($object,function($el) use(&$i,$keys_on_array,$filter_keys){
                    $key = $keys_on_array[$i];
                    $i++;

                    if(in_array($key,$filter_keys) || is_int($key))return false;                
                    return true;                        
                });
            }

            if(is_array($l[$r][$keys[$z]])){
                $l[] = &$l[$r][$keys[$z]];
                $c++;
            }//IF           
        }//FOR
    }//FOR  

    return $l[0];

}

// Filter out array elements with keys shorter than 4 characters 
// By using Anonymous function with  Closure...     

function comparison($min)
{
   return function($item) use ($min) { 
      return strlen($item) >= $min;   
   }; 
}

$input = array(
  0      => "val 0",
  "one"  => "val one",
  "two"  => "val two",
  "three"=> "val three",
  "four" => "val four",  
  "five" => "val five",    
  "6"    => "val 6"    
);

$output = array_filter(array_keys($input), comparison(4));    

print_r($output);

Naive und hässliche (scheint aber schneller zu sein) Lösung?

Ich habe dies nur in PHP 7.3.11 versucht, aber eine hässliche Schleife scheint in etwa einem Drittel der Zeit ausgeführt zu werden. Ähnliche Ergebnisse auf einem Array mit einigen hundert Schlüsseln. Mikrooptimierung, wahrscheinlich nicht nützlich in RW, fand sie aber überraschend und interessant:

$time = microtime(true);
$i = 100000;
while($i) {
    $my_array = ['foo' => 1, 'hello' => 'world'];
    $allowed  = ['foo', 'bar'];
    $filtered = array_filter(
        $my_array,
        function ($key) use ($allowed) {
            return in_array($key, $allowed);
        },
        ARRAY_FILTER_USE_KEY
    );
    $i--;
}
print_r($filtered);
echo microtime(true) - $time . ' on array_filter';

// 0.40600109100342 on array_filter
$time2 = microtime(true);
$i2 = 100000;
while($i2) {
    $my_array2 = ['foo' => 1, 'hello' => 'world'];
    $allowed2  = ['foo', 'bar'];
    $filtered2 = [];
    foreach ($my_array2 as $k => $v) {
        if (in_array($k, $allowed2)) $filtered2[$k] = $v;
    }
    $i2--;
}
print_r($filtered2);
echo microtime(true) - $time2 . ' on ugly loop';
// 0.15677785873413 on ugly loop

$elements_array = ['first', 'second'];

Funktion zum Entfernen einiger Array-Elemente

function remove($arr, $data) {
    return array_filter($arr, function ($element) use ($data) {
        return $element != $data;
    });
}

anrufen und drucken

print_r(remove($elements_array, 'second'));

das Ergebnis Array ( [0] => first )