// isn't a comment in Perl. It's the defined-or operator. It's an infix operator, so it comes between two operands. If the left operand evaluates to a defined value, the operator produces the left operand's value. If the left operand evaluates to an undefined value, the operator produces the right operand's value.

In other words, shift off the first parameter to the function and assign its value to $it. If that's not a defined value, assign the value of $foo to $it instead.

C-style Logical Defined-Or
       Although it has no direct equivalent in C, Perl's "//" operator
+ is
       related to its C-style or.  In fact, it's exactly the same as "
+||",
       except that it tests the left hand side's definedness instead o
+f its
       truth.  Thus, "$a // $b" is similar to "defined($a) || $b" (exc
+ept that
       it returns the value of $a rather than the value of "defined($a
+)") and
       yields the same result as "defined($a) ? $a : $b" (except that 
+the
       ternary-operator form can be used as a lvalue, while "$a // $b"
       cannot).  This is very useful for providing default values for
       variables.  If you actually want to test if at least one of $a 
+and $b
       is defined, use "defined($a // $b)".

       The "||", "//" and "&&" operators return the last value evaluat
+ed
       (unlike C's "||" and "&&", which return 0 or 1). Thus, a reason
+ably
       portable way to find out the home directory might be:

           $home =  $ENV{HOME}
                 // $ENV{LOGDIR}
                 // (getpwuid($<))[7]
                 // die "You're homeless!\n";

       In particular, this means that you shouldn't use this for selec
+ting
       between two aggregates for assignment:

           @a = @b || @c;              # this is wrong
           @a = scalar(@b) || @c;      # really meant this
           @a = @b ? @b : @c;          # this works fine, though

       As more readable alternatives to "&&" and "||" when used for co
+ntrol
       flow, Perl provides the "and" and "or" operators (see below).  
+The
       short-circuit behavior is identical.  The precedence of "and" a
+nd "or"
       is much lower, however, so that you can safely use them after a
+ list
       operator without the need for parentheses:

           unlink "alpha", "beta", "gamma"
                   or gripe(), next LINE;

       With the C-style operators that would have been written like th
+is:

           unlink("alpha", "beta", "gamma")
                   || (gripe(), next LINE);

       Using "or" for assignment is unlikely to do what you want; see 
+below.
[download]

my $it;
$it = shift;
defined $it or $it = $foo;
[download]

Are you sure this is a typo? It seems to me that the author knew exactly what the code was supposed to do. Using "//" like this is a common idiom to have "default arguments".

If the "$foo" was meant to be a comment, then what should be in "$it"? An undefined "$it" would produce a warning.

some Perl code which was written by a, shall we say, Perl non-expert.

Possibly not an expert, but probably not a total newbie either. ;-)

Nice trick. I think I'll be taking that one home today.

Take it home and use it, certainly, but don't leave that loaded global variable lying around where it can hurt someone!

>perl -wMstrict -le
"use constant FOO => 'bar';
 ;;
 DoIt();
 ;;
 sub DoIt {
   my $it = shift // FOO;
   print qq{it is '$it'};
   }
"
it is 'bar'
[download]