From 75ecb5aa8133325f14d97d00675c3b039da06530 Mon Sep 17 00:00:00 2001
From: Mark Canlas <github@htmlism.com>
Date: Wed, 10 Jun 2015 00:00:12 +0200
Subject: tamed indentation/whitespace

---
 perl.html.markdown | 44 +++++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 21 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index aac95939..ab8c7a32 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -47,9 +47,9 @@ my %fruit_color = ("apple", "red", "banana", "yellow");
 #  You can use whitespace and the "=>" operator to lay them out more nicely:
 
 my %fruit_color = (
-        apple  => "red",
-        banana => "yellow",
-        );
+  apple  => "red",
+  banana => "yellow",
+);
 # Scalars, arrays and hashes are documented more fully in perldata.
 # (perldoc perldata).
 
@@ -60,17 +60,17 @@ my %fruit_color = (
 
 # Perl has most of the usual conditional and looping constructs.
 
-if ( $var ) {
-    ...
-} elsif ( $var eq 'bar' ) {
-    ...
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
 } else {
-    ...
+  ...
 }
 
-unless ( condition ) {
-                   ...
-               }
+unless (condition) {
+  ...
+}
 # This is provided as a more readable version of "if (!condition)"
 
 # the Perlish post-condition way
@@ -78,19 +78,19 @@ print "Yow!" if $zippy;
 print "We have no bananas" unless $bananas;
 
 #  while
-  while ( condition ) {
-                   ...
-               }
+while (condition) {
+  ...
+}
 
 
 # for and foreach
 for ($i = 0; $i <= $max; $i++) {
-                   ...
-               }
+  ...
+}
 
 foreach (@array) {
-                   print "This element is $_\n";
-               }
+  print "This element is $_\n";
+}
 
 
 #### Regular expressions
@@ -129,9 +129,11 @@ my @lines = <$in>;
 # Writing subroutines is easy:
 
 sub logger {
-    my $logmessage = shift;
-    open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
-    print $logfile $logmessage;
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
+
+  print $logfile $logmessage;
 }
 
 # Now we can use the subroutine just as any other built-in function:
-- 
cgit v1.2.3


From 66379e80cdc805612327e71a6cfa79d4699a8186 Mon Sep 17 00:00:00 2001
From: Mark Canlas <github@htmlism.com>
Date: Wed, 10 Jun 2015 00:05:36 +0200
Subject: revamped for loops

---
 perl.html.markdown | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index ab8c7a32..3c0699ad 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -83,13 +83,23 @@ while (condition) {
 }
 
 
-# for and foreach
-for ($i = 0; $i <= $max; $i++) {
-  ...
+# for loops and iteration
+for (my $i = 0; $i < $max; $i++) {
+  print "index is $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "Current element is " . $elements[$i];
 }
 
-foreach (@array) {
-  print "This element is $_\n";
+for my $element (@elements) {
+  print $element;
+}
+
+# implicitly
+
+for (@elements) {
+  print;
 }
 
 
-- 
cgit v1.2.3


From e4931ee126a23a851c6a2ab474e84996e1b28f3e Mon Sep 17 00:00:00 2001
From: Ahmad Fatoum <ahmad@a3f.at>
Date: Fri, 19 Jun 2015 23:11:38 +0200
Subject: Fixed misinfo regarding sigils

also # is more commonly called number sign than number symbol.
---
 perl.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 3c0699ad..4e172406 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -12,16 +12,16 @@ Perl 5 is a highly capable, feature-rich programming language with over 25 years
 Perl 5 runs on over 100 platforms from portables to mainframes and is suitable for both rapid prototyping and large scale development projects.
 
 ```perl
-# Single line comments start with a number symbol.
+# Single line comments start with a number sign.
 
 
 #### Perl variable types
 
-#  Variables begin with the $ symbol.
+#  Variables begin with a sigil, which is a symbol showing the type.
 #  A valid variable name starts with a letter or underscore,
 #  followed by any number of letters, numbers, or underscores.
 
-### Perl has three main variable types: scalars, arrays, and hashes.
+### Perl has three main variable types: $scalar, @array, and %hash.
 
 ## Scalars
 #  A scalar represents a single value:
-- 
cgit v1.2.3


From a8dce45150fb6938188d7ec895ade58ff264d670 Mon Sep 17 00:00:00 2001
From: Alan Berndt <alan@eatabrick.org>
Date: Sat, 10 Oct 2015 11:44:50 -0700
Subject: Add example of post-condition for loop.

---
 perl.html.markdown | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 4e172406..1b86f410 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -102,6 +102,8 @@ for (@elements) {
   print;
 }
 
+# the Perlish post-condition way again
+print for @elements;
 
 #### Regular expressions
 
-- 
cgit v1.2.3


From 0b8a0526249264c7ac34069adf3159f2b72771a8 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sun, 13 Dec 2015 18:03:47 -0500
Subject: Add info on references, modules, and objects

These topics are central to modern usage of Perl.
---
 perl.html.markdown | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 125 insertions(+), 7 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 1b86f410..85f3974e 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -5,6 +5,7 @@ language: perl
 filename: learnperl.pl
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Dan Book", "http://github.com/Grinnz"]
 ---
 
 Perl 5 is a highly capable, feature-rich programming language with over 25 years of development.
@@ -14,7 +15,6 @@ Perl 5 runs on over 100 platforms from portables to mainframes and is suitable f
 ```perl
 # Single line comments start with a number sign.
 
-
 #### Perl variable types
 
 #  Variables begin with a sigil, which is a symbol showing the type.
@@ -37,7 +37,9 @@ my @animals = ("camel", "llama", "owl");
 my @numbers = (23, 42, 69);
 my @mixed   = ("camel", 42, 1.23);
 
-
+# Array elements are accessed using square brackets, with a $ to indicate
+# one value will be returned.
+my $second = $animals[1];
 
 ## Hashes
 #   A hash represents a set of key/value pairs:
@@ -50,11 +52,39 @@ my %fruit_color = (
   apple  => "red",
   banana => "yellow",
 );
+
+# Hash elements are accessed using curly braces, again with the $ sigil.
+my $color = $fruit_color{apple};
+
 # Scalars, arrays and hashes are documented more fully in perldata.
 # (perldoc perldata).
 
-# More complex data types can be constructed using references, which allow you
-# to build lists and hashes within lists and hashes.
+#### References
+
+# More complex data types can be constructed using references, which allow
+# you to build arrays and hashes within arrays and hashes.
+
+my $array_ref = \@array;
+my $hash_ref = \%hash;
+my @array_of_arrays = (\@array1, \@array2, \@array3);
+
+# You can also create anonymous arrays or hashes, returning a reference:
+
+my $fruits = ["apple", "banana"];
+my $colors = {apple => "red", banana => "yellow"};
+
+# References can be dereferenced by prefixing the appropriate sigil.
+
+my @fruits_array = @$fruits;
+my %colors_hash = %$colors;
+
+# As a shortcut, the arrow operator can be used to dereference and access a
+# single value.
+
+my $first = $array_ref->[0];
+my $value = $hash_ref->{banana};
+
+# See perlreftut and perlref for more in-depth documentation on references.
 
 #### Conditional and looping constructs
 
@@ -105,6 +135,9 @@ for (@elements) {
 # the Perlish post-condition way again
 print for @elements;
 
+# iterating through the keys and values of a referenced hash
+print $hash_ref->{$_} for keys %$hash_ref;
+
 #### Regular expressions
 
 # Perl's regular expression support is both broad and deep, and is the subject
@@ -151,11 +184,96 @@ sub logger {
 # Now we can use the subroutine just as any other built-in function:
 
 logger("We have a logger subroutine!");
-```
 
-#### Using Perl modules
+#### Modules
+
+# A module is a set of Perl code, usually subroutines, which can be used in
+# other Perl code. It is usually stored in a file with the extension .pm so
+# that Perl can find it.
+
+package MyModule;
+
+sub trim {
+  my $string = shift;
+  $string =~ s/^\s+//;
+  $string =~ s/\s+$//;
+  return $string;
+}
+
+1;
+
+# From elsewhere:
+
+use MyModule;
+MyModule::trim($string);
+
+# The Exporter module can help with making subroutines exportable, so they
+# can be used like this:
+
+use MyModule 'trim';
+trim($string);
+
+# Many Perl modules can be downloaded from CPAN (http://www.cpan.org/) and
+# provide a range of features to help you avoid reinventing the wheel.  A
+# number of popular modules like Exporter are included with the Perl
+# distribution itself. See perlmod for more details on modules in Perl.
+
+#### Objects
+
+# Objects in Perl are just references that know which class (package) they
+# belong to, so that methods (subroutines) called on it can be found there.
+# The bless function is used in constructors (usually new) to set this up.
+# However, you never need to call it yourself if you use a module like Moose
+# or Moo (see below).
+
+package MyCounter;
+
+sub new {
+  my $class = shift;
+  my $self = {count => 0};
+  return bless $self, $class;
+}
+
+sub count {
+  my $self = shift;
+  return $self->{count};
+}
+
+sub increment {
+  my $self = shift;
+  $self->{count}++;
+}
+
+1;
+
+# Methods can be called on a class or object instance with the arrow operator.
+
+my $counter = MyCounter->new;
+print $counter->count, "\n"; # 0
+$counter->increment;
+print $counter->count, "\n"; # 1
+
+# The modules Moose and Moo from CPAN can help you set up your object classes.
+# They provide a constructor and simple syntax for declaring attributes. This
+# class can be used equivalently to the one above.
+
+package MyCounter;
+use Moo;
+
+has 'count' => (is => 'rwp', default => 0, init_arg => undef);
+
+sub increment {
+  my $self = shift;
+  $self->_set_count($self->count + 1);
+}
+
+1;
+
+# Object-oriented programming is covered more thoroughly in perlootut, and its
+# low-level implementation in Perl is covered in perlobj.
+```
 
-Perl modules provide a range of features to help you avoid reinventing the wheel, and can be downloaded from CPAN (http://www.cpan.org/).  A number of popular modules are included with the Perl distribution itself.
+#### FAQ
 
 perlfaq contains questions and answers related to many common tasks, and often provides suggestions for good CPAN modules to use.
 
-- 
cgit v1.2.3


From 35b3c490ce06fb94b8b51bd7f5ceb1638401fb1a Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sun, 13 Dec 2015 19:22:29 -0500
Subject: Add blurb about strict and warnings

---
 perl.html.markdown | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 85f3974e..ab71a6ab 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -15,6 +15,16 @@ Perl 5 runs on over 100 platforms from portables to mainframes and is suitable f
 ```perl
 # Single line comments start with a number sign.
 
+#### Strict and warnings
+
+use strict;
+use warnings;
+
+# All perl scripts and modules should include these lines. Strict causes
+# compilation to fail in cases like misspelled variable names, and warnings
+# will print warning messages in case of common pitfalls like concatenating
+# to an undefined value.
+
 #### Perl variable types
 
 #  Variables begin with a sigil, which is a symbol showing the type.
-- 
cgit v1.2.3


From 88af462c699b9f48310a9624bb6bbe94b7101af1 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sun, 13 Dec 2015 19:39:37 -0500
Subject: use strict and warnings in example modules

---
 perl.html.markdown | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index ab71a6ab..d919e00e 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -202,6 +202,8 @@ logger("We have a logger subroutine!");
 # that Perl can find it.
 
 package MyModule;
+use strict;
+use warnings;
 
 sub trim {
   my $string = shift;
@@ -237,6 +239,8 @@ trim($string);
 # or Moo (see below).
 
 package MyCounter;
+use strict;
+use warnings;
 
 sub new {
   my $class = shift;
@@ -268,7 +272,7 @@ print $counter->count, "\n"; # 1
 # class can be used equivalently to the one above.
 
 package MyCounter;
-use Moo;
+use Moo; # imports strict and warnings
 
 has 'count' => (is => 'rwp', default => 0, init_arg => undef);
 
-- 
cgit v1.2.3


From 16d879d712878e2d1aa262dc1218b6543aec99c9 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sun, 13 Dec 2015 19:51:57 -0500
Subject: add missing use line

---
 perl.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index d919e00e..61e8cd0e 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -262,6 +262,7 @@ sub increment {
 
 # Methods can be called on a class or object instance with the arrow operator.
 
+use MyCounter;
 my $counter = MyCounter->new;
 print $counter->count, "\n"; # 0
 $counter->increment;
-- 
cgit v1.2.3


From f6b16c69bb7631be65b60f866928d06dc6453e96 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Fri, 15 Apr 2016 03:23:10 -0400
Subject: [perl/en] Fix line formatting and use $x instead of $a

---
 perl.html.markdown | 85 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 45 insertions(+), 40 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 61e8cd0e..3cbd2801 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -21,9 +21,9 @@ use strict;
 use warnings;
 
 # All perl scripts and modules should include these lines. Strict causes
-# compilation to fail in cases like misspelled variable names, and warnings
-# will print warning messages in case of common pitfalls like concatenating
-# to an undefined value.
+# compilation to fail in cases like misspelled variable names, and
+# warnings will print warning messages in case of common pitfalls like
+# concatenating to an undefined value.
 
 #### Perl variable types
 
@@ -47,8 +47,8 @@ my @animals = ("camel", "llama", "owl");
 my @numbers = (23, 42, 69);
 my @mixed   = ("camel", 42, 1.23);
 
-# Array elements are accessed using square brackets, with a $ to indicate
-# one value will be returned.
+# Array elements are accessed using square brackets, with a $ to
+# indicate one value will be returned.
 my $second = $animals[1];
 
 ## Hashes
@@ -56,7 +56,8 @@ my $second = $animals[1];
 
 my %fruit_color = ("apple", "red", "banana", "yellow");
 
-#  You can use whitespace and the "=>" operator to lay them out more nicely:
+#  You can use whitespace and the "=>" operator to lay them out more
+#  nicely:
 
 my %fruit_color = (
   apple  => "red",
@@ -71,8 +72,8 @@ my $color = $fruit_color{apple};
 
 #### References
 
-# More complex data types can be constructed using references, which allow
-# you to build arrays and hashes within arrays and hashes.
+# More complex data types can be constructed using references, which
+# allow you to build arrays and hashes within arrays and hashes.
 
 my $array_ref = \@array;
 my $hash_ref = \%hash;
@@ -88,13 +89,14 @@ my $colors = {apple => "red", banana => "yellow"};
 my @fruits_array = @$fruits;
 my %colors_hash = %$colors;
 
-# As a shortcut, the arrow operator can be used to dereference and access a
-# single value.
+# As a shortcut, the arrow operator can be used to dereference and
+# access a single value.
 
 my $first = $array_ref->[0];
 my $value = $hash_ref->{banana};
 
-# See perlreftut and perlref for more in-depth documentation on references.
+# See perlreftut and perlref for more in-depth documentation on
+# references.
 
 #### Conditional and looping constructs
 
@@ -150,18 +152,18 @@ print $hash_ref->{$_} for keys %$hash_ref;
 
 #### Regular expressions
 
-# Perl's regular expression support is both broad and deep, and is the subject
-# of lengthy documentation in perlrequick, perlretut, and elsewhere.
-# However, in short:
+# Perl's regular expression support is both broad and deep, and is the
+# subject of lengthy documentation in perlrequick, perlretut, and
+# elsewhere. However, in short:
 
 # Simple matching
 if (/foo/)       { ... }  # true if $_ contains "foo"
-if ($a =~ /foo/) { ... }  # true if $a contains "foo"
+if ($x =~ /foo/) { ... }  # true if $x contains "foo"
 
 # Simple substitution
 
-$a =~ s/foo/bar/;         # replaces foo with bar in $a
-$a =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $a
+$x =~ s/foo/bar/;         # replaces foo with bar in $x
+$x =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $x
 
 
 #### Files and I/O
@@ -172,9 +174,10 @@ open(my $in,  "<",  "input.txt")  or die "Can't open input.txt: $!";
 open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
 open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
 
-# You can read from an open filehandle using the "<>" operator.  In scalar
-# context it reads a single line from the filehandle, and in list context it
-# reads the whole file in, assigning each line to an element of the list:
+# You can read from an open filehandle using the "<>" operator.  In
+# scalar context it reads a single line from the filehandle, and in list
+# context it reads the whole file in, assigning each line to an element
+# of the list:
 
 my $line  = <$in>;
 my @lines = <$in>;
@@ -197,9 +200,9 @@ logger("We have a logger subroutine!");
 
 #### Modules
 
-# A module is a set of Perl code, usually subroutines, which can be used in
-# other Perl code. It is usually stored in a file with the extension .pm so
-# that Perl can find it.
+# A module is a set of Perl code, usually subroutines, which can be used
+# in other Perl code. It is usually stored in a file with the extension
+# .pm so that Perl can find it.
 
 package MyModule;
 use strict;
@@ -219,24 +222,25 @@ sub trim {
 use MyModule;
 MyModule::trim($string);
 
-# The Exporter module can help with making subroutines exportable, so they
-# can be used like this:
+# The Exporter module can help with making subroutines exportable, so
+# they can be used like this:
 
 use MyModule 'trim';
 trim($string);
 
-# Many Perl modules can be downloaded from CPAN (http://www.cpan.org/) and
-# provide a range of features to help you avoid reinventing the wheel.  A
-# number of popular modules like Exporter are included with the Perl
-# distribution itself. See perlmod for more details on modules in Perl.
+# Many Perl modules can be downloaded from CPAN (http://www.cpan.org/)
+# and provide a range of features to help you avoid reinventing the
+# wheel.  A number of popular modules like Exporter are included with
+# the Perl distribution itself. See perlmod for more details on modules
+# in Perl.
 
 #### Objects
 
-# Objects in Perl are just references that know which class (package) they
-# belong to, so that methods (subroutines) called on it can be found there.
-# The bless function is used in constructors (usually new) to set this up.
-# However, you never need to call it yourself if you use a module like Moose
-# or Moo (see below).
+# Objects in Perl are just references that know which class (package)
+# they belong to, so that methods (subroutines) called on it can be
+# found there. The bless function is used in constructors (usually new)
+# to set this up. However, you never need to call it yourself if you use
+# a module like Moose or Moo (see below).
 
 package MyCounter;
 use strict;
@@ -260,7 +264,8 @@ sub increment {
 
 1;
 
-# Methods can be called on a class or object instance with the arrow operator.
+# Methods can be called on a class or object instance with the arrow
+# operator.
 
 use MyCounter;
 my $counter = MyCounter->new;
@@ -268,9 +273,9 @@ print $counter->count, "\n"; # 0
 $counter->increment;
 print $counter->count, "\n"; # 1
 
-# The modules Moose and Moo from CPAN can help you set up your object classes.
-# They provide a constructor and simple syntax for declaring attributes. This
-# class can be used equivalently to the one above.
+# The modules Moose and Moo from CPAN can help you set up your object
+# classes. They provide a constructor and simple syntax for declaring
+# attributes. This class can be used equivalently to the one above.
 
 package MyCounter;
 use Moo; # imports strict and warnings
@@ -284,8 +289,8 @@ sub increment {
 
 1;
 
-# Object-oriented programming is covered more thoroughly in perlootut, and its
-# low-level implementation in Perl is covered in perlobj.
+# Object-oriented programming is covered more thoroughly in perlootut,
+# and its low-level implementation in Perl is covered in perlobj.
 ```
 
 #### FAQ
-- 
cgit v1.2.3


From ff362fc01fa798727c8423d20f093e25702af52b Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sat, 21 Jan 2017 06:06:52 -0500
Subject: [perl/en] how to write to files (#2633)

---
 perl.html.markdown | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 3cbd2801..908f300b 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -170,8 +170,11 @@ $x =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $x
 
 # You can open a file for input or output using the "open()" function.
 
+# For reading:
 open(my $in,  "<",  "input.txt")  or die "Can't open input.txt: $!";
+# For writing (clears file if it exists):
 open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
+# For writing (appends to end of file):
 open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
 
 # You can read from an open filehandle using the "<>" operator.  In
@@ -182,6 +185,12 @@ open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
 my $line  = <$in>;
 my @lines = <$in>;
 
+# You can write to an open filehandle using the standard "print"
+# function.
+
+print $out @lines;
+print $log $msg, "\n";
+
 #### Writing subroutines
 
 # Writing subroutines is easy:
-- 
cgit v1.2.3


From 05614d0920804799aec69fddadac4356c91020a2 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Sat, 21 Jan 2017 07:20:42 -0500
Subject: [perl/en] some more examples of interacting with arrays and hashes
 (#2632)

---
 perl.html.markdown | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 908f300b..a29fdf1f 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -51,6 +51,13 @@ my @mixed   = ("camel", 42, 1.23);
 # indicate one value will be returned.
 my $second = $animals[1];
 
+# The size of an array is retrieved by accessing the array in a scalar
+# context, such as assigning it to a scalar variable or using the
+# "scalar" operator.
+
+my $num_animals = @animals;
+print "Number of numbers: ", scalar(@numbers), "\n";
+
 ## Hashes
 #   A hash represents a set of key/value pairs:
 
@@ -67,6 +74,11 @@ my %fruit_color = (
 # Hash elements are accessed using curly braces, again with the $ sigil.
 my $color = $fruit_color{apple};
 
+# All of the keys or values that exist in a hash can be accessed using
+# the "keys" and "values" functions.
+my @fruits = keys %fruit_color;
+my @colors = values %fruit_color;
+
 # Scalars, arrays and hashes are documented more fully in perldata.
 # (perldoc perldata).
 
@@ -144,6 +156,12 @@ for (@elements) {
   print;
 }
 
+# iterating through a hash (for and foreach are equivalent)
+
+foreach my $key (keys %hash) {
+  print $key, ': ', $hash{$key}, "\n";
+}
+
 # the Perlish post-condition way again
 print for @elements;
 
-- 
cgit v1.2.3


From 447986c19d2e40536872c4c97c1e5f7a82c29d0d Mon Sep 17 00:00:00 2001
From: Chris C <centreti@users.noreply.github.com>
Date: Thu, 9 Feb 2017 09:31:22 -0600
Subject: [perl/en] more perlish iterations on perl5 (#2489)

* more perlish iteration

c-style 'for' isn't perlish

* Update perl.html.markdown

removed one of the array iterator loops
---
 perl.html.markdown | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index a29fdf1f..93eabea9 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -138,18 +138,16 @@ while (condition) {
 
 
 # for loops and iteration
-for (my $i = 0; $i < $max; $i++) {
+for my $i (0 .. $max) {
   print "index is $i";
 }
 
-for (my $i = 0; $i < @elements; $i++) {
-  print "Current element is " . $elements[$i];
-}
-
 for my $element (@elements) {
   print $element;
 }
 
+map {print} @elements;
+
 # implicitly
 
 for (@elements) {
-- 
cgit v1.2.3


From 6e3d29f036f9ede844f17e36e764b685d046adf9 Mon Sep 17 00:00:00 2001
From: Dan Book <grinnz@gmail.com>
Date: Thu, 18 May 2017 06:40:15 -0400
Subject: [perl/en] Use more single quotes and explain single vs double quotes
 (#2710)

* [perl/en] Explain single vs double quotes

Explains an example of variable interpolation and escape codes in a double quoted string.

* add section about interpolating arrays and email in double quotes trap
---
 perl.html.markdown | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'perl.html.markdown')

diff --git a/perl.html.markdown b/perl.html.markdown
index 93eabea9..17a538e3 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -37,10 +37,14 @@ use warnings;
 #  A scalar represents a single value:
 my $animal = "camel";
 my $answer = 42;
+my $display = "You have $answer ${animal}s.\n";
 
 # Scalar values can be strings, integers or floating point numbers, and
 # Perl will automatically convert between them as required.
 
+# Strings in single quotes are literal strings. Strings in double quotes
+# will interpolate variables and escape codes like "\n" for newline.
+
 ## Arrays
 #  An array represents a list of values:
 my @animals = ("camel", "llama", "owl");
@@ -58,6 +62,18 @@ my $second = $animals[1];
 my $num_animals = @animals;
 print "Number of numbers: ", scalar(@numbers), "\n";
 
+# Arrays can also be interpolated into double-quoted strings, and the
+# elements are separated by a space character by default.
+
+print "We have these numbers: @numbers\n";
+
+# Be careful when using double quotes for strings containing symbols
+# such as email addresses, as it will be interpreted as a variable.
+
+my @example = ('secret', 'array');
+my $oops_email = "foo@example.com"; # 'foosecret array.com'
+my $ok_email = 'foo@example.com';
+
 ## Hashes
 #   A hash represents a set of key/value pairs:
 
-- 
cgit v1.2.3