Variables and Types in Perl

Perl’s approach to variables is unique among programming languages. Instead of declaring a type, you prefix each variable with a sigil—a symbol that tells Perl (and you) what kind of data structure the variable holds. A dollar sign means a single value, an at-sign means a list, a percent sign means a key/value mapping. The sigils are part of the variable’s identity.

Perl is dynamically and weakly typed. Variables do not hold a declared type; scalars can hold a number, a string, or a reference, and Perl will silently convert between strings and numbers as the situation demands. This flexibility is one of the reasons Perl became famous for rapid text processing and system administration scripts.

Even more unusual is Perl’s notion of context. The same expression can produce different results depending on whether it is evaluated in scalar context (expecting a single value) or list context (expecting multiple values). Understanding context is essential to reading and writing idiomatic Perl.

This tutorial walks through scalars, arrays, hashes, undef handling, constants, and the type conversions that happen automatically when Perl sees a string where it expected a number—or the other way around.

Scalars, Arrays, and Hashes

Perl has three fundamental variable types, each with its own sigil. Scalars ($) hold a single value—a number, string, or reference. Arrays (@) hold an ordered list of scalars indexed by integer. Hashes (%) hold an unordered collection of scalar values indexed by string keys.

The my keyword declares a lexically-scoped variable. Combined with use strict, it helps catch typos by requiring every variable to be declared before use.

Create a file named variables.pl:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;

# Scalars hold a single value: number, string, or reference
my $integer = 42;
my $float   = 3.14159;
my $name    = "Perl";
my $char    = 'P';

say "integer = $integer";
say "float   = $float";
say "name    = $name";
say "char    = $char";

# Arrays are ordered lists indexed from 0
my @languages = ("Perl", "Python", "Ruby", "AWK");
say "first language  = $languages[0]";
say "third language  = $languages[2]";
say "array size      = " . scalar(@languages);
say "last index      = $#languages";

# Hashes map string keys to scalar values
my %creator = (
    Perl   => "Larry Wall",
    Python => "Guido van Rossum",
    Ruby   => "Yukihiro Matsumoto",
);
say "Perl creator    = $creator{Perl}";
say "Ruby creator    = $creator{Ruby}";

# Arrays and hashes can be mixed by taking references
my @numbers = (10, 20, 30);
my $sum = 0;
$sum += $_ for @numbers;
say "sum of numbers  = $sum";

Notice how $languages[0] uses the $ sigil, not @, even though @languages is an array. The sigil describes what you are accessing, not what the variable was declared as: a single element of an array is a scalar, so it takes $.

Context and Type Coercion

Perl converts between numbers and strings automatically. A string that looks like a number is treated as a number in numeric context; any scalar becomes a string when concatenated or interpolated. This is what “weak typing” means in practice.

Context is the other side of the coin. The same array in scalar context gives its element count; in list context it gives its elements. You rarely force context explicitly—most operators impose a context on their operands—but the scalar keyword is available when you need to be explicit.

Create a file named context_and_coercion.pl:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;

# --- String/number coercion ---
my $num_str = "25";
my $number  = 7;

# '+' forces numeric context: "25" becomes 25
my $total = $num_str + $number;
say "\"25\" + 7 = $total";

# '.' forces string context: 7 becomes "7"
my $joined = $num_str . $number;
say "\"25\" . 7 = $joined";

# A non-numeric string converts to 0 in numeric context
my $bogus = "hello" + 5;
say "\"hello\" + 5 = $bogus";

# A string starting with digits parses the leading number
my $partial = "42 bananas" + 0;
say "\"42 bananas\" + 0 = $partial";

# --- Scalar vs list context ---
my @items = ("apple", "banana", "cherry");

my $count   = @items;          # scalar context: element count
my $joined2 = "@items";         # list in string: space-separated
my ($first, $second) = @items;  # list context: extract elements

say "count   = $count";
say "joined2 = $joined2";
say "first   = $first";
say "second  = $second";

# Explicit context with the 'scalar' keyword
say "explicit scalar: " . scalar(@items);

# --- Truthiness ---
# Perl's false values: 0, "0", "", and undef. Everything else is true.
for my $val (0, "0", "", "false", "0.0", 1) {
    if ($val) {
        say "truthy: '$val'";
    } else {
        say "falsy:  '$val'";
    }
}

The string "0.0" is truthy in Perl, even though it looks like zero. Perl’s truthiness rules operate on the literal string form, not a numeric interpretation: only the specific strings "" and "0" are false. This trips up programmers coming from other dynamic languages.

Undef and Constants

Perl’s equivalent of null is undef—a special value that means “no value yet.” Reading an uninitialized variable returns undef, and looking up a missing hash key does too. The defined-or operator // (introduced in Perl 5.10) provides a clean way to supply defaults only when a value is undefined, as opposed to || which also triggers on 0 or empty strings.

For values that should never change, Perl offers several ways to create constants. The use constant pragma creates a true compile-time constant; a lexically-scoped Readonly variable is another option (via CPAN). For simple cases, a my scalar assigned once and never modified works in practice.

Create a file named undef_and_constants.pl:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;
use constant {
    PI       => 3.14159265,
    MAX_SIZE => 100,
    APP_NAME => "CodeArchaeology",
};

# Uninitialized scalars are undef
my $maybe;
if (defined $maybe) {
    say "defined: $maybe";
} else {
    say "maybe is undef";
}

# Defined-or: use default only when undefined
my $port = undef;
my $host = "";
my $user = 0;

my $chosen_port = $port // 8080;   # triggers: undef -> 8080
my $chosen_host = $host // "local"; # no trigger: "" is defined
my $chosen_user = $user // "guest"; # no trigger: 0 is defined

say "chosen_port = $chosen_port";
say "chosen_host = '$chosen_host'";
say "chosen_user = $chosen_user";

# Compare // with ||: || triggers on any falsy value
my $fallback = $host || "local";
say "fallback with || = '$fallback'";

# Constants defined by 'use constant'
say "PI       = " . PI;
say "MAX_SIZE = " . MAX_SIZE;
say "APP_NAME = " . APP_NAME;

# Attempting to modify a constant is a compile-time error.
# The following line would fail: PI = 4;  (not allowed)

# Hash lookup returns undef for missing keys
my %scores = (alice => 90, bob => 85);
my $carol = $scores{carol} // "not recorded";
say "carol's score = $carol";

# exists() checks for key presence without triggering autovivification
say "alice exists: " . (exists $scores{alice} ? "yes" : "no");
say "dave exists:  " . (exists $scores{dave}  ? "yes" : "no");

Note the difference between // and ||: the first line assigns 8080 because $port is undef, but $chosen_host stays as the empty string because "" is defined (just falsy). Using || instead would have replaced the empty string—sometimes desired, sometimes a bug.

Running with Docker

1
2
3
4
5
6
7

# Pull the official Perl image
docker pull perl:5.40-slim

# Run each example
docker run --rm -v $(pwd):/app -w /app perl:5.40-slim perl variables.pl
docker run --rm -v $(pwd):/app -w /app perl:5.40-slim perl context_and_coercion.pl
docker run --rm -v $(pwd):/app -w /app perl:5.40-slim perl undef_and_constants.pl

Expected Output

variables.pl:

integer = 42
float   = 3.14159
name    = Perl
char    = P
first language  = Perl
third language  = Ruby
array size      = 4
last index      = 3
Perl creator    = Larry Wall
Ruby creator    = Yukihiro Matsumoto
sum of numbers  = 60

context_and_coercion.pl:

"25" + 7 = 32
"25" . 7 = 257
"hello" + 5 = 5
"42 bananas" + 0 = 42
count   = 3
joined2 = apple banana cherry
first   = apple
second  = banana
explicit scalar: 3
falsy:  '0'
falsy:  '0'
falsy:  ''
truthy: 'false'
truthy: '0.0'
truthy: '1'

undef_and_constants.pl:

maybe is undef
chosen_port = 8080
chosen_host = ''
chosen_user = 0
fallback with || = 'local'
PI       = 3.14159265
MAX_SIZE = 100
APP_NAME = CodeArchaeology
carol's score = not recorded
alice exists: yes
dave exists:  no

Note that variables.pl and context_and_coercion.pl will emit warnings under use warnings for the non-numeric string coercions ("hello" + 5 and "42 bananas" + 0). These warnings go to STDERR, not STDOUT, and do not appear in the output shown above.

Key Concepts

• Sigils identify the access type, not the variable type: $ for a scalar value, @ for a list, % for a key/value mapping. $array[0] uses $ because one element of an array is a scalar.
• my and use strict introduce lexically-scoped variables and catch undeclared-variable typos. Always use them in modern Perl code.
• Dynamic, weak typing: scalars auto-convert between strings and numbers based on the operator. + forces numeric context; . forces string context.
• Context matters: an array in scalar context gives its element count; in list context it gives its elements. Most operators impose context on their operands.
• Falsy values are undef, 0, "0", and ""—and nothing else. The string "0.0" is truthy because only the literal string "0" counts as false.
• Defined-or (//) vs logical-or (||): // only triggers when a value is undefined, while || triggers on any falsy value. Use // for default values when 0 or "" are legitimate.
• undef is the “no value” sentinel: use defined() to check for it, and exists() to check hash key presence without triggering autovivification.
• Constants via use constant are compile-time and cannot be modified. They integrate cleanly with use strict.