如何使用函数标志

关于默认值和掩码

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

我觉得你并不真正理解你正在使用的|和&位运算符。它所做的是在位级上比较输入并改变位。因此，为了理解，您需要将所有值放入二进制格式并进行检查。|运算符在任意一位为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。如果你在左边加一个1，然后把其他的位都换成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; 

现在你可以使用你创建的标志函数了。因为只有在构造函数中实际设置了一个标志，它才会被接受。

你的问题是这里的声明:

 const CURRENT_AS_FILEINFO  = 0 

当将位标志定义为0时，它永远不可能出现在位掩码上。

直接使用:

(($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的二进制标志没有意义

你在试图用一种假设它们是2的幂的方式来使用不是2的幂的东西。

您感到困惑的行可以用十六进制重写为

var_dump( ((0 | 0x10 | 0x20 | 0xf0 | 0xf00) & 0x400) == 0x400 ); //true??
var_dump( ((0 | 0x10 | 0x20 | 0xf0 | 0xf00) & 0x800) == 0x800 ); //true??

一旦你意识到:

0xf00 = (0x800 + 0x400 + 0x200 + 0x100)

很明显为什么0xf00 &0x400 == 0x400为真。您不能像当前那样使用这些标志来进行简单的测试，以确定它们是否有效。

我想你应该只检查定义的确切标志，而不是任意的数字。

编辑

嗯-我明白你的意思。似乎有些标志与out标志不兼容，因为它们冲突，例如

const KEY_AS_FILENAME      = 256 ;
const NEW_CURRENT_AND_KEY  = 256 ;

所以不能单独设置和测试——这很奇怪。

我试过阅读FileIterator的源代码-它在https://github.com/php/php-src/blob/master/ext/spl/spl_directory.c。然而，它不是很容易阅读。

我认为在类之外使用这些标志可能不是一个好主意。