- NAME
- DESCRIPTION
  - Awk Traps
  - C/C++ Traps
  - JavaScript Traps
  - Sed Traps
  - Shell Traps
  - Perl Traps

# NAME

perltrap - Perl traps for the unwary

# DESCRIPTION

The biggest trap of all is forgetting to `use warnings` or use the -w switch; see warnings and perlrun. The second biggest trap is not making your entire program runnable under `use strict`. The third biggest trap is not reading the list of changes in this version of Perl; see perldelta.

## Awk Traps

Accustomed awk users should take special note of the following:

- A Perl program executes only once, not once for each input line. You can do an implicit loop with `-n` or `-p`.

- The English module, loaded via

          use English;

  allows you to refer to special variables (like `$/`) with names (like $RS), as though they were in awk; see perlvar for details.

- Semicolons are required after all simple statements in Perl (except at the end of a block). Newline is not a statement delimiter.

- Curly brackets are required on `if`s and `while`s.

- Variables begin with "$", "@" or "%" in Perl.

- Arrays index from 0. Likewise string positions in substr() and index().

- You have to decide whether your array has numeric or string indices.

- Hash values do not spring into existence upon mere reference.

- You have to decide whether you want to use string or numeric comparisons.

- Reading an input line does not split it for you. You get to split it to an array yourself. And the split() operator has different arguments than awk's.

- The current input line is normally in $_, not $0. It generally does not have the newline stripped. ($0 is the name of the program executed.) See perlvar.

- $<digit> does not refer to fields--it refers to substrings matched by the last match pattern.

- The print() statement does not add field and record separators unless you set `$,` and `$\`. You can set $OFS and $ORS if you're using the English module.

- You must open your files before you print to them.

- The range operator is "..", not comma. The comma operator works as in C.

- The match operator is "=~", not "~". ("~" is the one's complement operator, as in C.)

- The exponentiation operator is "**", not "^". "^" is the XOR operator, as in C. (You know, one could get the feeling that awk is basically incompatible with C.)

- The concatenation operator is ".", not the null string. (Using the null string would render `/pat/ /pat/` unparsable, because the third slash would be interpreted as a division operator--the tokenizer is in fact slightly context sensitive for operators like "/", "?", and ">". And in fact, "." itself can be the beginning of a number.)

- The `next`, `exit`, and `continue` keywords work differently.

- The following variables work differently:

            Awk       Perl
            ARGC      scalar @ARGV (compare with $#ARGV)
            ARGV[0]   $0
            FILENAME  $ARGV
            FNR       $. - something
            FS        (whatever you like)
            NF        $#Fld, or some such
            NR        $.
            OFMT      $#
            OFS       $,
            ORS       $\
            RLENGTH   length($&)
            RS        $/
            RSTART    length($`)
            SUBSEP    $;

- You cannot set $RS to a pattern, only a string.

- When in doubt, run the awk construct through a2p and see what it gives you.

## C/C++ Traps

Cerebral C and C++ programmers should take note of the following:

- Curly brackets are required on `if`'s and `while`'s.

- You must use `elsif` rather than `else if`.

- The `break` and `continue` keywords from C become in Perl `last` and `next`, respectively. Unlike in C, these do not work within a `do { } while` construct. See "Loop Control" in perlsyn.

- The switch statement is called `given`/`when` and only available in perl 5.10 or newer. See "Switch Statements" in perlsyn.

- Variables begin with "$", "@" or "%" in Perl.

- Comments begin with "#", not "/*" or "//". Perl may interpret C/C++ comments as division operators, unterminated regular expressions or the defined-or operator.

- You can't take the address of anything, although a similar operator in Perl is the backslash, which creates a reference.

- `ARGV` must be capitalized. `$ARGV[0]` is C's `argv[1]`, and `argv[0]` ends up in `$0`.

- System calls such as link(), unlink(), rename(), etc. return nonzero for success, not 0. (system(), however, returns zero for success.)

- Signal handlers deal with signal names, not numbers. Use `kill -l` to find their names on your system.

## JavaScript Traps

Judicious JavaScript programmers should take note of the following:

- In Perl, binary `+` is always addition. `$string1 + $string2` converts both strings to numbers and then adds them. To concatenate two strings, use the `.` operator.

- The `+` unary operator doesn't do anything in Perl. It exists to avoid syntactic ambiguities.

- Unlike `for...in`, Perl's `for` (also spelled `foreach`) does not allow the left-hand side to be an arbitrary expression. It must be a variable:

         for my $variable (keys %hash) {
              ...
         }

  Furthermore, don't forget the `keys` in there, as `foreach my $kv (%hash) {}` iterates over the keys and values, and is generally not useful ($kv would be a key, then a value, and so on).

- To iterate over the indices of an array, use `foreach my $i (0 .. $#array) {}`. `foreach my $v (@array) {}` iterates over the values.

- Perl requires braces following `if`, `while`, `foreach`, etc.

- In Perl, `else if` is spelled `elsif`.

- `? :` has higher precedence than assignment. In JavaScript, one can write:

          condition ? do_something() : variable = 3

  and the variable is only assigned if the condition is false. In Perl, you need parentheses:

          $condition ? do_something() : ($variable = 3);

  Or just use `if`.

- Perl requires semicolons to separate statements.

- Variables declared with `my` only affect code after the declaration. You cannot write `$x = 1; my $x;` and expect the first assignment to affect the same variable. It will instead assign to an `$x` declared previously in an outer scope, or to a global variable.

  Note also that the variable is not visible until the following statement. This means that in `my $x = 1 + $x` the second $x refers to one declared previously.

- `my` variables are scoped to the current block, not to the current function. If you write `{my $x;} $x;`, the second `$x` does not refer to the one declared inside the block.

- An object's members cannot be made accessible as variables. The closest Perl equivalent to `with(object) { method() }` is `for`, which can alias `$_` to the object:

          for ($object) {
              $_->method;
          }

- The object or class on which a method is called is passed as one of the method's arguments, not as a separate `this` value.

## Sed Traps

Seasoned sed programmers should take note of the following:

- A Perl program executes only once, not once for each input line. You can do an implicit loop with `-n` or `-p`.

- Backreferences in substitutions use "$" rather than "\".

- The pattern matching metacharacters "(", ")", and "|" do not have backslashes in front.

- The range operator is `...`, rather than comma.

## Shell Traps

Sharp shell programmers should take note of the following:

- The backtick operator does variable interpolation without regard to the presence of single quotes in the command.

- The backtick operator does no translation of the return value, unlike csh.

- Shells (especially csh) do several levels of substitution on each command line. Perl does substitution in only certain constructs such as double quotes, backticks, angle brackets, and search patterns.

- Shells interpret scripts a little bit at a time. Perl compiles the entire program before executing it (except for `BEGIN` blocks, which execute at compile time).

- The arguments are available via @ARGV, not $1, $2, etc.

- The environment is not automatically made available as separate scalar variables.

- The shell's `test` uses "=", "!=", "<" etc for string comparisons and "-eq", "-ne", "-lt" etc for numeric comparisons. This is the reverse of Perl, which uses `eq`, `ne`, `lt` for string comparisons, and `==`, `!=` `<` etc for numeric comparisons.

## Perl Traps

Practicing Perl Programmers should take note of the following:

- Remember that many operations behave differently in a list context than they do in a scalar one. See perldata for details.

- Avoid barewords if you can, especially all lowercase ones. You can't tell by just looking at it whether a bareword is a function or a string. By using quotes on strings and parentheses on function calls, you won't ever get them confused.

- You cannot discern from mere inspection which builtins are unary operators (like chop() and chdir()) and which are list operators (like print() and unlink()). (Unless prototyped, user-defined subroutines can only be list operators, never unary ones.) See perlop and perlsub.

- People have a hard time remembering that some functions default to $_, or @ARGV, or whatever, but that others which you might expect to do not.

- The <FH> construct is not the name of the filehandle, it is a readline operation on that handle. The data read is assigned to $_ only if the file read is the sole condition in a while loop:

          while (<FH>)      { }
          while (defined($_ = <FH>)) { }..
          <FH>;  # data discarded!

- Remember not to use `=` when you need `=~`; these two constructs are quite different:

          $x =  /foo/;
          $x =~ /foo/;

- The `do {}` construct isn't a real loop that you can use loop control on.

- Use `my()` for local variables whenever you can get away with it (but see perlform for where you can't). Using `local()` actually gives a local value to a global variable, which leaves you open to unforeseen side-effects of dynamic scoping.

- If you localize an exported variable in a module, its exported value will not change. The local name becomes an alias to a new value but the external name is still an alias for the original.

As always, if any of these are ever officially declared as bugs, they'll be fixed and removed.