PHP: ¿Cómo usar array filter () para filtrar claves de array?

Con array_intersect_key y array_flip:

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

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

Necesitaba hacer lo mismo, pero con un array_filter más complejo en las teclas.

Así es como lo hice, usando un método similar.

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

Esto produce el resultado:

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

Aquí hay una solución más flexible usando un cierre:

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

Salidas:

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

Así que en la función, puede hacer otras pruebas específicas.

Si está buscando un método para filtrar una matriz por una cadena que ocurre en las claves, puede usar:

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

El resultado de print_r($mResult) es

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

Una adaptación de esta respuesta que soporta expresiones regulares

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

Salida

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

Cómo obtener la clave actual de un array cuando se usa array_filter

Independientemente de cómo me guste la solución de Vincent para el problema de Maček, en realidad no usa array_filter. Si usted vino aquí desde un motor de búsqueda que tal vez en busca de algo como esto (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';
}

Pasa la matriz que está filtrando como una referencia a la devolución de llamada. Como array_filter no itera convencionalmente sobre la matriz al aumentar su puntero interno público, debe avanzar por a ti mismo.

Lo que es importante aquí es que necesita asegurarse de que su matriz se restablezca, de lo contrario podría comenzar justo en el medio de ella.

En PHP >= 5.4 podría hacer la devolución de llamada aún más corta:

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

Aquí hay una alternativa menos flexible usando unset():

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

El resultado de print_r($array) es:

Array
(
    [2] => two
)

Esto no es aplicable si desea mantener los valores filtrados para su uso posterior, pero más ordenados, si está seguro de que no lo hace.

A partir de PHP 5.6, puede usar el indicador ARRAY_FILTER_USE_KEY en array_filter:

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

De lo contrario, puede usar esta función ( desde TestDummy):

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

Y aquí hay una versión aumentada de la mía, que acepta una devolución de llamada o directamente las teclas:

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

Por último, pero no menos importante, también puede utilizar un simple foreach:

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

Tal vez un exceso si lo necesita solo una vez, pero puede usar la biblioteca YaLinqo* para filtrar colecciones (y realizar cualquier otra transformación). Esta biblioteca permite peforming consultas tipo SQL en objetos con sintaxis fluida. Su where la función acepta un calback con dos argumentos: un valor y una clave. Por ejemplo:

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

(La función where devuelve un iterador, por lo que si solo necesita iterar con foreach sobre la secuencia resultante una vez, ->toArray() puede ser quitar.)

_{* desarrollado por mí}

Con esta función puede filtrar un array multidimensional

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

}

Función de filtro de matriz de php:

array_filter ( $array, $callback_function, $flag )

Array array-Es el array de entrada

Call callback_function - La función callback a usar， Si la función callback devuelve true, el valor actual de la matriz se devuelve en la matriz de resultados.

Flag flag - Es parámetro opcional, determinará qué argumentos se envían a la función callback. Si este parámetro está vacío, la función callback tomará los valores de la matriz como argumento. Si desea enviar clave de matriz como argumento entonces use {flag como ARRAY_FILTER_USE_KEY . Si desea enviar ambas claves y valores, debe usar {flag como ARRAY_FILTER_USE_BOTH .

Por Ejemplo : Considere la matriz simple

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

Si desea filtrar el array basado en la clave array, necesitamos usar ARRAY_FILTER_USE_KEY como tercer parámetro de la función array array_filter.

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

Si desea filtrar la matriz basada en la clave de matriz y la matriz valor , Necesitamos usar ARRAY_FILTER_USE_BOTH como tercer parámetro de la función array array_filter.

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

Funciones de devolución de llamada de ejemplo:

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

Saldrá

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

/ / Filtrar elementos de matriz con claves más cortas que 4 caracteres // Mediante el uso de la función Anónima con cierre...

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 output = array_filter (array_keys(input input), comparison (4));

Print_r (output output);

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

Función para eliminar algunos elementos del array

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

Llamar e imprimir

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

El resultado Array ( [0] => first )