Perl: esercizi di programmazione

Questo documento fa parte di Appunti di informatica libera <http://a2.swlibero.org>, dal quale è stato estratto.

Appunti di informatica libera 2001.01.30 --- Copyright (c) Daniele Giacomini -- daniele @ swlibero.org

Questo capitolo raccoglie una sequenza di esercizi didattici di programmazione realizzati in Perl, e svolti nelle classi terze OGA dell'IPC Fabio Besta di Treviso. Il contenuto e la gradualità degli esercizi è, ovviamente, orientato verso studenti di scuola media. Come si può osservare dagli esempi, in tutti i programmi viene aggiunto inizialmente l'opzione -w per assicurare l'emissione di informazioni diagnostiche da parte dell'interprete.

1 Area del rettangolo

Con il pretesto di calcolare l'area di un rettangolo, si vuole introdurre all'uso dell'istruzione print, alla gestione delle stringhe, con la relativa espansione delle variabili e l'eliminazione del codice di interruzione di riga.

La prima soluzione proposta ha lo scopo di mostrare l'uso dei flussi di file standard nel linguaggio Perl.

#!/usr/bin/perl -w
#
# Programma area-01.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.

print ("Inserisci la base: ");
$base = <STDIN>;
print ("Inserisci l'altezza: ");
$altezza = <STDIN>;             
$area = $base * $altezza;
print ("Il rettangolo con una base di ");
print $base;
print (" e un'altezza di ");
print $altezza;
print (" ha un'area di ");
print $area;
print ("\n");

Inserendo rispettivamente i valori 10 e 20, il risultato che si ottiene è quello dell'interazione seguente:

Inserisci la base: 10[Invio]

Inserisci l'altezza: 20[Invio]

Il rettangolo con una base di 10
 e un'altezza di 20
 ha un'area di 200

La seconda soluzione serve a mostrare la possibilità di concatenare le stringhe nella composizione della frase finale, attraverso l'operatore ..

#!/usr/bin/perl -w
#
# Programma area-02.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
# Rispetto alla versione 01 si introduce il concatenamento
# di stringa.

print ("Inserisci la base: ");
$base = <STDIN>;
print ("Inserisci l'altezza: ");
$altezza = <STDIN>;             
$area = $base * $altezza;
print ("Il rettangolo con una base di "
       . $base
       . " e un'altezza di "
       . $altezza
       . " ha un'area di "
       . $area
       . "\n");

La terza soluzione serve a mostrare l'opportunità di fare riferimento allo standard output in modo esplicito, indicare espressamente il nome STDOUT nell'istruzione print; inoltre, si mostra la possibilità di espandere le variabili scalari all'interno delle stringhe letterali.

#!/usr/bin/perl -w
#
# Programma area-03.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
#
# Rispetto alla versione 02 si introduce il riferimento allo
# standard output in modo esplicito e si mostra l'espansione
# delle variabili scalari all'interno delle stringhe.

print STDOUT ("Inserisci la base: ");
$base = <STDIN>;
print STDOUT ("Inserisci l'altezza: ");
$altezza = <STDIN>;             
$area = $base * $altezza;
print STDOUT ("Il rettangolo con una base di $base e un'altezza di "
              . "$altezza ha un'area di $area\n");

Come sarà stato possibile osservare, l'inserimento dei valori attraverso istruzioni del tipo variabile = <STDIN>, include anche il codice di interruzione di riga, con il quale in effetti si termina l'inserimento. Per ovviare a questo inconveniente, nella quarta variante dell'esercizio si utilizza l'istruzione chomp.

#!/usr/bin/perl -w
#
# Programma area-04.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
#
# Rispetto alla versione 03 si utilizza «chomp» per eliminare
# il codice di interruzione di riga finale che accompagna i valori
# inseriti.

print STDOUT ("Inserisci la base: ");
$base = <STDIN>;
chomp ($base);
print STDOUT ("Inserisci l'altezza: ");
$altezza = <STDIN>;             
chomp ($altezza);
$area = $base * $altezza;
print STDOUT ("Il rettangolo con una base di $base e un'altezza di "
              . "$altezza ha un'area di $area\n");

L'utilizzo di chomp risolve il problema di visualizzazione del risultato che avevano tutti gli esempi precedenti:

Inserisci la base: 10[Invio]

Inserisci l'altezza: 20[Invio]

Il rettangolo con una base di 10 e un'altezza di 20 ha un'area di 200

La quinta soluzione mostra l'opportunità di dichiarare le variabili prima dell'uso, inizializzandole secondo il tipo di dati per le quali verranno adoperate. Questo serve a migliorare la leggibilità del programma, anche se il linguaggio non richiede tale accortezza.

#!/usr/bin/perl -w
#
# Programma area-05.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
#
# Rispetto alla versione 04 si dichiarano e si inizializzano le
# variabili prima del loro uso.

$base=0;
$altezza=0;
$area=0;

print STDOUT ("Inserisci la base: ");
$base = <STDIN>;
chomp ($base);
print STDOUT ("Inserisci l'altezza: ");
$altezza = <STDIN>;             
chomp ($altezza);
$area = $base * $altezza;
print STDOUT ("Il rettangolo con una base di $base e un'altezza di "
              . "$altezza ha un'area di $area\n");

La sesta soluzione mostra l'opportunità di aggiungere delle descrizioni (commenti) all'interno del sorgente, per spiegare il significato di ciò che viene fatto, facilitando così l'interpretazione dello stesso per la lettura umana. Inoltre, l'istruzione iniziale system ("clear") serve a introdurre l'uso di comandi del sistema operativo sottostante.

#!/usr/bin/perl -w
#
# Programma area-06.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
#
# Rispetto alla versione 05 si aggiungono dei commenti descrittivi.

#-----------------------------------------------------------------------
# DICHIARAZIONE DELLE VARIABILI
#-----------------------------------------------------------------------

# Si creano le variabili $base, $altezza, area, e si inizializzano.

$base=0;                # crea la variabile $base    e la inizializza
$altezza=0;             # crea la variabile $altezza e la inizializza
$area=0;                # crea la variabile $area    e la inizializza

#-----------------------------------------------------------------------
# INSERIMENTO DEI DATI (INPUT)
#-----------------------------------------------------------------------

# Si ripulisce lo schermo con il comando «clear» del sistema operativo.
system ("clear");       

# Si emette un messaggio di invito a inserire il valore della base.
print STDOUT ("Inserisci la base: ");

# Si assegna alla variabile $base una riga proveniente dallo standard
# input, ovvero ciò che viene inserito presumibilmente dalla tastiera.
$base = <STDIN>;

# Si toglie il codice di interruzione di riga che si trova alla fine
# della variabile $base.
chomp ($base);

# Si emette un messaggio di invito a inserire il valore dell'altezza.
print STDOUT ("Inserisci l'altezza: ");

# Si assegna alla variabile $altezza una riga proveniente dallo standard
# input, ovvero ciò che viene inserito presumibilmente dalla tastiera.
$altezza = <STDIN>;             

# Si toglie il codice di interruzione di riga che si trova alla fine
# della variabile $altezza.
chomp ($altezza);

#-----------------------------------------------------------------------
# ELABORAZIONE DEI DATI
#-----------------------------------------------------------------------

# Assegna alla variabile $area il prodotto del contenuto di $base e di
# $altezza; in altri termini si calcola l'area e la si assegna alla
# variabile $area.
$area = $base * $altezza;

#-----------------------------------------------------------------------
# EMISSIONE DEL RISULTATO DELL'ELABORAZIONE (OUTPUT)
#-----------------------------------------------------------------------

# Si emette un messaggio con il quale si mostra il risultato del calcolo
# dell'area del rettangolo.
print STDOUT ("Il rettangolo con una base di $base e un'altezza di "
              . "$altezza ha un'area di $area\n");

La settima soluzione mostra la possibilità di utilizzare la riga di comando per fornire i dati da elaborare. In pratica, la base viene ottenuta dal primo argomento, mentre l'altezza si ottiene dal secondo argomento.

#!/usr/bin/perl -w
#
# Programma area-07.pl
# Scritto da ... 
#
# Programma per trovare l'area di un rettangolo.
#
# Rispetto alla versione 06 si ottengono i dati in ingresso dalla
# riga di comando (inoltre mancano i commenti).

$base=0;
$altezza=0;
$area=0;

$base    = $ARGV[0];
$altezza = $ARGV[1];

$area = $base * $altezza;
print STDOUT ("Il rettangolo con una base di $base e un'altezza di "
              . "$altezza ha un'area di $area\n");

L'esempio seguente mostra l'avvio del programma per calcolare l'area di un rettangolo con base 10 e altezza 20:

$ ./area-07.pl 10 20[Invio]

Il rettangolo con una base di 10 e un'altezza di 20 ha un'area di 200

2 Ricerca del valore scalare più alto

Lo scopo di questi esercizi è quello di far prendere confidenza con le espressioni di confronto numerico e confronto tra stringhe, che in Perl usano operatori differenti nei due casi. Inoltre, si presenta la struttura condizionale.

Il primo caso mostra la ricerca del valore più altro tra tre valori numerici. In questo caso si usano gli operatori >, < e gli altri di questa serie.

#!/usr/bin/perl -w
#
# Programma massimo-01.pl
# Scritto da ... 
#
# Programma per trovare il valore massimo tra tre numeri.
#

$num1 = 0;
$num2 = 0;
$num3 = 0;
$max  = 0;

print STDOUT ("inserisci il primo numero: ");
$num1 = <STDIN>;
chomp ($num1);
print STDOUT ("inserisci il secondo numero: ");
$num2 = <STDIN>;             
chomp ($num2);
print STDOUT ("inserisci il terzo numero: ");
$num3 = <STDIN>;
chomp ($num3);

if ($num1 > $num2)
  {
    $max = $num1;
  }
else
  {
    $max = $num2;
  }
if ($num3 > $max)
  {
    $max = $num3;
  }

print STDOUT ("Il massimo tra $num1, $num2 e $num3, è $max\n");

Il secondo caso mostra la ricerca della stringa lessicograficamente superiore tra tre valori stringa. In questo caso si usano gli operatori gt, lt e gli altri di questa serie.

#!/usr/bin/perl -w
#
# Programma massimo-02.pl
# Scritto da ... 
#
# Programma per trovare il valore lessicograficamente superiore
# tra tre stringhe.
#

$str1 = "";
$str2 = "";
$str3 = "";
$max  = "";

print STDOUT ("inserisci la prima stringa: ");
$str1 = <STDIN>;
chomp ($str1);
print STDOUT ("inserisci la seconda stringa: ");
$str2 = <STDIN>;             
chomp ($str2);
print STDOUT ("inserisci la terza stringa: ");
$str3 = <STDIN>;
chomp ($str3);

if ($str1 gt $str2)
  {
    $max = $str1;
  }
else
  {
    $max = $str2;
  }
if ($str3 gt $max)
  {
    $max = $str3;
  }

print STDOUT ("Il massimo tra \"$str1\", \"$str2\" e \"$str3\", è \"$max\"\n");

3 Equazione di primo e di secondo grado

L'equazione di primo grado ax+b=0 si risolve come x=-b/a, dove la soluzione è indeterminata se «a» e «b» hanno valore zero, oppure è impossibile se «a» vale zero e «b» ha un valore diverso da zero.

#!/usr/bin/perl -w
#
# Programma equazione-01.pl
# Scritto da ... 
#
# Programma per risolvere un'equazione di primo grado.
#

$a         = 0;
$b         = 0;
$soluzione = 0;

print STDOUT ("inserisci a: ");
$a = <STDIN>;
print STDOUT ("inserisci b: ");
$b = <STDIN>;

if ($a == 0 && $b == 0)
  {
    print STDOUT ("L'equazione è indeterminata\n");
  }
elsif ($a == 0 && $b != 0)
  {
    print STDOUT ("l'equazione è impossibile\n");
  }
elsif ($a != 0)
  {
    $soluzione = -$b/$a;
    print STDOUT ("la soluzione è $soluzione\n");
  }

Equazione di secondo grado.

#!/usr/bin/perl -w
#
# Programma equazione-02.pl
# Scritto da ... 
#
# Programma per risolvere un'equazione di secondo grado.
#

$a         = 0;
$b         = 0;
$c         = 0;
$discri    = 0;
$x1        = 0;
$x2        = 0;

print STDOUT ("inserisci a: ");
$a = <STDIN>;
print STDOUT ("inserisci b: ");
$b = <STDIN>;
print STDOUT ("inserisci c: ");
$c = <STDIN>;

$discri = $b ** 2 - 4*$a*$c;

if ($a == 0)
  {
    print STDOUT ("L'equazione è di primo grado\n");
  }
elsif ($discri < 0)
  {
    print STDOUT ("La soluzione è imposibile: il discriminante è $discri\n");
  }
elsif ($discri == 0)
  {
    $x1 = -$b/(2*$a);
    print STDOUT ("Le soluzioni sono reali e coincidenti x1=x2= $x1\n");
  }
elsif ($discri > 0)
  {
    $x1 = (-$b - sqrt($discri))/(2*$a);
    $x2 = (-$b + sqrt($discri))/(2*$a);
    print STDOUT ("Le soluzioni sono x1= $x1 e x2= $x2 \n");
  }

4 Somma ciclica

Lo scopo di questi esercizi è quello di far prendere confidenza con le strutture iterative ed enumerative.

Ciclo iterativo.

#!/usr/bin/perl -w
#
# Programma somma-01.pl
# Scritto da ... 
#
# Programma per sommare i primi k numeri naturali.
# Utilizza la struttura while.
#

$k     = 0;
$n     = 0;
$somma = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);
$n = 1;
$somma = 0;
while ($n <= $k)
  {
    $somma = $somma +$n;
    $n = $n + 1;
  }

print STDOUT ("La somma dei primi $k numeri è $somma\n");

Ciclo iterativo con una struttura differente.

#!/usr/bin/perl -w
#
# Programma somma-02.pl
# Scritto da ... 
#
# Programma per sommare i primi k numeri naturali.
# Utilizza la struttura until.
#

$k     = 0;
$n     = 0;
$somma = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);
$n = 1;
$somma = 0;
until ($n > $k)
  {
    $somma = $somma +$n;
    $n = $n + 1;
  }

print STDOUT ("La somma dei primi $k numeri è $somma\n");

Ciclo enumerativo.

#!/usr/bin/perl -w
#
# Programma somma-03.pl
# Scritto da ... 
#
# Programma per sommare i primi k numeri naturali.
# Utilizza la struttura for.
#

$k     = 0;
$n     = 0;
$somma = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);

$somma = 0;
for ($n = 1; $n <= $k; $n++)
  {
    $somma += $n;
  }

print STDOUT ("La somma dei primi $k numeri è $somma\n");

Ciclo enumerativo più sofisticato.

#!/usr/bin/perl -w
#
# Programma somma-04.pl
# Scritto da ... 
#
# Programma per sommare i primi k numeri naturali.
# Utilizza la struttura for in modo più sofisticato.
#

$k     = 0;
$n     = 0;
$somma = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);

for ($somma = 0, $n = 1; $n <= $k; $somma += $n, $n++)
  {
    ;
  }

print STDOUT ("La somma dei primi $k numeri è $somma\n");

5 Prodotto ciclico

Lo scopo di questi esercizi è quello di far prendere confidenza con le strutture iterative ed enumerative.

Ciclo iterativo.

#!/usr/bin/perl -w
#
# Programma prodotto-01.pl
# Scritto da ... 
#
# Programma per moltiplicare i primi k numeri naturali.
# Utilizza la struttura while.
#

$k        = 0;
$n        = 0;
$prodotto = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);
$n = 1;
$prodotto = 1;
while ($n <= $k)
  {
    $prodotto = $prodotto * $n;
    $n = $n + 1;
  }
print STDOUT ("il prodotto dei primi $k numeri è $prodotto\n");

Ciclo iterativo con una struttura differente.

#!/usr/bin/perl -w
#
# Programma prodotto-02.pl
# Scritto da ... 
#
# Programma per moltiplicare i primi k numeri naturali.
# Utilizza la struttura until.
#

$k        = 0;
$n        = 0;
$prodotto = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);
$n = 1;
$prodotto = 1;
until ($n > $k)
  {
    $prodotto = $prodotto * $n;
    $n = $n + 1;
  }

print STDOUT ("il prodotto dei primi $k numeri è $prodotto\n");

Ciclo enumerativo.

#!/usr/bin/perl -w
#
# Programma prodotto-03.pl
# Scritto da ... 
#
# Programma per moltiplicare i primi k numeri naturali.
# Utilizza la struttura for.
#

$k        = 0;
$n        = 0;
$prodotto = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);

$prodotto = 1;
for ($n = 1; $n <= $k; $n++)
  {
    $prodotto *= $n;
  }

print STDOUT ("il prodotto dei primi $k numeri è $prodotto\n");

Ciclo enumerativo più sofisticato.

#!/usr/bin/perl -w
#
# Programma prodotto-04.pl
# Scritto da ... 
#
# Programma per moltiplicare i primi k numeri naturali.
# Utilizza la struttura for in modo più sofisticato.
#

$k        = 0;
$n        = 0;
$prodotto = 0;

print STDOUT ("inserisci il valore per k: ");
$k = <STDIN>;
chomp ($k);

for ($prodotto = 1, $n = 1; $n <= $k; $prodotto *= $n, $n++)
  {
    ;
  }

print STDOUT ("il prodotto dei primi $k numeri è $prodotto\n");

6 Scansione di array

Lo scopo di questi esercizi è quello di far prendere confidenza con la scansione degli array.

Il primo esercizio mostra l'inserimento di dati all'interno di un vettore (in forma di array) e la sua scansione allo scopo di mostrarne il contenuto.

#!/usr/bin/perl -w
#
# Programma vettore-01.pl
# Scritto da ... 
#
# Programma per inserire dati all'interno di un vettore e per visualizzarli.
#

@vettore = ();
$k       = 0;
$i       = 0;

print STDOUT ("inserisci l'indice massimo del vettore: ");
$k = <STDIN>;
chomp ($k);

# Inserimento.
for ($i = 0; $i <= $k; $i++)
  {
    print STDOUT ("inserisci l'elemento $i:"); 
    $vettore[$i] = <STDIN>;
    chomp ($vettore[$i]);
  } 

# Visualizzazione.
print STDOUT ("Gli elementi del vettore sono: ");
for ($i = 0; $i <= $k; $i++ )
  {
    print STDOUT ($vettore[$i]);
    print STDOUT (" ");
  }
print STDOUT ("\n");

Il secondo esercizio mostra la ricerca del valore massimo all'interno di un vettore non ordinato.

#!/usr/bin/perl -w
#
# Programma vettore-02.pl
# Scritto da ... 
#
# Programma per cercare il valore massimo all'interno di un vettore
# non ordinato.
#

@vettore = ();
$k       = 0;
$i       = 0;
$max     = 0;

print STDOUT ("inserisci l'indice massimo del vettore: ");
$k = <STDIN>;
chomp ($k);

# Inserimento.
for ($i = 0; $i <= $k; $i++)
  {
    print STDOUT ("inserisci l'elemento $i:"); 
    $vettore[$i] = <STDIN>;
    chomp ($vettore[$i]);
  } 

# Scansione di ricerca del massimo.
for ($i = 0; $i <= $k; $i++ )
  {
    if ($vettore[$i] > $max)
      {
        $max = $vettore[$i];
      }
  }

# Risultato.
print STDOUT ("Il massimo è $max\n");

Nel terzo esercizio si aggiunge un controllo nel caso in cui il vettore da scandire sia vuoto.

#!/usr/bin/perl -w
#
# Programma vettore-03.pl
# Scritto da ... 
#
# Programma per cercare il valore massimo all'interno di un vettore
# non ordinato. Se il vettore è vuoto non si esegue alcuna scansione.
#

@vettore = ();
$k       = 0;
$i       = 0;
$max     = 0;

print STDOUT ("inserisci l'indice massimo del vettore: ");
$k = <STDIN>;
chomp ($k);

# Inserimento.
for ($i = 0; $i <= $k; $i++)
  {
    print STDOUT ("inserisci l'elemento $i:"); 
    $vettore[$i] = <STDIN>;
    chomp ($vettore[$i]);
  } 

# Scansione di ricerca del massimo.
if ($k < 0)
  {
    print STDOUT ("Non ci sono elementi nel vettore\n");
  }
else
  {
    for ($i = 0; $i <= $k; $i++ )
      {
        if ($vettore[$i] > $max)
          {
            $max = $vettore[$i];
          }
      }

    # Risultato.
    print STDOUT ("Il massimo è $max\n");
  }

Ordinamento di un vettore con l'algoritmo Bubblesort. L'elaborazione avviene con cicli iterativi.

#!/usr/bin/perl -w
#
# Programma vettore-04.pl
# Scritto da ... 
#
# Programma per riordinare gli elementi di un vettore.
# Si utilizza la struttura while.
#

@vettore = ();
$k       = 0;
$i       = 0;
$j       = 0;
$scambio = 0;

print STDOUT ("Inserisci l'indice massimo del vettore: ");
$k = <STDIN>;
chomp ($k);

# Inserimento.
for ($i = 0; $i <= $k; $i++)
  {
    print STDOUT ("inserisci l'elemento $i:"); 
    $vettore[$i] = <STDIN>;
    chomp ($vettore[$i]);
  } 

# Riordino.
$j = $k;
while ($j >= 1)
  {
    $i = 0;     
    while ($i <= $j-1)
      {
        if ($vettore[$i] > $vettore[$i+1])
          {
            $scambio = $vettore[$i];
            $vettore[$i] = $vettore[$i+1];
            $vettore[$i+1] = $scambio;
          }
        $i++;
      }
    $j--        
  }

# Visualizzazione.
print STDOUT ("Il vettore ordinato è: ");
for ($i = 0; $i <= $k; $i++ )
  {
    print STDOUT ($vettore[$i]);
    print STDOUT (" ");
  }
print STDOUT ("\n");

Ordinamento di un vettore con l'algoritmo Bubblesort. Questa volta si usano cicli enumerativi.

#!/usr/bin/perl -w
#
# Programma vettore-05.pl
# Scritto da ... 
#
# Programma per riordinare gli elementi di un vettore.
# Si utilizza la struttura for.
#

@vettore = ();
$k       = 0;
$i       = 0;
$j       = 0;
$scambio = 0;

print STDOUT ("Inserisci l'indice massimo del vettore: ");
$k = <STDIN>;
chomp ($k);

# Inserimento.
for ($i = 0; $i <= $k; $i++)
  {
    print STDOUT ("inserisci l'elemento $i:"); 
    $vettore[$i] = <STDIN>;
    chomp ($vettore[$i]);
  } 

# Riordino.
$j = $k;

for ($j = $k; $j >= 1; $j--)
  {
    for ($i = 0; $i <= $j-1; $i++)
      {
        if ($vettore[$i] > $vettore[$i+1])
          {
            $scambio = $vettore[$i];
            $vettore[$i] = $vettore[$i+1];
            $vettore[$i+1] = $scambio;
          }
      }
  }

# Visualizzazione.
print STDOUT ("Il vettore ordinato è: ");
for ($i = 0; $i <= $k; $i++ )
  {
    print STDOUT ($vettore[$i]);
    print STDOUT (" ");
  }
print STDOUT ("\n");

7 Elaborazione con in file

Questi esercizi servono a prendere un po' di confidenza con la lettura e la scrittura dei file.

I flussi di file standard risultano già aperti. Il primo esercizio mostra la lettura e la scrittura con questi flussi.

#!/usr/bin/perl -w
#
# Programma file-01.pl
# Scritto da ... 
#
# Programma per il trasferimento dello standard input nello
# standard output.
#

$riga = "";

while ($riga = <STDIN>)
  {
    print STDOUT ($riga);
  }

Nel caso si vogliano gestire altri file, è necessario aprire il flusso di file relativo. Nel prossimo esercizio si visualizza il contenuto di un file, il cui nome viene specificato in modo interattivo.

#!/usr/bin/perl -w
#
# Programma file-02.pl
# Scritto da ... 
#
# Programma per la visualizzazione del contenuto di un file.
#

$mio_file = "";
$riga     = "";

print STDOUT ("Inserisci il nome del file da leggere: ");
$mio_file = <STDIN>;
chomp ($mio_file);

open (PRIMOFILE, "< $mio_file");

while ($riga = <PRIMOFILE>)
  {
    print STDOUT ($riga);
  }

close (PRIMOFILE);

La stringa che identifica il flusso di file può anche essere contenuta in una variabile.

#!/usr/bin/perl -w
#
# Programma file-03.pl
# Scritto da ... 
#
# Programma per la visualizzazione del contenuto di un file.
#

$mio_file = "";
$riga     = "";
$flusso   = "";

print STDOUT ("Inserisci il nome del file da leggere: ");
$mio_file = <STDIN>;
chomp ($mio_file);

$flusso = "PRIMOFILE";
open ($flusso, "< $mio_file");

while ($riga = <$flusso>)
  {
    print STDOUT ($riga);
  }

close ($flusso);

Copia di un file.

#!/usr/bin/perl -w
#
# Programma file-04.pl
# Scritto da ... 
#
# Programma per copiare un file.
#

$file_origine        = "";
$file_destinazione   = "";
$flusso_origine      = "";
$flusso_destinazione = "";
$riga                = "";

print STDOUT ("Inserisci il nome del file di origine: ");
$file_origine = <STDIN>;
chomp ($file_origine);
print STDOUT ("Inserisci il nome del file di destinazione: ");
$file_destinazione = <STDIN>;
chomp ($file_destinazione);

$flusso_origine      = "ORIGINE";
$flusso_destinazione = "DESTINAZIONE";

open ($flusso_origine, "< $file_origine");
open ($flusso_destinazione, "> $file_destinazione");

while ($riga = <$flusso_origine>)
  {
    print $flusso_destinazione ($riga);
  }

close ($flusso_destinazione);
close ($flusso_origine);

Copia di un file, utilizzando i nomi forniti come argomenti della riga di comando.

#!/usr/bin/perl -w
#
# Programma file-05.pl
# Scritto da ... 
#
# Programma per copiare un file. Utilizza i nomi indicati nella
# riga di comando.
#

$file_origine        = "";
$file_destinazione   = "";
$flusso_origine      = "";
$flusso_destinazione = "";
$riga                = "";

$file_origine        = $ARGV[0];
$file_destinazione   = $ARGV[1];

$flusso_origine      = "ORIGINE";
$flusso_destinazione = "DESTINAZIONE";

open ($flusso_origine, "< $file_origine");
open ($flusso_destinazione, "> $file_destinazione");

while ($riga = <$flusso_origine>)
  {
    print $flusso_destinazione ($riga);
  }

close ($flusso_destinazione);
close ($flusso_origine);

Appunti di informatica libera 2001.01.30 --- Copyright (c) Daniele Giacomini -- daniele @ swlibero.org