view release on metacpan or  search on metacpan

IT/perlsub.pod  view on Meta::CPAN

    sub PI ()		{ 4 * atan2 1, 1 }	# Buona come viene,
						# ed e` pure espansa in linea!
    sub ST_DEV ()	{ 0 }
    sub ST_INO ()	{ 1 }

    sub FLAG_PIPPO ()    { 1 << 8 }
    sub FLAG_PLUTO ()    { 1 << 9 }
    sub FLAG_MASCHERA () { FLAG_PIPPO | FLAG_PLUTO }

    sub OPZ_TOPO () { not (0x1B58 & FLAG_MASCHERA) }

    sub N () { int(OPZ_TOPO) / 3 }

    sub PIPPO_IMPOSTATO () { 1 if FLAG_MASCHERA & FLAG_PIPPO }

Fate attenzione che quelle che segono non saranno espanse; poichE<eacute>
contengono ambiti di visibilitE<agrave> interni, la semplificazione
delle costanti non le riduce ad una singola costante:

   sub pippo_set () { if (FLAG_MASCHERA & FLAG_PIPPO) { 1 } }

   sub baz_val () {
      if (OPZ_TOPO) {
         return 23;
      }
      else {
         return 42;
      }
   }

Se ridefinite una subrouinte che risultava espandibile, riceverete un
I<warning> obbligatorio. (Potete anche utilizzare questo I<warning> per sapere
se una particolare subroutine E<egrave> considerata costante o no). Il
I<warning> E<egrave> considerato importante abbastanza da non essere opzionale,
perchE<eacute> le chiamate alla funzione compilate in precedenza utilizzeranno
ancora la vecchia definizione della funzione. Se avete bisogno di ridefinire
la subroutine, dovete assicurarvi che non sia espansa in linea, o eliminando
il prototipo C<()> (che ne cambia il comportamento, quindi attenzione) o
aggirando il meccanismo di espansione in qualche altro modo, come

   sub non_espansa_in_linea () {
      23 if $];
   }

=head2 Ridefinire le Funzioni Native
X<built-in> X<nativa> X<ridefinire> X<CORE> X<CORE::GLOBAL>

Molte funzioni native possono essere ridefinite, sebbene questo
approccio debba essere riservato per poche e ben dimostrate
occasioni. Tipicamente questo approccio potrebbe essere utilizzato
da un modulo che tenti di emulare una funzionalitE<agrave> nativa su un
sistema non-Unix.

La ridefinizione puE<ograve> essere effettuata solo importando il nome da un
modulo in fase di compilazione -- la pre-dichiarazione ordinaria
non E<egrave> sufficiente. In ogni caso, il pragma C<use subs> vi consente,
in effetti, di predichiarare le subroutine attraverso la sintassi
di importazione usuale, e questi nomi possono poi ridefinire
quelli nativi:

   use subs 'chdir', 'chroot', 'chmod', 'chown';
   chdir $daqualcheparte;
   sub chdir { ... }

Per riferirsi senza ambiguitE<agrave> alla forma nativa, occorre precedere
il nome della funzione con il qualificatore di pacchetto speciale
C<CORE::>. Ad esempio, C<CORE::open()> si riferisce sempre alla
funzione nativa C<open()>, anche se il pacchetto corrente ha
importato qualche altra subroutine chiamata C<&open()> da qualche
altra parte. Anche se sembra una normale chiamata a funzione, non
lo E<egrave>: non potete prendervi un riferimento, come l'espressione
scorretta C<\&CORE::open> puE<ograve> sembrare produrre.

I moduli di libreria non dovrebbero, in generale, esportare nomi
di funzioni native come C<open> o C<chdir> come parte della loro
lista C<@EXPORT> di default, perchE<eacute> potrebbero andarsi ad infilare
nello spazio dei nomi di qualcun altro e cambiar loro la semantica
in maniera inaspettata. Se il modulo, invece, include questi nomi
all'interno di C<@EXPORT_OK> sarE<agrave> allora possibile per un utente
importarli esplicitamente, ma non implicitamente. Ossia, potrebbero
scrivere:

    use Module 'open';

e verrebbe importata la ridefinizione di C<open>. Ma se
scrivessero

    use Module;

avrebbero i nomi importati per default senza le ridefinizioni.

Il meccanismo di ridefinizione delle funzioni native viene ristretto,
abbastanza intenzionalmente, al pacchetto che richiede l'importazione.
Esiste perE<ograve> un secondo metodo che puE<ograve> essere talvolta
utilizzato quando volete ridefinire una funzione nativa in tutto il programma,
senza preoccuparvi dei limiti degli spazi dei nomi. Questo risultato puE<ograve>
essere ottenuto importando una subroutine nello spazio dei nomi speciale
C<CORE::GLOBAL::>. Quello che segue E<egrave> un esempio che rimpiazza
l'operatore C<glob> senza troppo pudore, con qualcosa che gestisce
le espressioni regolari:

   package REGlob;
   require Exporter;
   @ISA = 'Exporter';
   @EXPORT_OK = 'glob';

   sub import {
      my $pkg = shift;
      return unless @_;
      my $sim = shift;
      my $dove = ($sim =~ s/^GLOBAL_// ? 'CORE::GLOBAL' : caller(0));
      $pkg->export($dove, $sim, @_);
   }

   sub glob {
      my $pat = shift;
      my @preso;
      local *D;
      if (opendir D, '.') { 
         @preso = grep /$pat/, readdir D; 
         closedir D;