如何使用功能标志？

Question

我想创建一个类并扩展PHP类FilesystemIterator,如下面的代码所示.我定义了一个方法hasFlag()并测试它是否包含一个标志(我希望它像其他一些PHP函数,例如.glob),但结果总是与预期不同.那么我该如何解决这个问题呢？

class c extends FilesystemIterator 
{
    /* These are parent constants */
    const CURRENT_AS_FILEINFO  = 0 ;
    const KEY_AS_PATHNAME      = 0 ;
    const CURRENT_AS_SELF      = 16 ;
    const CURRENT_AS_PATHNAME  = 32 ;
    const CURRENT_MODE_MASK    = 240 ;
    const KEY_AS_FILENAME      = 256 ;
    const NEW_CURRENT_AND_KEY  = 256 ;
    const FOLLOW_SYMLINKS      = 512 ;
    const KEY_MODE_MASK        = 3840 ;
    const SKIP_DOTS            = 4096 ;
    const UNIX_PATHS           = 8192 ;

    public function __construct($flags) {
        $this->flags = $flags;
    }
    public function hasFlag($flag) {
        //How do I test $this->flags it contains a $flag???
        return ($this->flags & $flag) ? true : false;
    }
}

$c = new c(
    c::CURRENT_AS_FILEINFO | 
    c::KEY_AS_PATHNAME | 
    c::CURRENT_AS_SELF |
    c::CURRENT_AS_PATHNAME |
    c::CURRENT_MODE_MASK |
    c::KEY_AS_FILENAME  |
    c::NEW_CURRENT_AND_KEY |
    c::FOLLOW_SYMLINKS |
    c::KEY_MODE_MASK |
    c::SKIP_DOTS |
    c::UNIX_PATHS
);

var_dump($c->hasFlag(c::CURRENT_AS_FILEINFO));

编辑1

为什么会这样？

var_dump( ((0 | 16 | 32 | 240 | 3840) & 0)    == 0 );    //true
var_dump( ((0 | 16 | 32 | 240 | 3840) & 32)   == 32 );   //true
var_dump( ((0 | 16 | 32 | 240 | 3840) & 240)  == 240 );  //true
var_dump( ((0 | 16 | 32 | 240 | 3840) & 1024) == 1024 ); //true??
var_dump( ((0 | 16 | 32 | 240 | 3840) & 2048) == 2048 ); //true??
var_dump( ((0 | 16 | 32 | 240 | 3840) & 3840) == 3840 ); //true

Answer 1

关于默认值和掩码

有一些特殊的标志FilesystemIterator,被称为面具; 它们将多个相关的标志组合在一起(或者在这种情况下,相互排斥)并且不应该作为常规标志传递; 下面是他们的二进制表示:

000x00xx0000
+--++--+
   |   |
   |   +---- CURRENT_MODE_MASK
   |
   +-------- KEY_MODE_MASK

这些标志用于确定是否应使用默认值key()和current()方法.这两个方法的默认值定义如下:

const CURRENT_AS_FILEINFO  = 0 ;
const KEY_AS_PATHNAME      = 0 ;

以下代码说明了如何测试它:

if ($flags & CURRENT_MODE_MASK == 0) {
    // CURRENT_AS_FILEINFO is used
} else {
    // either CURRENT_AS_PATHNAME, CURRENT_AS_SELF or CURRENT_AS_PATHNAME is used
}

if ($flags & KEY_MODE_MASK == 0) {
    // KEY_AS_PATHNAME is used
} else {
    // KEY_AS_FILENAME is used
}

有这样一个功能的问题->hasFlag()是你无法区分这两个默认值,即你想测试CURRENT_AS_FILEINFO还是KEY_AS_PATHNAME？你必须重新考虑逻辑.

关于互斥旗帜

有一些标志不能一起使用,因为它们会导致未定义的行为; 例如:

const CURRENT_AS_SELF      = 16 ;
const CURRENT_AS_PATHNAME  = 32 ;

您无法定义两种类型的行为current(),应使用其中一种(或默认值).一组兼容的标志可能是这样的:

$c = new c(
    c::CURRENT_AS_SELF |
    c::KEY_AS_FILENAME  |
    c::FOLLOW_SYMLINKS |
    c::SKIP_DOTS |
    c::UNIX_PATHS
);

关于扩展课程

假设您的构造函数与父代相同,则可以完全删除构造函数:

class c extends FilesystemIterator 
{
    public function hasFlag($flag)
    {
        $flags = $this->getFlags(); // use parent function here
        // logic here
    }
}

Answer 2

我觉得你并不真正了解按位运算符 |和&你正在使用的.这样做是比较bitlevel上的输入和改变位.因此,要理解,您需要将所有值放在其二进制格式中并进行检查.|当其中一个位为1时,运算符将位&设置为1,当两个位均为1时,运算符将其设置为1.

取数字2和4.使用 |

2: 0010
4: 0100
--------
6: 0110

运用 &

2: 0010
4: 0100
--------
0: 0000

所以在你的构造函数中,你只是将所有数字加在一起,并且$this->flags将包含一个整数

c::CURRENT_AS_FILEINFO | 
c::KEY_AS_PATHNAME | 
c::CURRENT_AS_SELF |
c::CURRENT_AS_PATHNAME |
c::CURRENT_MODE_MASK |
c::KEY_AS_FILENAME  |
c::NEW_CURRENT_AND_KEY |
c::FOLLOW_SYMLINKS |
c::KEY_MODE_MASK |
c::SKIP_DOTS |
c::UNIX_PATHS

将转化为

0    : 00000000000000
0    : 00000000000000
16   : 00000000010000
240  : 00000011110000  //notice this one. It doesnt change 1 bit, but multiple.
256  : 00000100000000
256  : 00000100000000
512  : 00001000000000
3840 : 00111100000000  //notice this one. It doesnt change 1 bit, but multiple.
4096 : 01000000000000
8192 : 10000000000000
---------------------
16368: 11111111110000

所以你的$this->flags包含16368.

现在为了你的var_dump测试,我会遗漏所有的确切位,但你正在制作类似的东西:

var_dump( ((0 | 16 | 32 | 240 | 3840) & 0)    == 0 );    //true
var_dump( ((4080) & 0)    == 0 );    //true

4080: 111111110000
0   : 000000000000
------------------ &
0   : 000000000000 //nowhere are both bits a 1 so the output is 0

所以结果你的var_dump声明变成了:

var_dump( (4080 & 0)    == 0 );
var_dump( (4080 & 32)   == 32 );
var_dump( (4080 & 240)  == 240 );
var_dump( (4080 & 1024) == 1024 );
var_dump( (4080 & 2048) == 2048 );
var_dump( (4080 & 3840) == 3840 );

    //which is also..
var_dump( 0    == 0 );
var_dump( 32   == 32 );
var_dump( 240  == 240 );
var_dump( 1024 == 1024 );
var_dump( 2048 == 2048 );
var_dump( 3840 == 3840 );

    //which obvisouly is true on all accounts.

现在回到你的hasFlag功能.请记住,你的$this->flags包含16368或11111111110000.现在,如果只取右边的位,10000你将得到数字16.如果你在左边添加一个并将所有其他位改为0,你会得到100000000000000哪个转换为16384.

结果:16到16384之间的任何数字,转换为二进制,在它的标志有一个1的同一位置上至少有一个1.所以,return ($this->flags & $flag)将成为所有这些数字如此.

由于您无法在父项中创建标记,因此需要使用不同的方法来检查标记是否为真.在这种情况下,您需要确保$this->flags & $flag匹配标志的结果.因为只有这样结果才是真的所以它会成为

return ($this->flags & $flag) == $flag;

仅供参考:

如果您可以自己设置标记并且没有任何复合标记,则可以使所有标记的幂为2且不同.这样,每个标志将对应于二进制格式的单个位置,因此具有"是/否"设置.

const CURRENT_AS_FILEINFO  = 2 ;
const KEY_AS_PATHNAME      = 4 ;
const CURRENT_AS_SELF      = 8 ;
const CURRENT_AS_PATHNAME  = 16 ;
const CURRENT_MODE_MASK    = 32 ;
const KEY_AS_FILENAME      = 64 ;
const NEW_CURRENT_AND_KEY  = 128 ;
const FOLLOW_SYMLINKS      = 256 ;
const KEY_MODE_MASK        = 512 ;
const SKIP_DOTS            = 1024 ;
const UNIX_PATHS           = 2048 ;

或者以二进制形式,这样你就可以看到每个位都有自己的位置(注意你可以从1,2,4等开始也使用右边的第一位):

const CURRENT_AS_FILEINFO   = 000000000010; 
const KEY_AS_PATHNAME       = 000000000100; 
const CURRENT_AS_SELF       = 000000001000; 
const CURRENT_AS_PATHNAME   = 000000010000; 
const CURRENT_MODE_MASK     = 000000100000; 
const KEY_AS_FILENAME       = 000001000000; 
const NEW_CURRENT_AND_KEY   = 000010000000; 
const FOLLOW_SYMLINKS       = 000100000000; 
const KEY_MODE_MASK         = 001000000000; 
const SKIP_DOTS             = 010000000000; 
const UNIX_PATHS            = 100000000000; 

现在您可以在创建它时使用标志功能.因为只有实际使用构造函数设置了一个标志,它才会被接受.

Answer 3

只需使用：

(($this->flags & $flag) === $flag)

例子：

class Test
{
    /* These are parent constants */
    const FLAG_A = 1;  // binary 01
    const FLAG_B = 2;  // binary 10

    public function __construct($flags) {
        $this->flags = $flags;
    }   
    public function hasFlag($flag) {
        return (($this->flags & $flag) === $flag) ? true : false;
    }   
}


$t = new Test(Test::FLAG_A | Test::FLAG_B);
var_dump($t->hasFlag(Test::FLAG_A)); # bool(true)
var_dump($t->hasFlag(Test::FLAG_A)); # bool(true)

$t = new Test(Test::FLAG_A);
var_dump($t->hasFlag(Test::FLAG_A)); # bool(true)
var_dump($t->hasFlag(Test::FLAG_B)); # bool(false)

$t = new Test(Test::FLAG_B);
var_dump($t->hasFlag(Test::FLAG_A)); # bool(false)
var_dump($t->hasFlag(Test::FLAG_B)); # bool(true)

解释：

$flags想象一下，这是当前设置为的二进制表示CURRENT_AS_PATHNAME | CURRENT_AS_SELF（二进制表示缩短）：

...110000

您现在尝试检查该标志是否CURRENT_AS_SELF处于活动状态。CURRENT_AS_SELF二进制表示如下：

...010000

如果您现在应用该logical AND运算符，&则只有在两个操作数中设置的位才会在结果中设置。什么给你：

...010000

这与旗帜相同。这就是为什么=== $flag

另请注意@mario 的答案，我的二进制标志与值0没有任何意义