What is the difference between `$this`, `@that`, a

Question

What is the difference between $this, @that, and %those in Perl?

Answer 1

People often try to tie sigils to variable types, but they are only loosely related. It's a topic we hit very hard in Learning Perl and Effective Perl Programming because it's much easier to understand Perl when you understand sigils.

Many people forget that variables and data are actually separate things. Variables can store data, but you don't need variables to use data.

The $ denotes a single scalar value (not necessarily a scalar variable):

$scalar_var
$array[1]
$hash{key}

The @ denotes multiple values. That could be the array as a whole, a slice, or a dereference:

@array;
@array[1,2]
@hash{qw(key1 key2)}
@{ func_returning_array_ref };

The % denotes pairs (keys and values), which might be a hash variable or a dereference:

%hash
%$hash_ref

Under Perl v5.20, the % can now denote a key/value slice or either a hash or array:

%array[ @indices ];  # returns pairs of indices and elements
%hash{ @keys };      # returns pairs of key-values for those keys

Answer 2

You might want to look at the perlintro and perlsyn documents in order to really get started with understanding Perl (i.e., Read The Flipping Manual). :-)

That said:

• $this is a scalar, which can store a number (int or float), a string, or a reference (see below);
• @that is an array, which can store an ordered list of scalars (see above). You can add a scalar to an array with the push or unshift functions (see perlfunc), and you can use a parentheses-bounded comma-separated list of scalar literals or variables to create an array literal (i.e., my @array = ($a, $b, 6, "seven");)
• %those is a hash, which is an associative array. Hashes have key-value pairs of entries, such that you can access the value of a hash by supplying its key. Hash literals can also be specified much like lists, except that every odd entry is a key and every even one is a value. You can also use a => character instead of a comma to separate a key and a value. (i.e., my %ordinals = ("one" => "first", "two" => "second");)

Normally, when you pass arrays or hashes to subroutine calls, the individual lists are flattened into one long list. This is sometimes desirable, sometimes not. In the latter case, you can use references to pass a reference to an entire list as a single scalar argument. The syntax and semantics of references are tricky, though, and fall beyond the scope of this answer. If you want to check it out, though, see perlref.

Answer 3

$this is a scalar value, it holds 1 item like apple

@that is an array of values, it holds several like ("apple", "orange", "pear")

%those is a hash of values, it holds key value pairs like ("apple" => "red", "orange" => "orange", "pear" => "yellow")

See perlintro for more on Perl variable types.

Answer 4

Perl's inventor was a linguist, and he sought to make Perl like a "natural language".

From this post:

Disambiguation by number, case and word order

Part of the reason a language can get away with certain local ambiguities is that other ambiguities are suppressed by various mechanisms. English uses number and word order, with vestiges of a case system in the pronouns: "The man looked at the men, and they looked back at him." It's perfectly clear in that sentence who is doing what to whom. Similarly, Perl has number markers on its nouns; that is, $dog is one pooch, and @dog is (potentially) many. So $ and @ are a little like "this" and "these" in English. [emphasis added]

Answer 5

A useful mnemonic for Perl sigils are:

• $calar
• @rray
• %ash

Matt Trout wrote a great comment on blog.fogus.me about Perl sigils which I think is useful so have pasted below:

Actually, perl sigils don’t denote variable type – they denote conjugation – $ is ‘the’, @ is ‘these’, % is ‘map of’ or so – variable type is denoted via [] or {}. You can see this with:

my $foo = 'foo';
my @foo = ('zero', 'one', 'two');
my $second_foo = $foo[1];
my @first_and_third_foos = @foo[0,2];
my %foo = (key1 => 'value1', key2 => 'value2', key3 => 'value3');
my $key2_foo = $foo{key2};
my ($key1_foo, $key3_foo) = @foo{'key1','key3'};

so looking at the sigil when skimming perl code tells you what you’re going to -get- rather than what you’re operating on, pretty much.

This is, admittedly, really confusing until you get used to it, but once you -are- used to it it can be an extremely useful tool for absorbing information while skimming code.

You’re still perfectly entitled to hate it, of course, but it’s an interesting concept and I figure you might prefer to hate what’s -actually- going on rather than what you thought was going on :)