Click above to get retro games delivered to your door ever month!

     -x      A file test.  This unary operator  takes  one  argu-
             ment,  either  a filename or a filehandle, and tests
             the associated file to  see  if  something  is  true
             about  it.   If  the  argument is omitted, tests $_,
             except for -t, which tests STDIN.  It returns 1  for
             true and '' for false, or the undefined value if the
             file doesn't exist.  Precedence is higher than logi-
             cal  and relational operators, but lower than arith-
             metic operators.  The operator may be any of:

                  -r   File is readable by effective uid.
                  -w   File is writable by effective uid.
                  -x   File is executable by effective uid.
                  -o   File is owned by effective uid.
                  -R   File is readable by real uid.
                  -W   File is writable by real uid.
                  -X   File is executable by real uid.
                  -O   File is owned by real uid.
                  -e   File exists.
                  -z   File has zero size.
                  -s   File has non-zero size (returns size).
                  -f   File is a plain file.
                  -d   File is a directory.
                  -l   File is a symbolic link.
                  -p   File is a named pipe (FIFO).
                  -S   File is a socket.
                  -b   File is a block special file.
                  -c   File is a character special file.
                  -u   File has setuid bit set.
                  -g   File has setgid bit set.
                  -k   File has sticky bit set.
                  -t   Filehandle is opened to a tty.
                  -T   File is a text file.
                  -B   File is a binary file (opposite of -T).
                  -M   Age of file in days when script started.
                  -A   Same for access time.
                  -C   Same for inode change time.

             The interpretation of the file permission  operators
             -r,  -R,  -w,  -W,  -x and -X is based solely on the
             mode of the file and the uids and gids of the  user.
             There  may be other reasons you can't actually read,
             write or execute the file.  (Note that  serveral  of
             the above don't mean much under MS-DOS.)

             Example:

                  while (<>) {
                       chop;
                       next unless -f $_;  # ignore specials
                       ...
                  }

             Note that -s/a/b/ does not do  a  negated  substitu-
             tion.   Saying  -exp($foo)  still works as expected,
             however--only single letters following a  minus  are
             interpreted as file tests.

             The -T and -B switches work as follows.   The  first
             block  or so of the file is examined for odd charac-
             ters such as strange control  codes  or  metacharac-
             ters.   If too many odd characters (>10%) are found,
             it's a -B file, otherwise it's a -T file.  Also, any
             file  containing  null  in  the  first block is con-
             sidered a binary file.  If -T or -B  is  used  on  a
             filehandle,  the  current  stdio  buffer is examined
             rather than the first block.  Both -T and -B  return
             TRUE on a null file, or a file at EOF when testing a
             filehandle.

     If any of the file tests (or either stat operator) are given
     the  special  filehandle consisting of a solitary underline,
     then the stat structure of the previous file test  (or  stat
     operator) is used, saving a system call.  (This doesn't work
     with -t, and you need to remember that  lstat  and  -l  will
     leave  values  in  the stat structure for the symbolic link,
     not the real file.)  Example:

          print "Can do.\n" if -r $a || -w _ || -x _;

          stat($filename);
          print "Readable\n" if -r _;
          print "Writable\n" if -w _;
          print "Executable\n" if -x _;
          print "Setuid\n" if -u _;
          print "Setgid\n" if -g _;
          print "Sticky\n" if -k _;
          print "Text\n" if -T _;
          print "Binary\n" if -B _;