Perl Language
Archivo I / O (lectura y escritura de archivos)

Parámetros

Observaciones

Leyendo de un archivo

my $filename = '/path/to/file';

open my $fh, '<', $filename or die "Failed to open file: $filename"; 
    
# You can then either read the file one line at a time...
while(chomp(my $line = <$fh>)) {
    print $line . "\n";
}

# ...or read whole file into an array in one go
chomp(my @fileArray = <$fh>); 

Si sabe que su archivo de entrada es UTF-8, puede especificar la codificación:

open my $fh, '<:encoding(utf8)', $filename or die "Failed to open file: $filename";

Después de terminar de leer el archivo, se debe cerrar el identificador de archivo:

close $fh or warn "close failed: $!";

Ver también: Leer un archivo en una variable.

Otra forma más rápida de leer un archivo es usar File :: Slurper Module. Esto es útil si trabajas con muchos archivos.

use File::Slurper;
my $file = read_text("path/to/file"); # utf8 without CRLF transforms by default
print $file; #Contains the file body

Ver también: [Leyendo un archivo con sorbete]

Escribir en un archivo

Este código abre un archivo para escribir. Devuelve un error si no se pudo abrir el archivo. También cierra el archivo al final.

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

# Open "output.txt" for writing (">") and from now on, refer to it as the variable $fh.
open(my $fh, ">", "output.txt")
# In case the action failed, print error message and quit.
or die "Can't open > output.txt: $!";

Ahora tenemos un archivo abierto listo para la escritura que se accede a través de $fh (esta variable se denomina gestor de archivo). A continuación podemos dirigir la salida a ese archivo usando el operador de print :

# Print "Hello" to $fh ("output.txt").
print $fh "Hello";
# Don't forget to close the file once we're done!
close $fh or warn "Close failed: $!";

El operador open tiene una variable escalar ( $fh en este caso) como su primer parámetro. Como se define en el operador open , se trata como un identificador de archivo . El segundo parámetro ">" (mayor que) define que el archivo está abierto para escritura. El último parámetro es la ruta del archivo para escribir los datos.

Para escribir los datos en el archivo, el operador de print se utiliza junto con el identificador de archivo. Observe que en el operador de print no hay una coma entre el identificador de archivo y la declaración en sí, solo el espacio en blanco.

Abriendo una manija de archivo para leer

Apertura de archivos de texto ASCII genéricos

open my $filehandle, '<', $name_of_file or die "Can't open $name_of_file, $!";

Apertura de archivos binarios

open my $filehandle, '<:raw', 'path/to/file' or die "Can't open $name_of_file, $!";

Apertura de archivos de texto UTF8

open my $filehandle, '<:raw:encoding(utf-8)', 'path/to/file' 
   or die "Can't open $name_of_file, $!";

Leer y escribir en un archivo.

Antes de leer y escribir archivos de texto, debe saber qué codificación utilizar. Consulte la documentación de Perl Unicode para obtener más detalles sobre la codificación . Aquí mostramos la configuración de UTF-8 como la codificación y decodificación predeterminadas para la función open . Esto se hace usando el pragma open cerca de la parte superior de su código (justo después de su use strict; y use warnings; sería apropiado):

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); 

La función open crea un identificador de archivo que se utiliza para leer y / o escribir en un archivo. La función open tiene la firma.

open(FILEHANDLE, MODE, FILEPATH) y devuelve un valor falso si la operación falla. La descripción del error se almacena en $! .

Leyendo

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '<', $file_path) or die "Could not open file! $!";

while(my $row = <$file_handle>) {
    print chomp($row), "\n";
}

close $file_handle 
      or warn "Close failed!";

Escritura

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '>', $file_path) or die "Could not open file! $!";

print $file_handle "Writing to a file";

close $file_handle 
      or warn "Close failed!";

Lectura de trozos

Abrir y leer archivos grandes puede llevar tiempo y recursos. Si solo se requiere una pequeña parte del contenido, puede ser una buena idea leer el contenido en fragmentos utilizando la función de read que tiene la firma

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

FILEHANDLE debe ser un identificador de archivo abierto, SCALAR mantendrá los datos de lectura después de la operación. LENGTH especifica el número de caracteres que se leerán a partir de la OFFSET . La función devuelve el número de caracteres leídos, 0 si se alcanzó el final del archivo y undef en caso de error.

read($file_handle, $data, 16, 0); 

Lee 16 caracteres desde el principio del archivo en $data .

"use autodie" y no necesitará verificar los errores de apertura / cierre de archivos

autodie permite trabajar con archivos sin tener que verificar explícitamente las fallas de apertura / cierre.

Desde Perl 5.10.1, autodie ha estado disponible en Core Perl. Cuando se utiliza, Perl buscará automáticamente errores al abrir y cerrar archivos.

Aquí hay un ejemplo en el que todas las líneas de un archivo se leen y luego se escriben al final de un archivo de registro.

use 5.010;    # 5.010 and later enable "say", which prints arguments, then a newline
use strict;   # require declaring variables (avoid silent errors due to typos)
use warnings; # enable helpful syntax-related warnings
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding
use autodie;  # Automatically handle errors in opening and closing files

open(my $fh_in, '<', "input.txt"); # check for failure is automatic

# open a file for appending (i.e. using ">>")
open( my $fh_log, '>>', "output.log"); # check for failure is automatic

while (my $line = readline $fh_in) # also works: while (my $line = <$fh_in>)
{
     # remove newline
     chomp $line;

     # write to log file
     say $fh_log $line or die "failed to print '$line'"; # autodie doesn't check print
}

# Close the file handles (check for failure is automatic)
close $fh_in;
close $fh_log;

Por cierto, técnicamente siempre debe verificar print declaraciones de print . Muchas personas no lo hacen, pero perl (el intérprete de Perl) no lo hace automáticamente y tampoco lo hace el autodie .

Rebobinar un identificador de archivo

A veces es necesario dar marcha atrás después de leer.

# identify current position in file, in case the first line isn't a comment
my $current_pos = tell; 

while (my $line = readline $fh)
{
    if ($line =~ /$START_OF_COMMENT_LINE/)
    {
        push @names, get_name_from_comment($line);
    }
    else {
        last; # break out of the while loop
    }
    $current_pos = tell; # keep track of current position, in case we need to rewind the next line read
}

# Step back a line so that it can be processed later as the first data line
seek $fh, $current_pos, 0;

Lectura y escritura de archivos comprimidos gzip

Escribiendo un archivo comprimido

Para escribir un archivo comprimido, use el módulo IO::Compress::Gzip y cree un identificador de archivo creando una nueva instancia de IO::Compress::Gzip para el archivo de salida deseado:

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Compress::Gzip;

my $fh_out = IO::Compress::Gzip->new("hello.txt.gz");

print $fh_out "Hello World!\n";

close $fh_out;

use IO::Compress::Gzip;

Leyendo de un archivo comprimido

Para leer un archivo comprimido, use el módulo IO::Uncompress::Gunzip y luego cree un identificador de archivo creando una nueva instancia de IO::Uncompress::Gunzip para el archivo de entrada:

#!/bin/env perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Uncompress::Gunzip;

my $fh_in = IO::Uncompress::Gunzip->new("hello.txt.gz");

my $line = readline $fh_in;

print $line;

Configuración de la codificación predeterminada para IO

# encode/decode UTF-8 for files and standard input/output
use open qw( :encoding(UTF-8) :std ); 

Este pragma cambia el modo predeterminado de lectura y escritura de texto (archivos, entrada estándar, salida estándar y error estándar) a UTF-8, que suele ser lo que desea al escribir nuevas aplicaciones.

ASCII es un subconjunto de UTF-8, por lo que no se espera que cause ningún problema con los archivos ASCII heredados y le ayudará a protegerse contra la corrupción accidental de archivos que puede ocurrir cuando se tratan archivos UTF-8 como ASCII.

Sin embargo, es importante que sepa cuál es la codificación de sus archivos con los que está tratando y los maneje en consecuencia. ( Razones por las que no debemos ignorar Unicode ) . Para un tratamiento más profundo de Unicode, consulte el tema Perl Unicode .