Fatal编程技术网
  • php/
  • Php 从另一个函数在数组中进行引用检测

Php 从另一个函数在数组中进行引用检测

php arrays loops reference

Php 从另一个函数在数组中进行引用检测,php,arrays,loops,reference,Php,Arrays,Loops,Reference,所以我使用的是pin方法，但检测到参考值的时间太晚了一个级别： $pin = time(); function wrap($arr){ test($arr); } function test(&$arr){ global $pin; if(in_array($pin, $arr)) return print "ref"; $arr[] = $pin; foreach($arr as &$v){ if(

所以我使用的是pin方法，但检测到参考值的时间太晚了一个级别：

$pin = time();

function wrap($arr){
  test($arr);
}

function test(&$arr){
    global $pin;

    if(in_array($pin, $arr))
        return print "ref";

    $arr[] = $pin;

    foreach($arr as &$v){

        if($v != $pin){

            if(is_array($v))
                return test($v);

            print $v . " ";

      }

    }

}

$array = array(1, 2, 3);
$array[4] = &$array;

wrap($array);
我得到
123rec

但我希望
123rec

如果我只做
test（$arr）
，那么它可以工作，但问题是我需要将测试函数包装到另一个接受值而不是引用的函数中：(

有什么方法可以让我的包装函数在适当的时候检测到引用吗？

我认为你把事情复杂化了。我通过循环数组并检查数组中的当前值是否与数组相等（
==
）来解决这个问题

function wrap( $arr){
    test($arr);
}

function test( $arr){
    foreach( $arr as $v) {
        if( $v === $arr) { 
            print 'ref, ';
        } else {
            if( is_array( $v)) { 
                test( $v); 
            } else {
                print $v . ', ';
            }
        }
    }
}
我使用了以下测试用例：

echo "Array 1:\n";
$array1 = array(1, 2, 3);
$array1[4] = &$array1;
wrap( $array1);

echo "\nArray 2:\n";
$array2 = array(1, 2, 3, array(1, 2, 3));
$array2[2] = &$array2;
wrap( $array2);
其中：

但是，对于嵌套引用，上述方法将失败。如果嵌套引用是可能的，如以下测试用例中所示：

echo "\nArray 3:\n";
$array3 = array(1, 2, 3, array(1, 2, 3));
$array3[3][2] = &$array3;
wrap( $array3);
然后我们需要跟踪我们看到的所有数组引用，如下所示：

function wrap( $arr){
    test( $arr);
}

function test( $arr){
    $refs = array(); // Array of references that we've seen

    $f = function( $arr) use( &$refs, &$f) {
        $refs[] = $arr;
        foreach( $arr as $v) {
            if( in_array( $v, $refs)) { 
                print 'ref, ';
            } else {
                if( is_array( $v)) {
                    $f( $v); 
                } else {
                    print $v . ', ';
                }
            }
        }
    };
    $f( $arr);
}
使用上述测试用例，这将输出：

Array 3: 
1, 2, 3, 1, ref, 3,
编辑：我已经更新了跟踪所有引用的最终函数，以消除全局依赖关系。

简介

/**
 * Added printf since test now returns array
 * @param array $arr
 */
function wrap(array $arr) {
    printf("<pre>%s<pre>", print_r(test($arr), true));
}


/**
 * - Removed Top Refrence
 * - Removed Global
 * - Add Recursion
 * - Returns array
 * @param array $arr
 * @return array
 */
function test(array $arr) {
    $temp = $arr;
    foreach ( $arr as $key => &$v ) {
        if (is_array($v)) {
            $temp[$key]['_PIN_'] = true;
            $v = isset($arr[$key]['_PIN_']) ? "ref" : test($v);
        }
    }
    unset($temp); // cleanup
    return $arr;
}
我认为更好的方法是创建数组的副本并比较修改，而不是使用全局pin，它仍然可以是
100%递归的

示例1

这是您上面的示例：

$array = array(1,2,3);
$array[4] = &$array;
wrap($array);
输出

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [4] => ref
)
示例2

我们真的确定它是检测引用还是数组的副本

//Case 1 : Expect no modification
$array = array(1, 2, 3, array(1, 2, 3));
wrap( $array);

//Case 2 : Expect Modification in Key 2
$array = array(1, 2, 3, array(1, 2, 3));
$array[2] = &$array;
wrap( $array);
输出

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

)
Array
(
    [0] => 1
    [1] => 2
    [2] => ref
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

)

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

    [4] => Array
        (
            [4] => Array
                (
                    [2] => Array
                        (
                            [6] => Array
                                (
                                    [1] => Array
                                        (
                                            [0] => 1
                                            [1] => 2
                                            [3] => ref   <-- GOT YOU
                                        )

                                )

                        )

                )

        )

)
示例3

这真的是递归的吗

$array = array(1, 2, 3, array(1, 2, 3));
$array[4][4][2][6][1] = array(1,2,3=>&$array);
wrap( $array);
输出

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

)
Array
(
    [0] => 1
    [1] => 2
    [2] => ref
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

)

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

    [4] => Array
        (
            [4] => Array
                (
                    [2] => Array
                        (
                            [6] => Array
                                (
                                    [1] => Array
                                        (
                                            [0] => 1
                                            [1] => 2
                                            [3] => ref   <-- GOT YOU
                                        )

                                )

                        )

                )

        )

)

数组
(
[0] => 1
[1] => 2
[2] => 3
[3] =>阵列
(
[0] => 1
[1] => 2
[2] => 3
)
[4] =>阵列
(
[4] =>阵列
(
[2] =>阵列
(
[6] =>阵列
(
[1] =>阵列
(
[0] => 1
[1] => 2
[3] =>参考和$v）{
if（is_数组（$v））{
$temp[$key][''u PIN']=true；
$v=isset（$arr[$key][''U PIN']]？“ref”：测试（$v）；
}
}
取消设置（$temp）；//清除
返回$arr；
}
调用
wrap（）中的
test（）
函数时，您的
wrap（）函数为
$arr
分配新的内存块
s主体，它引用了
$arr
内存块，但不是
$array
s内存块，因为
$arr
是
$array
的副本，PHP内存管理系统将它们分开存储



有一个通用的参考点定位功能：


1   // < $arr
2
3
1   // < $array
2
3
ref // < $array doubled -> reference found


因此，让我们做一些测试：


function wrap($arr){
    $arr[] = &$arr;

    test($arr);
}


结果将是：


1
2
3
ref


这表明：


1 2 3 ref
1 2 3 4 5 6 ref
1 2 3 a b c ref
1 2 3 4 5
1 2 3 1 2 3 4 5 2 3 6 1 2 3 7 1 2 3
1 2 3 1 2 3 ref 4 5 2 3 ref 6 1 2 3 7 1 2 3 ref




2） “将所有内容包装成数组或对象”“实践：（首选且可靠）


$pin
从不更改，这是故意的吗？是的。它应该用来比较两个数组是否是同一个变量。@Alex autodetect？我不这么认为，只是：
函数换行（&$arr）
。简短回答：不。只要您通过值传递输入，内部引用就不再是传递的结构，而是传递给原始的外部结构。唯一可行的方法是通过引用传递，如果您这样做，那么我会让您参考my，以检测两个给定变量是否相互引用。我会重写整个方法时，请将其废弃，这有太多问题：）它不应该在引用后返回。它应该只打印'ref'并继续下一个元素…@Alex-我已经更新了我的答案并清理了这篇文章上的评论。如果它没有达到您的预期效果，请告诉我。您的解决方案仍然会对数组产生误报，例如：
$array=array（1，2，array（1，2），数组（1，2））；
。顺便说一句，我看到了你在那里做的事情。@Yoshi-Crap，很害怕。但是由于你对全局变量提出了如此令人信服的论点，我不得不重构它们。。）

1   // < $arr
2
3
ref // < $arr doubled -> reference found



<?php
header('Content-Type: text/plain');

function is_equal_refs(&$a, &$b){
    $buffer = $a;

    $a = md5(time());

    $result = ($a === $b);

    $a = $buffer;

    return $result;
}

function wrap($array){
    global $check; // <- THIS

    test(empty($check) ? $array : $check); // <- THIS
}

function test(&$arr){
    foreach($arr as &$v){

        if(is_equal_refs($v, $arr)){
            print_r('ref');
            echo PHP_EOL;
            break;
        }

        if(is_array($v)){
            test($v);
        } else {
            print $v . ' ';
            echo PHP_EOL;
        }
    }
}

$array   = array(1, 2, 3);
$array[] = &$array;
$check   = &$array; // <- and THIS

wrap($array);
?>



1
2
3
ref



<?php
header('Content-Type: text/plain');

define('REF_MARKER', 'x-my-tr!cky-ref'); // trick key definition

function is_equal_refs(&$a, &$b){
        $buffer = $a;

        $a = md5(time());

        $result = ($a === $b);

        $a = $buffer;

        return $result;
    }

function wrap(array $arr){
        // restore reference, if trick.
        // it might be moved to the top part of test() function (might affect performance).
        if(isset($arr[REF_MARKER]))$arr = &$arr[REF_MARKER];

        test($arr);
    }

// $array - subject to test;
// $refs  - internal ref list of all `subjects`;
function test(&$array, $refs = array()){
        $refs[] = &$array;

        foreach($array as &$value){

            foreach($refs as &$ref){
                if(is_equal_refs($ref, $value))return print 'ref ';
            }

            if(is_array($value)){
                $refs[] = &$value;

                test($value, $refs);
            } else {
                print $value . ' ';
            }
        }
    }

$array   = array(1, 2, 3);
$array[] = &$array;

wrap(array(REF_MARKER => &$array)); // trick

print PHP_EOL;

$ring      = array(1, 2, 3, array(4, 5, 6));
$ring[3][] = &$ring;

wrap(array(REF_MARKER => &$ring)); // trick

print PHP_EOL;

$test = array('a', 'b', 'c');
$ring = array(1, 2, 3);

$ring[] = &$test;
$test[] = &$ring;

wrap(array(REF_MARKER => &$ring)); // trick

print PHP_EOL;

wrap(range(1, 5)); // normal

print PHP_EOL;

$test = array(1, 2, 3, array(1, 2, 3), 4, array(5, 2, 3), array(6, array(1, 2, 3), 7), array(1, 2, 3));

wrap($test); // normal

print PHP_EOL;

$test[]    = &$test;
$test[3][] = &$test;
$test[5][] = &$test[3];

wrap(array(REF_MARKER => &$test)); // trick
?>



1 2 3 ref
1 2 3 4 5 6 ref
1 2 3 a b c ref
1 2 3 4 5
1 2 3 1 2 3 4 5 2 3 6 1 2 3 7 1 2 3
1 2 3 1 2 3 ref 4 5 2 3 ref 6 1 2 3 7 1 2 3 ref