Tutorial di riferimento e dereferenziazione degli array Perl con esempi pratici

In questo articolo esaminiamo come fare riferimento e dereferenziare l'array Perl con esempi. Il riferimento non è altro che la posizione (indirizzo) di un'altra variabile. I riferimenti possono essere di array, hash o uno snippet di codice Perl. I riferimenti rendono il codice Perl più veloce.

Riferimento Perl all'array

Normalmente, memorizziamo l'elenco di elementi in un array come mostrato di seguito.

@array =  (“one”,”two”,”three”,”four”,”five”);

Per assegnare un riferimento a una matrice in una variabile, usa l'operatore backslash(\) come mostrato di seguito

$array_ref = \@array;

Se provi a stampare la variabile $array_ref, otterrai qualcosa di simile al seguente.

ARRAY(0x1a2b3c)

Il riferimento all'array Perl può anche essere passato a una subroutine come mostrato di seguito.

sub add_numbers
{
  my $array_ref =  shift;
  .....
}  

@numbers = (11,2,3,45);

$array_ref = add_numbers(\@numbers);

Nel frammento di codice sopra, dobbiamo dereferenziare l'array, in modo che la subroutine possa prendere gli elementi dall'array originale.

Di seguito sono riportati alcuni dei vantaggi di passare il riferimento a una subroutine, invece di passare l'intero array.

• Se abbiamo passato l'array a una subroutine, Perl copia l'intero array nella variabile @_. Quando l'array è grande, questo non è un metodo efficace.
• Quando vogliamo che l'array originale venga modificato dalla subroutine, dobbiamo passare il riferimento dell'array.
• I riferimenti svolgono un ruolo essenziale nella costruzione di strutture di dati complesse.

Possiamo prendere il riferimento di un array anonimo nella variabile scalare come mostrato di seguito.

$array_ref = [ 11,2,3,45];

Nota:questo articolo fa parte della serie di tutorial Perl in corso.

Matrice di dereferenziazione Perl

All'interno della subroutine, la dereferenziazione può essere eseguita utilizzando uno dei metodi mostrati di seguito.

La variabile di riferimento può essere dereferenziata come mostrato di seguito. Usando questo metodo, possiamo prendere tutti gli elementi dell'array. Questo è lo stesso di @numeri.

@{ $array_ref };

Per ottenere un particolare elemento in una matrice, procedere come segue. Questa istruzione fornisce il primo elemento dell'array @numbers. È lo stesso di $numbers[0]

$ { $array_ref }[0]

Invece di memorizzare il riferimento nella variabile, è possibile accedere agli elementi dell'array direttamente dalla variabile incorporata in Perl.

# Get all the elements of @numbers array.
@ { $_[0] }

# Get a particular element. This gives the first element of the array.
$ { $_[0] } [0]

Nota : Se stiamo dereferenziando una semplice variabile scalare, possiamo omettere le parentesi come mostrato di seguito.

@$array_ref  # same as @{ $array_ref }

$$array_ref  # same as $ { $array_ref }

$_[0]         # not a simple scalar variable and this cant be dereferenced,

Memorizzazione di più riferimenti nell'array Perl

Usiamo il seguente frammento di codice Perl di esempio.

#Array contains source ip and destination ip
@IP = ('192.168.1.10','192.168.1.15'); 

#Array contains the source port and destination port numbers
@PORT = ("5000","5002"); 

#Sublayers of TCP layer
@TCP = ("Q931","H225","H245"); 

#Common layers are available in a TCP packet.
@LAYER = ("ETHERNET","IP",\@TCP); 

@PKT = (
         \@IP,
         \@PORT,
         \@LAYER
        );
#Storing the reference of @PKT array into the scalar variable.
$array_ref = \@PKT;

Per comprendere il riferimento all'array, assumiamo che dal frammento di codice sopra, vogliamo accedere al secondo sottolivello ("H225") del livello TCP. Questo può essere fatto come spiegato di seguito.

Innanzitutto, dobbiamo accedere all'array LAYER. Questo restituisce un riferimento all'array @LAYER.

$ { $array_ref } [2]

$array_ref è una semplice variabile scalare. Quindi, le parentesi graffe possono essere omesse e possono anche essere scritte come mostrato di seguito.

$$array_ref[2]

Successivamente, per accedere al terzo elemento/livello (da @LAYER) tramite questo riferimento.

$ { $ { $array_ref } [2] } [2]

Questo restituisce l'indirizzo dell'array @TCP.

Infine, possiamo ottenere il secondo sottolivello del livello TCP (dall'array @TCP) come mostrato di seguito.

$ { $ { $ { $array_ref } [2] } [2] } [1]

Quanto sopra sembra piuttosto complicato e riduce la modularità del codice. C'è una disposizione per riscrivere le affermazioni di cui sopra e renderlo più facile per gli occhi nel modo seguente.

In Perl, $ { VAR } [ $y] può essere scritto come VAR->[$y].

$ { $array_ref } [2]  is same as $array_ref->[2]

$ { $ { $array_ref } [2] } [2] is same as $array_ref->[2]->[2]

$ { $ { $ { $array_ref } [2] } [2] } [1] is same as $array_ref->[2]->[2]->[1]

Ora, usando la regola "freccia di rilascio", possiamo riscriverla come mostrato di seguito. Secondo la regola della "freccia di rilascio", non possiamo rimuovere la prima freccia. Questo è molto più facile da leggere.

$array_ref->[2][2][1]