改进此页面

    了解如何改进此页面 • 提交拉取请求 • 报告错误
    ＋添加说明

    用户贡献的说明 16 条说明

    225
    turabgarip at gmail dot com
    7 年前
    关于在多维数组中搜索；对 "xfoxawy at gmail dot com" 的两个说明；

    它可以完美地搜索多维数组，并结合使用 array_column()（最小 PHP 5.5.0），但它可能不会返回您预期的值。

    <?php array_search($needle, array_column($array, 'key')); ?>

    由于 array_column() 会产生一个结果数组；它不会保留您多维数组的键。因此，如果您对键进行检查，它将失败。

    例如；

    <?php
    $people     = array(
    2 => array(
    'name' => 'John',
    'fav_color' => 'green'
    ),
    5=> array(
    'name' => 'Samuel',
    'fav_color' => 'blue'
    )
    );

    $found_key = array_search('blue', array_column($people, 'fav_color'));
    ?>

    在这里，您可能会期望 $found_key 为 "5"，但事实并非如此。它将为 1。因为它是由 array_column() 函数产生的数组的第二个元素。

    其次，如果您的数组很大，我建议您先分配一个新变量，这样它就不会对它搜索的每个元素都调用 array_column()。为了提高性能，您可以执行以下操作；

    <?php
    $colors     = array_column($people, 'fav_color');
    $found_key = array_search('blue', $colors);
    ?>
    51
    cue at openxbox dot com
    21 年前
    如果您在条件语句中使用 array_search 的结果，请确保使用 === 运算符而不是 == 来测试它是否找到了匹配项。否则，在具有数字索引的数组中搜索将导致索引 0 始终被评估为 false/null。这种细微差别让我浪费了很多时间和理智，因此我希望这能对某些人有所帮助。如果您不知道我在说什么，这里有一个示例

    <?php
    $code     = array("a", "b", "a", "c", "a", "b", "b"); // 著名的 abacabb 致命格斗代码 :-P

    // 这是错误的
    while (($key = array_search("a", $code)) != NULL)
    {
    // 无限循环，无论是否取消设置
    unset($code[$key]);
    }

    // 这是正确的
    while (($key = array_search("a", $code)) !== NULL)
    {
    // 循环将终止
    unset($code[$key]);
    }
    ?>
    30
    stefano@takys dot it
    13 年前
    为了搜索不区分大小写的更好方法，请使用此方法

    <?php
    array_search    (strtolower($element),array_map('strtolower',$array));
    ?>
    15
    RichGC
    18 年前
    为了扩展之前的评论，这里有一些例子
    在 IF 语句中使用 array_search 的地方可能会出现
    错误，当你想要使用返回的数组键时。

    以以下两个你想要搜索的数组为例

    <?php
    $fruit_array     = array("apple", "pear", "orange");
    $fruit_array = array("a" => "apple", "b" => "pear", "c" => "orange");

    if (    $i = array_search("apple", $fruit_array))
    //问题：第一个数组返回一个键 0，IF 将其视为 FALSE

    if (is_numeric($i = array_search("apple", $fruit_array)))
    //问题：对第一个数组的数字键有效，但对第二个数组无效

    if ($i = is_numeric(array_search("apple", $fruit_array)))
    //问题：在错误的顺序使用上面的代码会导致 $i 始终等于 1

    if ($i = array_search("apple", $fruit_array) !== FALSE)
    //问题：没有额外括号的显式语句会导致 $i 始终等于 1

    if (($i = array_search("apple", $fruit_array)) !== FALSE)
    //YES：对两个数组都有效，返回它们的键
    ?>
    8
    thinbegin at gmail dot com
    6 年前
    尽管 PHP 拥有惊人的数组函数和操作方法，但我发现自己需要一种方法来获取到特定值的完整数组键映射。这个函数可以做到这一点，并返回一个包含获取该值（第一次出现）的相应键的数组。

    function array_recursive_search_key_map($needle, $haystack) {
    foreach($haystack as $first_level_key=>$value) {
    if ($needle === $value) {
    return array($first_level_key);
    } elseif (is_array($value)) {
    $callback = array_recursive_search_key_map($needle, $value);
    if ($callback) {
    return array_merge(array($first_level_key), $callback);
    }
    }
    }
    return false;
    }

    使用示例
    -------------------

    $nested_array = $sample_array = array(
    'a' => array(
    'one' => array ('aaa' => 'apple', 'bbb' => 'berry', 'ccc' => 'cantalope'),
    'two' => array ('ddd' => 'dog', 'eee' => 'elephant', 'fff' => 'fox')
    ),
    'b' => array(
    'three' => array ('ggg' => 'glad', 'hhh' => 'happy', 'iii' => 'insane'),
    'four' => array ('jjj' => 'jim', 'kkk' => 'kim', 'lll' => 'liam')
    ),
    'c' => array(
    'five' => array ('mmm' => 'mow', 'nnn' => 'no', 'ooo' => 'ohh'),
    'six' => array ('ppp' => 'pidgeon', 'qqq' => 'quail', 'rrr' => 'rooster')
    )
    );

    $search_value = 'insane';

    $array_keymap = array_recursive_search_key_map($search_value, $nested_array);

    var_dump($array_keymap);
    // 输出
    // array(3) {
    // [0]=>
    // string(1) "b"
    // [1]=>
    // string(5) "three"
    // [2]=>
    // string(3) "iii"
    //}

    ----------------------------------------------

    但是，对于上述解决方案，PHP 再次在如何动态访问嵌套数组中特定元素的值方面存在不足。为此，我编写了第二个函数来提取上面映射的值。

    function array_get_nested_value($keymap, $array)
    {
    $nest_depth = sizeof($keymap);
    $value = $array;
    for ($i = 0; $i < $nest_depth; $i++) {
    $value = $value[$keymap[$i]];
    }

    return $value;
    }

    使用示例
    -------------------
    echo array_get_nested_value($array_keymap, $nested_array); // insane
    13
    maciej at speccode dot com
    8 年前
    提醒一下，严格模式可能会为你节省数小时。

    如果你正在搜索一个字符串，并且你遇到一个 "true" 布尔值，你将得到它作为结果（第一次出现）。以下示例

    <?php

    $arr     = [
    'foo' => 'bar',
    'abc' => 'def',
    'bool' => true,
    'target' => 'xyz'
    ];

    var_dump( array_search( 'xyz', $arr ) ); //bool
    var_dump( array_search( 'xyz', $arr, true ) ); //target

    ?>
    6
    opencart dot ocfilter at gmail dot com
    2 年前
    小心！

    <?php

    var_dump    (array_search('needle', [ 0 => 0 ])); // int(0) (!)

    var_dump(array_search('needle', [ 0 => 0 ], true)); // bool(false)

    ?>

    但是，在 php 8 中

    <?php

    var_dump    (array_search('needle', [ 0 => 0 ])); // bool(false)

    ?>
    2
    yasien dot dwieb at gmail dot com
    4 年前
    当使用 array_search 来混合字符串和整数，其中键的前缀可能发生冲突时要小心，就像在我的情况下，我遇到了以下情况

    假设你拥有以下数组
    <?php
    $arr     = [
    1 => 'index 0',
    2 => 'index 1',
    3 => 'index 2',
    '3anothersuffix' => 'index 3'
    ];

    $index1 = array_search('3', array_keys($arr)); // 2
    $index2 = array_search('3anothersuffix', array_keys($arr)); //2
    ?>

    $index1 和 $index2 将是相同的

    在使用严格类型搜索之后

    <?php
    $index1     = array_search('3', array_keys($arr), true); // false
    $index2 = array_search('3anothersuffix', array_keys($arr), true); //3
    ?>

    它根本不会找到 $index1，而会为 $index2 返回正确的值；
    3
    azaozz, gmail
    15 年前
    扩展 hansen{}cointel.de 的评论

    当搜索一个字符串，并且数组包含 0（零）时，字符串会通过类型强制转换强制转换为 (int)，这始终为 0（也许相反的行为才是正确的，数组值 0 应该被强制转换为字符串）。如果未使用严格比较，这会导致意外的结果

    <?php
    $a     = array(0, "str1", "str2", "str3");
    echo     "
    str1 = "    .array_search("str1", $a).",
    str2 = "    .array_search("str2", $a).",
    str3 = "    .array_search("str3", $a).",

    str1 strict = "    .array_search("str1", $a, true).",
    str2 strict = "    .array_search("str2", $a, true).",
    str3 strict = "    .array_search("str3", $a, true);
    ?>

    这将返回
    str1 = 0, str2 = 0, str3 = 0, str1 strict = 1, str2 strict = 2, str3 strict = 3
    3
    andreas dot damm at maxmachine dot de
    16 年前
    结合 array_search() 的语法和 array_keys() 的功能，获取数组中具有给定搜索值的 key=>value 关联。
    <?php
    function array_search_values( $m_needle, $a_haystack, $b_strict = false){
    return     array_intersect_key( $a_haystack, array_flip( array_keys( $a_haystack, $m_needle, $b_strict)));
    }
    ?>

    用法
    <?php
    $array1     = array( 'pre'=>'2', 1, 2, 3, '1', '2', '3', 'post'=>2);
    print_r( array_search_values( '2', $array1));
    print_r( array_search_values( '2', $array1, true));
    print_r( array_search_values( 2, $array1, true));
    ?>

    将返回
    array(4) {
    ["pre"] =>
    string(1) "2"
    [1] =>
    int(2)
    [4] =>
    string(1) "2"
    ["post"] =>
    int(2)
    }
    array(2) {
    ["pre"] =>
    string(1) "2"
    [4] =>
    string(1) "2"
    }
    array(2) {
    [1] =>
    int(2)
    ["post"] =>
    int(2)
    }
    5
    codeslinger at compsalot dot com
    14 年前
    需要注意的是，如果 needle 是字符串，而数组本身包含数字和字符串混合的值（甚至看起来像数字的字符串），则 array_search() 会失败。

    问题在于，除非您指定“strict”，否则匹配将使用 == 完成，在这种情况下，任何字符串都将匹配数字值零，这不是您想要的。

    -----

    此外，PHP 可以非常快地查找索引。对于许多情况，维护多个数组是实用的，其中一个数组的索引是搜索键，另一个数组包含数据。

    <?php

    $normal    [$index] = array('key'=>$key, 'data'=>'foo');
    $inverse[$key] = $index;

    //非常快速的查找，这比任何其他类型的搜索都要快

    if (array_key_exists($key, $inverse))
    {
    $index = $inverse[$key];
    return     $normal[$index];
    }

    ?>
    5
    n-regen
    15 年前
    如果您只知道数组中某个值的的一部分，并且想要知道完整的 value，可以使用以下函数
    <?php
    function array_find($needle, $haystack)
    {
    foreach (    $haystack as $item)
    {
    if (    strpos($item, $needle) !== FALSE)
    {
    return     $item;
    break;
    }
    }
    }
    ?>
    该函数返回包含 $needle 的 $haystack 的第一个完整值。
    0
    helenadeus at gmail dot com
    15 年前
    我试图使用 array_search 来检索与给定 needle 相匹配的所有值，但事实证明，只返回第一个匹配键。我创建了这个小函数，它就像 array_search 一样工作，但它返回所有与给定 needle 相匹配的键。输出是一个数组。

    <?php

    $haystack     = array('a','b','a','b');

    $needle = 'a';

    print_r(array_search_all($needle, $haystack));

    //输出将是
    // Array
    // (
    // [0]=>1
    // [1]=>3
    // )

    function array_search_all($needle, $haystack)
    {    #array_search_match($needle, $haystack) 返回在 $haystack 中与 $needle 相匹配的所有值的键

    foreach ($haystack as $k=>$v) {

    if(    $haystack[$k]==$needle){

    $array[] = $k;
    }
    }
    return (    $array);


    }

    ?>
    0
    kermes [at] thesevens [dot] net
    16 年前
    以前搜索的变体，它返回一个包含与给定值匹配的键的数组。

    <?php
    function array_ksearch($array, $str)
    {
    $result = array();
    for(    $i = 0; $i < count($array); next($array), $i++)
    if(    strtolower(current($array)) == strtolower($str))
    array_push($result, key($array);

    return     $result;
    }
    ?>

    用法如下
    <?php
    $testArray     = array('one' => 'test1', 'two' => 'test2', 'three' => 'test1', 'four' => 'test2', 'five' => 'test1');
    print_r(array_ksearch($testArray, 'test1'));
    ?>
    -1
    stooshie at gmail dot com
    12 年前
    递归二分搜索的示例，它返回索引而不是布尔值。
    <?php
    // 返回 needle 在 haystack 中的索引
    function binSearch($needle, $haystack)
    {
    // 仅当计算搜索深度时才需要 n
    global $n;
    $n++;
    // 获取传递的数组长度
    $l = count($haystack);
    // 如果长度为 0，则有问题
    if($l <= 0)
    {
    return -    1;
    }
    // 获取中间元素
    $m = (($l+($l%2))/2);
    // 如果 mid >= length （例如 l=1）
    if($m >= $l)
    {
    $m = $m-1;
    }
    // 获取要与传递的元素比较的索引元素，并根据情况进行分支
    $compare = $haystack[$m];
    switch(    true)
    {
    case(    $compare>$needle):
    {
    // 在下半部分递归
    $new_haystack = array_slice($haystack, 0, $m);
    $c = count($new_haystack);
    $r = binSearch($needle, $new_haystack);
    // 返回当前索引 - （下半部分的长度 - 下半部分中找到的索引）
    return $m - ($c - $r);
    break;
    }
    case(    $compare<$needle):
    {
    // 在上半部分递归
    $new_haystack = array_slice($haystack, $m, ($l-$m));
    $c = count($new_haystack);
    $r = binSearch($needle, $new_haystack);
    // 返回当前位置 + 上半部分中找到的索引
    return $m + $r;
    break;
    }
    case(    $compare==$needle):
    {
    // 找到了，所以返回索引
    return $m;
    break;
    }
    }
    }
    ?>
    -1
    nordseebaer at gmx dot de
    4 年前
    检查返回值是否为假非常重要！我使用 array_search() 来确定要取消设置的值的索引，然后意识到 $arr[false] === $arr[0]！

    <?php
    $arr     = ['apple', 'banana'];

    var_dump($arr[0] === 'apple'); // true
    var_dump($arr[false] === $arr[0]); // true
    var_dump($arr[false] === 'apple'); // true

    unset($arr[array_search('banana', $arr)]); //index = 1
    var_dump($arr);

    // 结果
    // array(1) {
    // [0]=>
    // string(5) "apple"
    // }

    unset($arr[array_search('peach', $arr)]); // 未找到，结果为 false
    var_dump($arr);

    // 结果
    // array(0) {
    // }
    // 因为 $arr[false] === $arr[0]
    ?>

    所以始终检查 array_search 的返回值！
    ＋添加说明
    To Top