Perl is a highly capable, feature-rich programming language with over 25 years of development. These notes follow the path of the Learning Perl book.

• First line should be #!/usr/bin/perl or #!/usr/bin/env perl
• Perl compiles to byte-code before executing
• Do not use an extension for scripts.
• To specify a minimum version use “use 5.010;”
• Semicolons (;) required to separate statements
• “perl -w” turns on warnings for entire program. For just the current file use “use warnings;”
• “use diagnostics;” adds explanations to warnings
• “use strict;” requires variable declaration
• Comments start with # (no block comments)
• Parenthesis are optional unless part of syntax.

• All numbers are stored in the same format e.g.-6.5e24, 037 (octal), 0x2a13b (hex), 0b11010 (binary)
• Underscores for readability are ignored e.g. 0x1377_0B77
• Arithmetic operators are * / + - % (modulus) (exponentiation) * Comparison operators are < ⇐ == >= > != ===== Strings ===== * To use unicode in source code - “use utf8;” * Single-quoted literals '⅚∞☃☠' can contain any character except single-quote (use \') and backslash (use \\). * Double-quoted strings can contain control-characters starting with a backslash and are variable interpolated e/g/ “${var}s $var\n”. * . is for concatenation, x for string repetition. * To insert a character by code - chr(0x05d0). To convert a character to its code - ord('א') * String comparison operators are lt, le, eq, ge, gt, and ne ===== Scalar Variables ===== * Scalars are numbers or strings (or undefined or references), used interchangeably. * $calar variables start with $ and a letter or underscore, but can contain letters (including unicode), numbers or underscores. * Scalar assignment looks like $a = 3; or $a .= “suffix”; or $a **= 3; * Recommended to use all lowercase variable names with underscores for word separation e.g. $var_name * print takes a single scalar or a list of scalars (separated by commas) * When a scalar is interpreted as a boolean, the following are false : 0, '0', '', undefined . * !! is a handy shortcut to convert any scalar to 0 or 1 (to represent a boolean) * Variables have value undef before being assigned. undef acts as a 0 or “” as needed, but will throw a warning if printed. * defined() checks if a variable has been defined. Can also set a variable to undef. ===== Lists and Arrays ===== * A list is an ordered set of elements (each of which is a scalar value), starting with position 0. * @rrays are variables that store a list (separate namespace from scalar variables). @x refers to entire array x. * Undefined arrays start out as (), the empty list and not undef. * To access an element of an array - $myarr[0] - undef if never set. * Index of last element is in $#arr * Negative array indices wrap around (only once) so -1 refers to last element. * Literal lists - ('abc','def') or (1..6) (integers 1 to 6) or qw(abc def) or qw#abc def# (quoted by whitespace). * Can assign list values to variables e.g. <code perl>($fred, $barney, $dino) = (“flintstone”, “rubble”, undef); ($fred, $barney) = ($barney, $fred); # swap those values</code> * push adds element(s) to end of array. pop removes a single element and returns it. * unshift adds element(s) to start** of array. shift removes a single element and returns it.
• splice removes elements from middle of array, returns them and optionally replaces them

  splice @arr, start, len, @newelems

• sort and reverse functions return the modified list (can be saved to original array variable).
• Expressions parsed in either a scalar context or a list context. Scalars are promoted to single-element lists in list context.
• List functions may return different scalars - array variables return number of elements. The scalar function forces a scalar context e.g. for print function.

• if-elsif-else

  if ($a == $b) {
    a = 0;
  } elsif ($a > $b) {
    a = 1;
  } else {
    a = -1;
  }

• while loop

  $count=0;
  while ($count < 10) {
      $count += 2;
  }

• foreach loop

  foreach $rock (@rocks) {
    # modifications to $rock modify the list element
    # $_ is used if loop variable is omitted
  }

• Read a line of input - $line = <STDIN>;
• chomp removes a newline e.g. chomp($line=<STDIN>);
• Assigning <STDIN> to a list reads all input up till EOF e.g.

   chmop(@lines = <STDIN>);