Qual è il significato di @_in Perl?

perldoc perlvar è il primo posto in cui verificare la presenza di informazioni sulle variabili Perl con nomi speciali.

Citando:

@_: All'interno di una subroutine l'array @_contiene i parametri passati a quella subroutine.

Maggiori dettagli possono essere trovati in perldoc perlsub (subroutine Perl) collegati da perlvar:

Tutti gli argomenti passati vengono visualizzati nell'array @_.

Pertanto, se si chiama una funzione con due argomenti, questi verranno memorizzati in $_[0]e $_[1].

L'array @_è un array locale , ma i suoi elementi sono alias per i parametri scalari effettivi . In particolare, se un elemento $ _ [0] viene aggiornato, viene aggiornato l'argomento corrispondente (o si verifica un errore se non è aggiornabile).

Se un argomento è un array o un elemento hash che non esisteva quando la funzione è stata chiamata, quell'elemento viene creato solo quando (e se) viene modificato o viene preso un riferimento ad esso. (Alcune versioni precedenti di Perl creavano l'elemento indipendentemente dal fatto che l'elemento fosse assegnato o meno.) Assegnare all'intero array @_ rimuove l'aliasing e non aggiorna alcun argomento.

Di solito, espandi i parametri passati a un sub utilizzando la @_variabile:

sub test{
  my ($a, $b, $c) = @_;
  ...
}

# call the test sub with the parameters
test('alice', 'bob', 'charlie');

Questo è il modo affermato di essere corretto da Perlcritic .

Il primo colpo di una ricercaperl @_ dice questo :

@_ è l'elenco dei parametri in arrivo a un sub.

Ha anche una spiegazione più lunga e dettagliata dello stesso.

La domanda era cosa @_ significa in Perl. La risposta a questa domanda è che, nella misura in cui $_i mezzi che in Perl, @_similmente significa che .

Nessuno sembra aver menzionato questo aspetto critico del suo significato, così come il loro .

Di conseguenza sono entrambi usati come pronomi, o talvolta come topicalizzatori.

In genere hanno antecedenti nominali, sebbene non sempre.

È inoltre possibile utilizzare shift per singole variabili nella maggior parte dei casi:

$var1 = shift;

Questo è un argomento in cui dovresti approfondire la ricerca poiché Perl ha una serie di modi interessanti per accedere a informazioni esterne all'interno della tua sub routine.

Tutte le "variabili speciali" di Perl sono elencate nella pagina della documentazione di perlvar .

Anche se una funzione restituisce un array, ma la funzione viene chiamata senza assegnare i dati restituiti a nessuna variabile come di seguito. Qui viene chiamata split (), ma non è assegnata a nessuna variabile. Possiamo accedere ai dati restituiti in seguito tramite @_:

$str = "Mr.Bond|Chewbaaka|Spider-Man";
split(/\|/, $str);

print @_[0]; # 'Mr.Bond'

Questo dividerà la stringa $stre imposterà l'array @_.

@ viene utilizzato per un array.

In una subroutine o quando chiamate una funzione in Perl, potete passare l'elenco dei parametri. In tal caso, @_è possibile utilizzare per passare l'elenco dei parametri alla funzione:

sub Average{

    # Get total number of arguments passed.
    $n = scalar(@_);
    $sum = 0;

    foreach $item (@_){

        # foreach is like for loop... It will access every
        # array element by an iterator
        $sum += $item;
    }

    $average = $sum / $n;

    print "Average for the given numbers: $average\n";
}

Chiamata di funzione

Average(10, 20, 30);

Se osservi il codice sopra, vedi la foreach $item(@_)riga ... Qui passa il parametro di input.

Non provare mai a modificare la variabile @_ !!!! Non devono essere toccati .. Oppure si ottiene qualche effetto insospettato. Per esempio...

my $size=1234;
sub sub1{
  $_[0]=500;
}
sub1 $size;

Prima di chiamare sub1 $ size contiene 1234. Ma dopo 500 (!!) Quindi non modificare questo valore !!! Puoi passare due o più valori e modificarli nella subroutine e tutti verranno modificati! Non ho mai visto questo effetto descritto. Anche i programmi che ho visto lasciano l'array @_ in sola lettura. E solo che puoi passare in sicurezza la variabile, non cambiare la subroutine interna Devi sempre farlo:

sub sub2{
  my @m=@_;
  ....
}

assegna @_ alle variabili di procedura della subroutine locale e poi lavora con esse. Anche in alcuni algoritmi ricorsivi profondi che rieseguono un array è possibile utilizzare questo approccio per ridurre la memoria utilizzata per le variabili locali. Solo se restituisce lo stesso array @_.