Cosa succede in queste righe uso Perl?

Question

Non capisco cosa succede qui:

use PAR { file => 'foo.par', fallback => 1 };

Credo che sia un hash anonimo. Come è un modulo usando dalla linea use? Si può fare una certa luce?

EDIT: Non mi interessa nel modulo PAR. Sono solo interessato a come funziona dietro la tenda. Come posso configurare i miei moduli del genere?

Answer 1

Più in fondo, questo è ciò che la sintassi rifhash divertente fa (utilizzando perldoc -f usare come riferimento):

Supponiamo di avere questo modulo base (mettiamo in Foo.pm nella directory corrente):

package Foo;

use Data::Dumper;
sub import
{
    print "import was passed these arguments: ". Dumper(\@_);
}

1;

quando chiamiamo perl -I. -wle'use Foo { a => 1, b => 2}', viene eseguito il codice Foo->import({a=>1, b=>2}). Quindi questo è ciò che si ottiene come output:

import was passed these arguments: $VAR1 = [
          'Foo',
          {
            'a' => 1,
            'b' => 2
          }
        ];

In sostanza, questa sintassi ci permette di fare magie con la Esportatore , ma in verità si può rendere import() fare qualcosa che ti piace (tanto per essere sicuro di documentare pesantemente in modo tale da non creare confusione!)

Answer 2

Quando si use un modulo, è possibile passare un elenco di argomenti ad esso. Nel tuo esempio (che sembra avere un errore di battitura, manca una citazione di chiusura), un elenco con un elemento (un riferimento hash) è passato.

Più in generale:

use Module LIST

Diventa in questo modo:

BEGIN {
    require Module;
    Module->import( LIST );
}

Il blocco BEGIN assicura che tutte le cose accade in fase di compilazione. Il require carica il modulo in memoria, se non è già lì. E allora il metodo import() del modulo si chiama con qualsiasi argomenti sono stati passati (come LIST) nella dichiarazione use originale.

In modo che i propri moduli di fare qualcosa con una tale LIST di argomenti, il modulo sarebbe necessario definire un metodo import(). Molti moduli non lo fanno; piuttosto, si ereditano dalla classe import() Exporter. Vedere perldoc -f utilizzare per ulteriori dettagli.

Se il modulo definisce il proprio metodo import(), vi sia bisogno di esportare i simboli nel codice cliente se stessi o, più comunemente, utilizzare il metodo export_to_level() fornito da Exporter. Il primo argomento di questo metodo è un numero intero positivo che specifica il livello nello stack di chiamate nella quale esportare simboli. Il valore più comune di 1 mezzo per esportare i simboli di un livello sopra il pacchetto corrente - che è, per il codice client che utilizza il modulo. Ecco una descrizione di ciò che il metodo di import() avrebbe bisogno di fare.

sub import {
    my ($class, @args) = @_;

    # Do whatever you need to do with the LIST of arguments
    # supplied by the client code using your module.


    # Let Exporter do its normal work of exporting symbols
    # into the client code using your module.
    $class->export_to_level(1, @_);
}

Answer 3

Sì, è un hash anonimo. E 'passato come argomento al metodo moduli import.

Answer 4

PAR è il CPAN modulo Perl Archive Toolkit . Il rifhash è parametri di configurazione vengono passati al PAR.

Il codice:

use PAR { file => 'foo.par, fallback => 1 };
use Foo::Bar;

significa utilizzare Foo::Bar se è disponibile, ma per il resto ripiegare a utilizzare l'archivio "foo.par" (che detiene presumibilmente una versione archiviata della Foo::Bar).

Answer 5

Risposta diretta alla tua domanda: PAR fa questo (linea 340) :

# called on "use PAR"
sub import {
    my $class = shift;
    [...]
    my @args = @_;
    [...]
    # process args to use PAR 'foo.par', { opts }, ...;
    foreach my $par (@args) {
        if (ref($par) eq 'HASH') { # <---- This is what handle's your case!
            # we have been passed a hash reference
            _import_hash_ref($par);
        }
        elsif ($par =~ /[?*{}\[\]]/) {
           # implement globbing for PAR archives
           [...]
        }
        else {
            # ordinary string argument => file
            [...]
        }
    }

Ora, purtroppo, una volta che visualizzi in dettaglio ciò che sta realmente accadendo là, vi renderete conto che avete scelto uno dei maggior parte dei moduli complicati su CPAN come un esempio da cui imparare, quindi suggerirei di dare un'occhiata al documentazione bene su moduli invece . Per darvi una guida cosa cercare: Quando si "utilizza" un modulo e fornire argomenti per l'istruzione all'uso, perl caricherà il modulo e chiamare il suo metodo di "importazione" con l'elenco degli argomenti

.

Nel tuo esempio caso, c'è semplicemente un argomento: Un riferimento ad un hash. Il {key => "valore", chiave2 => "valore2", ...} sintassi è il costruttore per hash anonimi. Questi sono documentati in la perlref manuale di pagina , ma spiegate in termini più amichevoli in la perlreftut esercitazione .