programing

인덱스 배열의 값과 키를 비교하는 연관 배열을 필터링하는 방법은 무엇입니까?

bestprogram 2023. 5. 27. 12:05

인덱스 배열의 값과 키를 비교하는 연관 배열을 필터링하는 방법은 무엇입니까?

콜백 함수는 배열의 값만 전달하고 키는 전달하지 않습니다.

내가 가지고 있는 경우:

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

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

의 모든 키를 삭제하는 가장 좋은 방법은 무엇입니까?$my_array에 없는$allowed배열?

원하는 출력:

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

포함 및 :

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

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

PHP 5.6은 세 번째 매개 변수를 도입했습니다.array_filter()값 대신 키로 필터링하도록 설정할 수 있습니다.

$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
    $my_array,
    function ($key) use ($allowed) {
        // N.b. in_array() is notorious for being slow 
        return in_array($key, $allowed);
    },
    ARRAY_FILTER_USE_KEY
);

PHP 7.4가 화살표 기능을 도입했기 때문에 우리는 이것을 더 간결하게 만들 수 있습니다.

$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
    $my_array,
    fn ($key) => in_array($key, $allowed),
    ARRAY_FILTER_USE_KEY
);

분명히 이것은 처럼 우아하지는 않지만 키에 대해 임의 테스트를 수행할 수 있는 추가적인 유연성을 제공합니다.$allowed일반 문자열 대신 정규식 패턴을 포함할 수 있습니다.

를 사용하여 값과 키를 모두 필터 기능에 전달할 수도 있습니다.다음은 첫 번째 예를 기반으로 한 고안된 예제이지만 다음을 사용하여 필터링 규칙을 인코딩하는 것은 권장하지 않습니다.$allowed이쪽:

$my_array = ['foo' => 1, 'bar' => 'baz', 'hello' => 'wld'];
$allowed  = ['foo' => true, 'bar' => true, 'hello' => 'world'];
$filtered = array_filter(
    $my_array,
    fn ($val, $key) => isset($allowed[$key]) && (
        $allowed[$key] === true || $allowed[$key] === $val
    ),
    ARRAY_FILTER_USE_BOTH
); // ['foo' => 1, 'bar' => 'baz']

클로저를 사용한 보다 유연한 솔루션은 다음과 같습니다.

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

출력:

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

따라서 기능에서는 다른 특정 테스트를 수행할 수 있습니다.

다음은 unset()을 사용하는 덜 유연한 대안입니다.

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

의 결과print_r($array)존재:

Array
(
    [2] => two
)

나중에 사용할 수 있도록 필터링된 값을 유지하려는 경우에는 적용되지 않지만, 그렇지 않은 것이 확실한 경우에는 더 깔끔합니다.

키에서 발생하는 문자열로 배열을 필터링하는 방법을 찾고 있는 경우 다음을 사용할 수 있습니다.

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

의 결과print_r($mResult)이라

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

정규식을 지원하는 이 답변의 적용

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

산출량

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

PHP 5.6부터, 당신은 다음을 사용할 수 있습니다.ARRAY_FILTER_USE_KEY플래그 위치:

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


그렇지 않으면 Test Dummy에서 다음 기능을 사용할 수 있습니다.

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


다음은 콜백 또는 직접 키를 수락하는 제 기능의 확장 버전은 다음과 같습니다.

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


마지막으로 중요한 것은, 간단한 것도 사용할 수 있습니다.foreach:

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

사용 시 배열의 현재 키를 가져오는 방법array_filter

내가 마크의 문제에 대한 빈센트의 해결책을 어떻게 좋아하든, 그것은 실제로 사용하지 않습니다.array_filter검색 엔진에서 현재 반복 키에 액세스할 수 있는 방법을 찾고 있는 경우array_filter의 콜백, 당신은 다음과 같은 것을 찾을 수 있습니다(PHP > = 5.3).

$my_array = ["foo" => 1, "hello" => "world"];

$allowed = ["foo", "bar"];

reset($my_array ); // Unnecessary in this case, as we just defined the array, but
                   // make sure your array is reset (see below for further explanation).

$my_array = array_filter($my_array, function($value) use (&$my_array, $allowed) {
  $key = key($my_array); // request key of current internal array pointer
  next($my_array); // advance internal array pointer

  return isset($allowed[$key]);
});

// $my_array now equals ['foo' => 1]

필터링 중인 배열을 콜백에 대한 참조로 전달합니다.~하듯이array_filter일반적으로 공용 내부 포인터를 늘려서 어레이를 반복하지 않습니다. 사용자가 직접 진행해야 합니다.

여기서 중요한 것은 어레이가 재설정되었는지 확인해야 합니다. 그렇지 않으면 내부 어레이 포인터가 이전에 실행된 의 일부 코드에 의해 그곳에 남겨졌기 때문에 바로 시작할 수 있습니다.

@sepiariver를 기반으로 PHP 8.0.3에서 몇 가지 유사한 테스트를 수행했습니다.

$arr = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6, 'g' => 7, 'h' => 8];
$filter = ['a', 'e', 'h'];


$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
  $filtered = array_intersect_key($arr, array_flip($filter));
  $i--;
}
print_r($filtered);
echo microtime(true) - $time . " using array_intersect_key\n\n";


$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
  $filtered = array_filter(
    $arr,
    function ($key) use ($filter){return in_array($key, $filter);},
    ARRAY_FILTER_USE_KEY
  );
  $i--;
}
print_r($filtered);
echo microtime(true) - $time . " using array_filter\n\n";

$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
  foreach ($filter as $key)
    if(array_key_exists($key, $arr))
      $filtered[$key] = $arr[$key];
  $i--;
}
print_r($filtered);
echo microtime(true) - $time . " using foreach + array_key_exists\n\n";
  • 0.28603601455688 array_syslog_key 사용
  • 1.3096671104431 array_filter 사용
  • 0.1592384757996 각 + 어레이_key_dll에 사용

array_filter의 '문제'는 arr의 모든 요소를 루프하는 반면 array_intersect_key는 각각 $filter만 루프한다는 것입니다.$filter가 $arr보다 작다고 가정하면 후자가 더 효율적입니다.

php의 배열 필터 함수:

array_filter ( $array, $callback_function, $flag )

$array - 입력 배열입니다.

$callback_function - 사용할 콜백 함수 , 콜백 함수가 true를 반환하면 배열의 현재 값이 결과 배열로 반환됩니다.

$flag - 선택적 매개 변수이며 콜백 함수로 보낼 인수를 결정합니다.이 매개 변수가 비어 있으면 콜백 함수는 배열 값을 인수로 사용합니다.배열 키를 인수로 보내려면 $flag를 ARARY_FILTER_USE_KEY로 사용합니다.키와 값을 모두 보내려면 $flag를 ARARY_FILTER_USE_BOTH로 사용해야 합니다.

예: 단순 배열을 고려

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

어레이 키를 기반으로 어레이를 필터링하려면 어레이 함수 array_filter의 세 번째 매개 변수ARARY_FILTER_USE_KEY를 사용해야 합니다.

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

어레이 키와 어레이 값을 기준으로 어레이를 필터링하려면 어레이 함수 array_filter의 세 번째 매개 변수로 ARARY_FILTER_USE_BOTH를 사용해야 합니다.

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

콜백 함수의 예:

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

출력됩니다.

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

한 번만 필요하면 오버킬이 발생할 수 있지만 YaLinqo 라이브러리*를 사용하여 컬렉션을 필터링하고 다른 변환을 수행할 수 있습니다.이 라이브러리를 사용하면 구문이 유창한 개체에 대해 SQL과 유사한 쿼리를 수행할 수 있습니다.이 함수는 값과 키라는 두 개의 인수가 있는 콜백을 허용합니다.예:

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

(계속)where에 다▁with▁functionerate▁you니▁to▁only▁returns▁it▁so 따라서 사용자가 반복하기만 하면 되는 경우foreach결과 시퀀스를 한 번 초과합니다.->toArray()제거할 수 있습니다.)

내가 개발한

저는 두 개의 필터 정적 함수를 denylist 또는 allowlist를 사용하여 배열을 필터링하는 작은 "Utils" 클래스를 사용합니다.

<?php

class Utils {
 
  /**
   * Filter an array based on a allowlist of keys
   *
   * @param array $array
   * @param array $allowlist
   *
   * @return array
   */
  public static function array_keys_allowlist( array $array, array $allowlist ): array {
    return array_intersect_key( $array, array_flip( $allowlist ) );
  }


  /**
   * Filter an array based on a denylist of keys
   *
   * @param array $array
   * @param array $denylist
   *
   * @return array
   */
  public static function array_keys_denylist( array $array, array $denylist ): array {
    return array_diff_key($array,array_flip($denylist));
  }

}

그런 다음 이렇게 사용할 수 있습니다.

<?php

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

$my_array = Utils::array_keys_allowlist($my_array,  $allowed)

순진하고 추악한(그러나 더 빠른 것처럼 보이는) 해결책?

php 7.3.11에서만 시도했지만 추한 루프가 약 3분의 1 안에 실행되는 것 같습니다.수백 개의 키가 있는 배열에서도 유사한 결과가 나타납니다.마이크로 최적화는 RW에서 유용하지 않을 수 있지만 놀랍고 흥미롭습니다.

$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

언급URL : https://stackoverflow.com/questions/4260086/how-to-filter-an-associative-array-comparing-keys-with-values-in-an-indexed-arra