Este es el comando perlfaq5 que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas, como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.
PROGRAMA:
NOMBRE
perlfaq5 - Archivos y formatos
VERSION
Versión 5.021009
DESCRIPCIÓN
En esta sección se tratan los problemas de E / S y "f": identificadores de archivos, vaciado, formatos y
pies de página.
Cómo do I vaciar / eliminar búfer an salida identificador de archivo? ¿Por Qué Elegir un Agente de Compras de Yiwu? deben I do todo esto?
(contribución de brian d foy)
Puede que le guste leer "Suffering From Buffering" de Mark Jason Dominus en
<http://perl.plover.com/FAQs/Buffering.html>.
Perl normalmente almacena la salida en búfer, por lo que no realiza una llamada al sistema para cada bit de salida. Por
ahorrando salida, hace menos costosas llamadas al sistema. Por ejemplo, en este pequeño
de código, desea imprimir un punto en la pantalla por cada línea que procese para ver el
progreso de su programa. En lugar de ver un punto por cada línea, Perl almacena la salida
y tienes que esperar mucho antes de ver una fila de 50 puntos todos a la vez:
# espera larga, luego fila de puntos todos a la vez
while (<>) {
impresión ".";
imprimir "\ n" a menos que ++ $ count% 50;
# ... costosas operaciones de procesamiento de línea
}
Para evitar esto, debe eliminar el búfer del identificador del archivo de salida, en este caso, "STDOUT".
Puede establecer la variable especial $ | a un valor verdadero (mnemotécnico: hacer que sus identificadores de archivo
"muy caliente"):
$ | ++;
# punto mostrado inmediatamente
while (<>) {
impresión ".";
imprimir "\ n" a menos que ++ $ count% 50;
# ... costosas operaciones de procesamiento de línea
}
El $ | es una de las variables especiales por identificador de archivo, por lo que cada identificador de archivo tiene su propia copia
de su valor. Si desea fusionar la salida estándar y el error estándar, por ejemplo,
tienen que eliminar el búfer de cada uno (aunque STDERR puede no tener búfer de forma predeterminada):
{
my $ previous_default = seleccionar (STDOUT); # guardar el valor predeterminado anterior
$ | ++; # autoflush STDOUT
seleccione (STDERR);
$ | ++; # autoflush STDERR, para estar seguro
seleccionar ($ previous_default); # restaurar el valor predeterminado anterior
}
# ahora debería alternar. y +
while (1) {
dormir 1;
imprimir STDOUT ".";
imprimir STDERR "+";
imprimir STDOUT "\ n" a menos que ++ $ count% 25;
}
Además del $ | variable especial, puede usar "binmode" para darle a su identificador de archivo un ": unix"
capa, que no tiene búfer:
binmode (STDOUT, ": unix");
while (1) {
dormir 1;
impresión ".";
imprimir "\ n" a menos que ++ $ count% 50;
}
Para obtener más información sobre las capas de salida, consulte las entradas para "binmode" y abra en perlfunc,
y la documentación del módulo PerlIO.
Si está utilizando IO :: Handle o una de sus subclases, puede llamar al método "autoflush"
para cambiar la configuración del identificador de archivo:
use IO :: Handle;
abre mi ($ io_fh), ">", "salida.txt";
$ io_fh->lavado automático(1);
Los objetos IO :: Handle también tienen un método "flush". Puede vaciar el búfer en cualquier momento
quiero sin almacenamiento automático en búfer
$ io_fh-> flush;
Cómo do I cambiar, borrar, or insertar a línea in a archivo, or anexar a de la forma más comienzo of a archivo?
(contribución de brian d foy)
La idea básica de insertar, cambiar o eliminar una línea de un archivo de texto implica
leer e imprimir el archivo hasta el punto en el que desea realizar el cambio, realizar el cambio,
luego leer e imprimir el resto del archivo. Perl no proporciona acceso aleatorio a
líneas (especialmente porque el separador de entrada de registros, $ /, es mutable), aunque módulos como
ya que Tie :: File puede falsificarlo.
Un programa Perl para realizar estas tareas toma la forma básica de abrir un archivo e imprimir su
líneas, luego cerrando el archivo:
abra mi archivo $ in, '<', $ o muera "No se puede leer el archivo antiguo: $!";
abre mi $ out, '>', "$ file.new" o muere "No se puede escribir un archivo nuevo: $!";
while (<$ in>) {
imprimir $ fuera $ _;
}
cerrar $ out;
Dentro de esa forma básica, agregue las partes que necesita para insertar, cambiar o eliminar líneas.
Para anteponer líneas al principio, imprima esas líneas antes de ingresar al bucle que imprime
las líneas existentes.
abra mi archivo $ in, '<', $ o muera "No se puede leer el archivo antiguo: $!";
abre mi $ out, '>', "$ file.new" o muere "No se puede escribir un archivo nuevo: $!";
print $ out "# Agrega esta línea al principio \ n"; # <--- AQUÍ ESTÁ LA MAGIA
while (<$ in>) {
imprimir $ fuera $ _;
}
cerrar $ out;
Para cambiar las líneas existentes, inserte el código para modificar las líneas dentro del ciclo "while". En
en este caso, el código busca todas las versiones en minúsculas de "perl" y las pone en mayúsculas. los
sucede para cada línea, así que asegúrese de que se supone que debe hacer eso en cada línea.
abra mi archivo $ in, '<', $ o muera "No se puede leer el archivo antiguo: $!";
abre mi $ out, '>', "$ file.new" o muere "No se puede escribir un archivo nuevo: $!";
print $ out "# Agrega esta línea al principio \ n";
while (<$ in>) {
s / \ b (perl) \ b / Perl / g;
imprimir $ fuera $ _;
}
cerrar $ out;
Para cambiar solo una línea en particular, el número de línea de entrada, $., Es útil. Primero lea y
imprima las líneas hasta la que desea cambiar. A continuación, lea la única línea que desee
cámbielo, cámbielo e imprímalo. Después de eso, lea el resto de las líneas e imprímalas:
while (<$ in>) {# imprime las líneas antes del cambio
imprimir $ fuera $ _;
último si $. == 4; # número de línea antes del cambio
}
mi $ línea = <$ en>;
$ línea = ~ s / \ b (perl) \ b / Perl / g;
imprimir $ línea $;
while (<$ in>) {# imprime el resto de las líneas
imprimir $ fuera $ _;
}
Para omitir líneas, use los controles de bucle. El "siguiente" en este ejemplo omite las líneas de comentarios,
y el "último" detiene todo el procesamiento una vez que encuentra "__END__" o "__DATA__".
while (<$ in>) {
siguiente si / ^ \ s + # /; # omitir líneas de comentarios
último si / ^ __ (FIN | DATOS) __ $ /; # detener al final del marcador de código
imprimir $ fuera $ _;
}
Haga lo mismo para eliminar una línea en particular usando "siguiente" para omitir las líneas
no desea aparecer en la salida. Este ejemplo omite cada quinta línea:
while (<$ in>) {
siguiente a menos que $. % 5;
imprimir $ fuera $ _;
}
Si, por alguna extraña razón, realmente desea ver el archivo completo a la vez en lugar de
procesando línea por línea, puede sorberlo (siempre que pueda encajar todo en
¡memoria!):
abra mi archivo $ in, '<', $ o muera "No se puede leer el archivo antiguo: $!"
abre mi $ out, '>', "$ file.new" o muere "No se puede escribir un archivo nuevo: $!";
my $ content = hacer {local $ /; <$ en>}; # ¡sorber!
# haz tu magia aquí
imprimir $ contenido $;
Módulos como Path :: Tiny y Tie :: File también pueden ayudar con eso. Sin embargo, si puedes
evite leer todo el archivo a la vez. Perl no devolverá esa memoria a la operación
sistema hasta que finalice el proceso.
También puede utilizar frases breves de Perl para modificar un archivo en el lugar. Lo siguiente cambia todo
'Fred' a 'Barney' en enArchivo.txt, sobrescribiendo el archivo con el nuevo contenido. Con el
Interruptor "-p", Perl envuelve un bucle "while" alrededor del código que especifica con "-e" y "-i"
activa la edición in situ. La línea actual está en $ _. Con "-p", Perl imprime automáticamente
el valor de $ _ al final del ciclo. Consulte perlrun para obtener más detalles.
perl -pi -e 's / Fred / Barney /' inFile.txt
Para hacer una copia de seguridad de "inFile.txt", asigne a "-i" una extensión de archivo para agregar:
perl -pi.bak -e 's / Fred / Barney /' inFile.txt
Para cambiar solo la quinta línea, puede agregar una comprobación de prueba $., El número de línea de entrada, luego
solo realice la operación cuando la prueba pase:
perl -pi -e 's / Fred / Barney / if $. == 5 'inFile.txt
Para agregar líneas antes de una determinada línea, puede agregar una línea (¡o líneas!) Antes de que Perl imprima $ _:
perl -pi -e 'print "Poner antes de la tercera línea \ n" if $. == 3 'inFile.txt
Incluso puede agregar una línea al principio de un archivo, ya que la línea actual se imprime en el
final del ciclo:
perl -pi -e 'print "Poner antes de la primera línea \ n" if $. == 1 'inFile.txt
Para insertar una línea después de una que ya está en el archivo, use el interruptor "-n". Es como "-p"
excepto que no imprime $ _ al final del ciclo, por lo que debe hacerlo usted mismo.
En este caso, imprima $ _ primero, luego imprima la línea que desea agregar.
perl -ni -e 'imprimir; imprimir "Poner después de la quinta línea \ n" si $. == 5 'inFile.txt
Para eliminar líneas, imprima solo las que desee.
perl -ni -e 'imprimir si / d /' inFile.txt
Cómo do I contar de la forma más número of líneas in a archivo?
(contribución de brian d foy)
Conceptualmente, la forma más fácil de contar las líneas en un archivo es simplemente leerlas y
cuéntalos:
my $ count = 0;
while (<$ fh>) {$ count ++; }
Sin embargo, no es necesario que los cuente usted mismo, ya que Perl ya lo hace con
el $. variable, que es el número de línea actual del último identificador de archivo leído:
1 mientras (<$ fh>);
my $ count = $ .;
Si desea usar $., Puede reducirlo a una simple línea, como una de estas:
% perl -lne '} print $ .; {' expediente
% perl -lne 'END {imprimir $. }' expediente
Sin embargo, esos pueden ser bastante ineficientes. Si no son lo suficientemente rápidos para ti, puedes
leer fragmentos de datos y contar el número de líneas nuevas:
mis $ líneas = 0;
abre mi ($ fh), '<: raw', $ filename o muere "¡No se puede abrir $ filename: $!";
while (sysread $ fh, $ buffer, 4096) {
$ líneas + = ($ búfer = ~ tr / \ n //);
}
cerrar $ fh;
Sin embargo, eso no funciona si el final de la línea no es una nueva línea. Podrías cambiar eso
"tr ///" a "s ///" para que pueda contar el número de veces que el separador de registros de entrada, $ /,
aparece:
mis $ líneas = 0;
abre mi ($ fh), '<: raw', $ filename o muere "¡No se puede abrir $ filename: $!";
while (sysread $ fh, $ buffer, 4096) {
$ líneas + = ($ búfer = ~ s | $ / || g;);
}
cerrar $ fh;
Si no le importa gastar dinero, el comando "wc" suele ser el más rápido, incluso con el
sobrecarga adicional entre procesos. Sin embargo, asegúrese de tener un nombre de archivo no contaminado:
#! perl -T
$ ENV {RUTA} = indef;
mis $ líneas;
if ($ filename = ~ /^([0-9a-z_.]+)\z/) {
$ líneas = `/ usr / bin / wc -l $ 1`
chomp $ líneas;
}
Cómo do I borrar de la forma más pasado N líneas obtenidos de a archivo?
(contribución de brian d foy)
La solución conceptual más sencilla es contar las líneas en el archivo y luego comenzar en el
al principio e imprime el número de líneas (menos la última N) en un nuevo archivo.
Muy a menudo, la pregunta real es cómo puede eliminar las últimas N líneas sin hacer más
de una pasada sobre el archivo, o cómo hacerlo sin mucha copia. El concepto fácil es
la dura realidad cuando puede tener millones de líneas en su archivo.
Un truco es usar File :: ReadBackwards, que comienza al final del archivo. Ese modulo
proporciona un objeto que envuelve el identificador de archivo real para que le sea más fácil moverse
el archivo. Una vez que llegue al lugar que necesita, puede obtener el identificador de archivo real y trabajar
con él como de costumbre. En este caso, obtiene la posición del archivo al final de la última línea que
desea conservar y truncar el archivo hasta ese punto:
use File :: ReadBackwards;
my $ nombre de archivo = 'prueba.txt';
my $ Lines_to_truncate = 2;
my $ bw = File :: ReadBackwards-> new ($ nombre de archivo)
or die "No se pudo leer al revés en [$ filename]: $!";
my $ lines_from_end = 0;
hasta ($ bw-> eof o $ lines_from_end == $ Lines_to_truncate) {
imprimir "Got:", $ bw-> readline;
$ lines_from_end ++;
}
truncar ($ nombre de archivo, $ bw-> decir);
El módulo File :: ReadBackwards también tiene la ventaja de establecer el registro de entrada
separador a una expresión regular.
También puede utilizar el módulo Tie :: File que le permite acceder a las líneas a través de un enlace
formación. Puede utilizar operaciones normales de matriz para modificar su archivo, incluida la configuración de la última
índice y usando "empalme".
Cómo can I use Perl's "-YO" opción obtenidos de within a programa?
"-i" establece el valor de la variable $ ^ I de Perl, que a su vez afecta el comportamiento de "<>";
ver perlrun para más detalles. Modificando las variables apropiadas directamente, puede obtener
el mismo comportamiento dentro de un programa más grande. Por ejemplo:
#...
{
local ($ ^ I, @ARGV) = ('.orig', glob ("*. c"));
while (<>) {
si ($. == 1) {
print "Esta línea debería aparecer en la parte superior de cada archivo \ n";
}
s / \ b (p) conde \ b / $ {1} erl / i; # Corregir errores tipográficos, conservando el caso
impresión;
cierre ARGV si eof; # Restablecer $.
}
}
# $ ^ I y @ARGV vuelven a sus valores anteriores aquí
Este bloque modifica todos los archivos ".c" en el directorio actual, dejando una copia de seguridad del
datos originales de cada archivo en un nuevo archivo ".c.orig".
Cómo can I copia a archivo?
(contribución de brian d foy)
Utilice el módulo Archivo :: Copiar. Viene con Perl y puede hacer una copia real en todos los sistemas de archivos,
y hace su magia de forma portátil.
use File :: Copy;
copiar ($ original, $ new_copy) o morir "Copia fallida: $!";
Si no puede usar Archivo :: Copiar, tendrá que hacer el trabajo usted mismo: abra el archivo original,
abra el archivo de destino, luego imprima en el archivo de destino mientras lee el original.
También debe recordar copiar los permisos, el propietario y el grupo en el nuevo archivo.
Cómo do I make a temporal presentar ¿nombre?
Si no necesita saber el nombre del archivo, puede usar "open ()" con "undef" en su lugar
del nombre del archivo. En Perl 5.8 o posterior, la función "open ()" crea un anónimo
archivo temporal:
abre mi $ tmp, '+>', undef o muere $ !;
De lo contrario, puede utilizar el módulo File :: Temp.
use File :: Temp qw / tempfile tempdir /;
my $ dir = tempdir (LIMPIEZA => 1);
($ fh, $ nombre de archivo) = archivo temporal (DIR => $ dir);
# o si no necesita saber el nombre del archivo
my $ fh = tempfile (DIR => $ dir);
File :: Temp ha sido un módulo estándar desde Perl 5.6.1. Si no tienes un moderno
suficiente Perl instalado, use el método de clase "new_tmpfile" del módulo IO :: File para obtener
un identificador de archivo abierto para leer y escribir. Úselo si no necesita conocer el archivo
Nombre:
use IO :: File;
my $ fh = IO :: Archivo-> new_tmpfile ()
o muere "No se puede crear un nuevo archivo temporal: $!";
Si está comprometido a crear un archivo temporal a mano, use el ID de proceso y / o el
valor de tiempo actual. Si necesita tener muchos archivos temporales en un proceso, use un
mostrador:
EMPEZAR {
utilizar Fcntl;
use File :: Spec;
my $ temp_dir = Archivo :: Spec-> tmpdir ();
my $ file_base = sprintf "% d-% d-0000", $$, time;
my $ base_name = File :: Spec-> catfile ($ temp_dir, $ file_base);
sub archivo_temp {
my $ fh;
my $ count = 0;
hasta (definido (fileno ($ fh)) || $ count ++> 100) {
$ nombre_base = ~ s / - (\ d +) $ / "-". (1 + $ 1) / e;
# O_EXCL es necesario por motivos de seguridad.
sysopen $ fh, $ nombre_base, O_WRONLY | O_EXCL | O_CREAT;
}
if (definido fileno ($ fh)) {
return ($ fh, $ base_name);
}
else {
regreso ();
}
}
}
Cómo can I manipular longitud de registro fija los archivos?
La forma más eficiente es usar paquete() y deshacer(). Esto es más rápido que usar substr ()
al tomar muchas, muchas cuerdas. Es más lento para unos pocos.
Aquí hay un fragmento de código de muestra para dividir y volver a armar algo de formato fijo
líneas de entrada, en este caso de la salida de un ps normal al estilo de Berkeley:
# línea de entrada de muestra:
# 15158 p5 T 0:00 perl / home / tchrist / scripts / ahora-qué
my $ PS_T = 'A6 A4 A7 A5 A *';
abre mi $ ps, '- |', 'ps';
imprimir escalar <$ ps>;
my @fields = qw (comando pid tt stat time);
while (<$ ps>) {
mi% proceso;
@process {@fields} = desempaquetar ($ PS_T, $ _);
para mi $ campo (@fields) {
imprimir "$ campo: <$ proceso {$ campo}> \ n";
}
print 'line =', pack ($ PS_T, @process {@fields}), "\ n";
}
Hemos utilizado un trozo de hash para manejar fácilmente los campos de cada fila. Almacenar el
Las teclas en una matriz facilitan su operación en grupo o sobre ellas con "for".
También evita contaminar el programa con variables globales y utilizar referencias simbólicas.
Cómo can I make a manejador de archivos local a a subrutina? Cómo do I pass manijas de archivo entre
subrutinas? Cómo do I make an matriz of identificadores de archivo?
A partir de perl5.6, open() autovivifica los identificadores de archivos y directorios como referencias si lo pasa
una variable escalar no inicializada. A continuación, puede pasar estas referencias como cualquier otra
escalar y utilícelos en lugar de identificadores con nombre.
abra mi $ fh, $ nombre_archivo;
abre $ fh local, $ nombre_archivo;
print $ fh "¡Hola mundo! \ n";
archivo_proceso ($ fh);
Si lo desea, puede almacenar estos identificadores de archivos en una matriz o un hash. Si accedes a ellos
directamente, no son simples escalares y necesitas ayudar a "imprimir" colocando
la referencia del identificador de archivo entre llaves. Perl solo puede resolverlo por sí solo cuando el
La referencia de identificador de archivo es un escalar simple.
mi @fhs = ($ fh1, $ fh2, $ fh3);
para ($ i = 0; $ i <= $ # fhs; $ i ++) {
print {$ fhs [$ i]} "solo otra respuesta de Perl, \ n";
}
Antes de perl5.6, tenías que lidiar con varios modismos de typeglob que puedes ver en versiones más antiguas.
código.
abrir ARCHIVO, "> $ nombre de archivo";
process_typeglob (* ARCHIVO);
referencia_proceso (\ * ARCHIVO);
sub process_typeglob {local * FH = shift; imprimir FH "Typeglob!" }
sub process_reference {local $ fh = shift; print $ fh "¡Referencia!" }
Si desea crear muchos identificadores anónimos, debe consultar el símbolo o
IO :: Manejar módulos.
Cómo can I use a manejador de archivos ¿indirectamente?
Un identificador de archivo indirecto es el uso de algo que no sea un símbolo en un lugar
Se espera filehandle. Aquí hay formas de obtener identificadores de archivos indirectos:
$ fh = ALGUNOS_FH; # bareword es estricto-subs hostil
$ fh = "ALGUNOS_FH"; # estrictas referencias hostiles; solo el mismo paquete
$ fh = * ALGUNOS_FH; # typeglob
$ fh = \ * ALGUNOS_FH; # ref a typeglob (bendito)
$ fh = * ALGUNOS_FH {IO}; # bendito IO :: Manejar desde * SOME_FH typeglob
O puede utilizar el método "nuevo" de uno de los módulos IO :: * para crear un
filehandle y almacenarlo en una variable escalar.
use IO :: Handle; # 5.004 o superior
my $ fh = IO :: Handle-> new ();
Luego use cualquiera de ellos como lo haría con un identificador de archivo normal. En cualquier lugar donde Perl esté esperando un
identificador de archivo, en su lugar se puede utilizar un identificador de archivo indirecto. Un identificador de archivo indirecto es solo un
variable escalar que contiene un identificador de archivo. Funciones como "imprimir", "abrir", "buscar" o
" "El operador de diamante aceptará un identificador de archivo con nombre o una variable escalar
que contiene uno:
($ ifh, $ ofh, $ efh) = (* STDIN, * STDOUT, * STDERR);
print $ ofh "Escríbelo:";
my $ got = <$ ifh>
print $ efh "¿Qué fue eso? $ got";
Si está pasando un identificador de archivo a una función, puede escribir la función de dos formas:
sub aceptar_fh {
my $ fh = turno;
print $ fh "Enviando al identificador de archivo indirecto \ n";
}
O puede localizar un typeglob y usar el identificador de archivo directamente:
sub aceptar_fh {
local * FH = desplazamiento;
print FH "Enviando al identificador de archivo localizado \ n";
}
Ambos estilos funcionan con objetos o typeglobs de identificadores de archivos reales. (También podrían
trabajar con cadenas en algunas circunstancias, pero esto es arriesgado).
accept_fh (* STDOUT);
accept_fh ($ identificador);
En los ejemplos anteriores, asignamos el identificador de archivo a una variable escalar antes de usarlo.
Esto se debe a que solo variables escalares simples, no expresiones o subíndices de hashes o
matrices, se pueden utilizar con elementos integrados como "print", "printf" o el operador de diamante. Utilizando
algo que no sea una simple variable escalar como un identificador de archivo es ilegal y ni siquiera
compilar:
mi @fd = (* STDIN, * STDOUT, * STDERR);
print $ fd [1] "Escríbelo:"; # INCORRECTO
my $ got = <$ fd [0]> # INCORRECTO
print $ fd [2] "¿Qué fue eso? $ got"; # INCORRECTO
Con "print" y "printf", puedes solucionar esto usando un bloque y una expresión donde
colocaría el identificador de archivo:
print {$ fd [1]} "cosas divertidas \ n";
printf {$ fd [1]} "Lástima de los pobres% x. \ n", 3_735_928_559;
# Lástima por el pobre cadáver.
Ese bloque es un bloque adecuado como cualquier otro, por lo que puede colocar un código más complicado allí.
Esto envía el mensaje a uno de dos lugares:
my $ ok = -x "/ papelera / gato";
imprimir {$ ok? $ fd [1]: $ fd [2]} "cat stat $ ok \ n";
imprimir {$ fd [1+ ($ ok || 0)]} "cat stat $ ok \ n";
Este enfoque de tratar "print" y "printf" como llamadas a métodos de objeto no funciona para
el operador de diamantes. Eso es porque es un operador real, no solo una función con un
argumento sin comas. Suponiendo que ha estado almacenando typeglobs en su estructura como lo hicimos nosotros
arriba, puede usar la función incorporada llamada "readline" para leer un registro como "<>"
lo hace. Dada la inicialización que se muestra arriba para @fd, esto funcionaría, pero solo porque
readline () requiere un typeglob. No funciona con objetos o cadenas, lo que podría ser un
error que aún no hemos solucionado.
$ got = readline ($ fd [0]);
Cabe señalar que la escasez de los identificadores de archivos indirectos no está relacionada con si
son cadenas, typeglobs, objetos o cualquier otra cosa. Es la sintaxis de lo fundamental
operadores. Jugar al juego de objetos no te ayuda en absoluto aquí.
Cómo can I para reinventar la industria logística y redefinir las soluciones ecológicas para reinventar la industria logística y redefinir las soluciones ecológicas. up a pie de página formato a be usado con escribir()?
No hay una forma incorporada de hacer esto, pero perlform tiene un par de técnicas para hacerlo
posible para el intrépido hacker.
Cómo can I escribir() into a ¿cuerda?
(contribución de brian d foy)
Si desea "escribir" en una cadena, solo tiene que un identificador de archivo a una cuerda,
lo que Perl ha podido hacer desde Perl 5.6:
abre FH, '>', \ my $ string;
escribir (FH);
Como quieres ser un buen programador, probablemente quieras usar un identificador de archivo léxico,
aunque los formatos están diseñados para funcionar con identificadores de archivos de palabras sin formato, ya que
los nombres de formato toman el nombre del identificador de archivo. Sin embargo, puede controlar esto con algo de Perl
Variables especiales por identificador de archivo: $ ^, que nombra el formato de la parte superior de la página, y $ ~ que
muestra el formato de línea. Debe cambiar el identificador de archivo predeterminado para establecer estas variables:
abre mi ($ fh), '>', \ mi $ cadena;
{# establecer variables por identificador de archivo
my $ old_fh = seleccionar ($ fh);
$ ~ = 'ANIMAL';
$ ^ = 'ANIMAL_TOP';
seleccionar ($ old_fh);
}
formato ANIMAL_TOP =
Nombre del tipo de identificación
.
formato ANIMAL =
@ ## @ <<< @ <<<<<<<<<<<<<
$ id, $ tipo, $ nombre
.
Aunque la escritura puede funcionar con variables léxicas o de paquete, cualquier variable que use tiene
al alcance en el formato. Eso probablemente significa que querrá localizar algún paquete
variables:
{
local ($ id, $ tipo, $ nombre) = qw (12 cat Buster);
escribir ($ fh);
}
imprimir $ cadena;
También hay algunos trucos que puedes jugar con "formline" y la variable acumuladora
$ ^ A, pero pierde gran parte del valor de los formatos ya que "formline" no manejará la paginación y
pronto. Terminas reimplementando formatos cuando los usas.
Cómo can I abierto a manejador de archivos a a ¿cuerda?
(contribución de Peter J. Holzer, [email protected])
Desde Perl 5.8.0 se puede crear un identificador de archivo que hace referencia a una cadena llamando a open con un
referencia a esa cadena en lugar del nombre de archivo. Este identificador de archivo se puede utilizar para
leer o escribir en la cadena:
open (my $ fh, '>', \ $ string) o muere "No se pudo abrir la cadena para escribir";
imprimir $ fh "foo \ n";
imprimir $ fh "barra \ n"; # $ string ahora contiene "foo \ nbar \ n"
open (my $ fh, '<', \ $ string) o muere "No se pudo abrir la cadena para leer";
my $ x = <$ fh>; # $ x ahora contiene "foo \ n"
Con versiones anteriores de Perl, el módulo IO :: String proporciona una funcionalidad similar.
Cómo can I salida my números con comas ¿adicional?
(contribución de brian d foy y Benjamin Goldberg)
Puede usar Number :: Format para separar lugares en un número. Maneja información local
para aquellos de ustedes que quieran insertar puntos en su lugar (o cualquier otra cosa que quieran
uso, de verdad).
Esta subrutina agregará comas a su número:
subcomunicar {
local $ _ = turno;
1 mientras s / ^ ([- +]? \ D +) (\ d {3}) / $ 1, $ 2 /;
return $ _;
}
Esta expresión regular de Benjamin Goldberg agregará comas a los números:
s / (^ [- +]? \ d +? (? = (?> (?: \ d {3}) +) (?! \ d)) | \ G \ d {3} (? = \ d) ) / $ 1, / g;
Es más fácil de ver con comentarios:
s/(
^ [- +]? # comienzo del número.
\ d +? # primeros dígitos antes de la primera coma
(? = # seguido de, (pero no incluido en el partido):
(?> (?: \ d {3}) +) # algún múltiplo positivo de tres dígitos.
(?! \ d) # un múltiplo * exacto *, no x * 3 + 1 o lo que sea.
)
| # o:
\ G \ d {3} # después del último grupo, obtenga tres dígitos
(? = \ d) # pero deben tener más dígitos después de ellos.
) / $ 1, / xg;
Cómo can I la traducción tildes (~) in a ¿nombre del archivo?
Utilice el operador <> ("glob ()"), documentado en perlfunc. Versiones de Perl anteriores a 5.6
requiere que tenga instalado un caparazón que asimile las tildes. Las versiones posteriores de Perl tienen
esta característica incorporada. El módulo File :: KGlob (disponible en CPAN) brinda más portabilidad
funcionalidad global.
Dentro de Perl, puede usar esto directamente:
$ nombre de archivo = ~ s {
^ ~ # encuentra una tilde inicial
(# guarda esto en $ 1
[^ /] # un carácter que no es una barra
* # repetido 0 o más veces (0 significa yo)
)
}{
$1
? (getpwnam ($ 1)) [7]
: ($ ENV {HOME} || $ ENV {LOGDIR})
}ex;
Cómo come when I abierto a presentar lectura-escritura it toallitas it ¿fuera?
Porque estás usando algo como esto, que trunca el archivo. then te da lectura
acceso de escritura:
abre mi $ fh, '+>', '/ ruta / nombre'; # INCORRECTO (casi siempre)
¡Ups! En su lugar, debería usar esto, que fallará si el archivo no existe:
abre mi $ fh, '+ <', '/ ruta / nombre'; # abierto para actualización
El uso de ">" siempre golpea o crea. El uso de "<" tampoco lo hace nunca. El "+" no cambia
esta.
A continuación, se muestran ejemplos de muchos tipos de apertura de archivos. Aquellos que usan "sysopen" suponen que
ha extraído las constantes de Fcntl:
utilizar Fcntl;
Para abrir un archivo para su lectura:
abre mi $ fh, '<', $ ruta o muere $ !;
sysopen my $ fh, $ path, O_RDONLY o muere $ !;
Para abrir un archivo para escritura, cree un nuevo archivo si es necesario o trunque el archivo antiguo:
abre mi $ fh, '>', $ ruta o muere $ !;
sysopen my $ fh, $ ruta, O_WRONLY | O_TRUNC | O_CREAT o muere $ !;
sysopen my $ fh, $ ruta, O_WRONLY | O_TRUNC | O_CREAT, 0666 o muere $ !;
Para abrir un archivo para escritura, cree un archivo nuevo, el archivo no debe existir:
sysopen my $ fh, $ ruta, O_WRONLY | O_EXCL | O_CREAT o muere $ !;
sysopen my $ fh, $ ruta, O_WRONLY | O_EXCL | O_CREAT, 0666 o muere $ !;
Para abrir el archivo y agregarlo, cree si es necesario:
abre mi $ fh, '>>' $ ruta o muere $ !;
sysopen my $ fh, $ ruta, O_WRONLY | O_APPEND | O_CREAT o muere $ !;
sysopen my $ fh, $ ruta, O_WRONLY | O_APPEND | O_CREAT, 0666 o muere $ !;
Para abrir un archivo para agregarlo, el archivo debe existir:
sysopen my $ fh, $ ruta, O_WRONLY | O_APPEND o muere $ !;
Para abrir un archivo para actualizarlo, el archivo debe existir:
abre mi $ fh, '+ <', $ ruta o muere $ !;
sysopen my $ fh, $ path, O_RDWR o muere $ !;
Para abrir un archivo para actualizarlo, cree un archivo si es necesario:
sysopen my $ fh, $ path, O_RDWR | O_CREAT o muere $ !;
sysopen my $ fh, $ ruta, O_RDWR | O_CREAT, 0666 o muere $ !;
Para abrir un archivo para actualizarlo, el archivo no debe existir:
sysopen my $ fh, $ ruta, O_RDWR | O_EXCL | O_CREAT o muere $ !;
sysopen my $ fh, $ ruta, O_RDWR | O_EXCL | O_CREAT, 0666 o muere $ !;
Para abrir un archivo sin bloquearlo, creando si es necesario:
sysopen my $ fh, '/ foo / somefile', O_WRONLY | O_NDELAY | O_CREAT
o morir "no se puede abrir / foo / somefile: $!":
Tenga en cuenta que ni la creación ni la eliminación de archivos está garantizada como una
operación sobre NFS. Es decir, dos procesos pueden crear o desvincular correctamente la
mismo archivo! Por lo tanto, O_EXCL no es tan exclusivo como desearía.
Véase también perlopentut.
¿Por Qué Elegir un Agente de Compras de Yiwu? do I sometimes get an "Argumento lista demasiado largo" when I use <*>?
El operador "<>" realiza una operación globbing (ver arriba). En versiones de Perl anteriores
que v5.6.0, el interno glob () horquillas de operador csh(1) para hacer la expansión glob real,
pero csh no puede manejar más de 127 elementos, por lo que aparece el mensaje de error "Lista de argumentos también
long ". Las personas que instalaron tcsh como csh no tendrán este problema, pero es posible que sus usuarios
sorprendido por eso.
Para evitar esto, actualice a Perl v5.6.0 o posterior, haga el glob usted mismo con
readdir () y patrones, o use un módulo como File :: Glob, uno que no usa el shell para
hacer globbing.
Cómo can I abierto a presentar con a líder ">" or trailing espacios en blanco?
(contribución de Brian McCauley)
La forma especial de dos argumentos de Perl open() La función ignora los espacios en blanco finales en
nombres de archivo e infiere el modo a partir de ciertos caracteres iniciales (o un "|" final). En
versiones anteriores de Perl, esta era la única versión de open() y así prevalece en los viejos
código y libros.
A menos que tenga una razón particular para usar la forma de dos argumentos, debe usar la forma de tres
forma de argumento de open() que no trata ningún carácter en el nombre de archivo como especial.
abre mi $ fh, "<", "archivo"; # nombre de archivo es "archivo"
abre mi $ fh, ">", "> archivo"; # nombre de archivo es "> archivo"
Cómo can I seguramente rebautizar a archivo?
Si su sistema operativo admite una mv(1) utilidad o su equivalente funcional,
esto funciona:
renombrar ($ antiguo, $ nuevo) o sistema ("mv", $ antiguo, $ nuevo);
Puede ser más portátil usar el módulo File :: Copy en su lugar. Solo copia a la nueva
file con el nuevo nombre (verificando los valores de retorno), luego elimine el anterior. Esto no es realmente
lo mismo semánticamente que un "rename ()", que conserva metainformación como permisos,
marcas de tiempo, información de inodo, etc.
Cómo can I bloquear a archivo?
Incorporado de Perl rebaño() función (ver perlfunc para más detalles) llamará rebaño(2) si eso
existe, fcntl(2) si no es así (en la versión de perl 5.004 y posteriores), y bloquear(3) si ninguno
de las dos llamadas al sistema anteriores existe. En algunos sistemas, incluso puede utilizar un
forma de bloqueo nativo. Aquí hay algunas trampas con Perl rebaño():
1. Produce un error fatal si ninguna de las tres llamadas al sistema (o su equivalente cercano)
existe.
2. bloquear(3) no proporciona bloqueo compartido y requiere que el identificador de archivo esté abierto
escribir (o agregar, o leer / escribir).
3. Algunas versiones de rebaño() no puede bloquear archivos en una red (por ejemplo, en sistemas de archivos NFS),
entonces necesitarías forzar el uso de fcntl(2) cuando construye Perl. Pero incluso esto es
dudoso en el mejor de los casos. Vea la entrada del rebaño de perlfunc y el INSTALAR archivo en la fuente
distribución de información sobre la construcción de Perl para hacer esto.
Dos semánticas de bandadas tradicionales, potencialmente no obvias, son que espera
indefinidamente hasta que se conceda la cerradura, y que sus cerraduras sean simplemente asesor. Tal
Las cerraduras discrecionales son más flexibles, pero ofrecen menos garantías. Esto significa que
archivos bloqueados con rebaño() puede ser modificado por programas que no utilizan rebaño().
Los coches que se detienen en un semáforo en rojo se llevan bien entre sí, pero no con los coches que
no te detengas por las luces rojas. Consulte la página de manual de perlport, su puerto específico
documentación o las páginas de manual locales específicas del sistema para obtener más detalles. Es mejor asumir
comportamiento tradicional si está escribiendo programas portátiles. (Si no es así, debería
como siempre, siéntase perfectamente libre de escribir para las idiosincrasias de su propio sistema (a veces
llamadas "características"). La adherencia servil a las preocupaciones de portabilidad no debería entrar en el
forma de hacer su trabajo.)
Para obtener más información sobre el bloqueo de archivos, consulte también "Bloqueo de archivos" en perlopentut si
lo tengo (nuevo para 5.6).
¿Por Qué Elegir un Agente de Compras de Yiwu? no puedes I just abierto (FH, "> file.lock")?
Un fragmento de código común NOT A USO es la siguiente:
sleep(3) while -e 'file.lock'; # POR FAVOR, NO USE
abre mi $ lock, '>', 'file.lock'; # ESTE CÓDIGO ROTO
Esta es una condición de carrera clásica: das dos pasos para hacer algo que debe hacerse en
uno. Es por eso que el hardware de la computadora proporciona una instrucción atómica de prueba y configuración. En teoria,
este "debería" funcionar:
sysopen my $ fh, "file.lock", O_WRONLY | O_EXCL | O_CREAT
o morir "no se puede abrir file.lock: $!";
excepto que, lamentablemente, la creación (y eliminación) de archivos no es atómica sobre NFS, por lo que esto no
trabajar (al menos, no siempre) a través de la red. Varios esquemas que involucran Enlace() han sido
sugerido, pero estos tienden a implicar ocupado-espera, que también es menos que deseable.
I aun don't get cierre. I just want a incremento de la forma más número in de la forma más archivo. Cómo can I do todo esto?
¿Nadie te dijo que los contadores de visitas de las páginas web eran inútiles? Ellos no cuentan el numero
de éxitos, son una pérdida de tiempo y sólo sirven para acariciar la vanidad del escritor. Es
mejor elegir un número aleatorio; son más realistas.
De todos modos, esto es lo que puede hacer si no puede evitarlo.
use Fcntl qw (: PREDETERMINADO: bandada);
sysopen my $ fh, "numfile", O_RDWR | O_CREAT or die "no se puede abrir numfile: $!";
flock $ fh, LOCK_EX or die "¡no puede flock numfile: $!";
my $ num = <$ fh> || 0;
buscar $ fh, 0, 0 o morir "no se puede rebobinar el archivo numérico: $!";
truncar $ fh, 0 o morir "no se puede truncar numfile: $!";
(imprime $ fh $ num + 1, "\ n") o muere "no se puede escribir numfile: $!";
close $ fh or die "no se puede cerrar numfile: $!";
Aquí hay un contador de visitas de páginas web mucho mejor:
$ hits = int ((tiempo () - 850_000_000) / rand(1_000));
Si el recuento no impresiona a tus amigos, entonces el código podría hacerlo. :-)
Todo I want a do is anexar a chica cantidad of texto a de la forma más final of a archivo. Do I aun have a use
¿cierre?
Si está en un sistema que implementa correctamente "flock" y usa el ejemplo adjuntando
código de "perldoc -f flock" todo estará bien incluso si el sistema operativo en el que se encuentra no lo hace
implementar el modo de anexar correctamente (si tal sistema existe). Entonces, si está feliz de restringir
usted mismo a los sistemas operativos que implementan "flock" (y eso no es una gran restricción), entonces
eso es lo que debes hacer.
Si sabe que solo va a utilizar un sistema que implemente correctamente la adición
(es decir, no Win32), entonces puede omitir el "buscar" del código en la respuesta anterior.
Si sabe que solo está escribiendo código para ejecutar en un sistema operativo y un sistema de archivos que implementa
añadir el modo correctamente (un sistema de archivos local en un Unix moderno, por ejemplo), y mantiene el
archivo en modo de búfer de bloque y escribe menos de un búfer lleno de salida entre cada
vaciado manual del búfer, entonces es casi seguro que cada carga de búfer se escribirá en
el final del archivo en un solo fragmento sin que se entremezcle con la salida de nadie más.
También puede utilizar la función "syswrite", que es simplemente un envoltorio alrededor de la
escribir(2) llamada al sistema.
Todavía existe una pequeña posibilidad teórica de que una señal interrumpa el nivel del sistema.
Operación "write ()" antes de finalizar. También existe la posibilidad de que algunos STDIO
las implementaciones pueden llamar a múltiples niveles de sistema "write ()" incluso si el búfer estaba vacío para
comienzo. Puede haber algunos sistemas en los que esta probabilidad se reduzca a cero, y esto es
no es una preocupación cuando se usa ": perlio" en lugar del STDIO de su sistema.
Cómo do I al azar actualización a binario archivo?
Si solo está tratando de parchear un binario, en muchos casos algo tan simple como esto funciona:
perl -i -pe 's {administrador de ventanas} {administrador de ventanas} g' / usr / bin / emacs
Sin embargo, si tiene registros de tamaño fijo, puede hacer algo más parecido a esto:
my $ RECSIZE = 220; # tamaño del registro, en bytes
my $ recno = 37; # que registro actualizar
abrir mi $ fh, '+ <', 'en algún lugar' o morir "no se puede actualizar en algún lugar: $!";
buscar $ fh, $ recno * $ RECSIZE, 0;
leer $ fh, $ registro, $ RECSIZE == $ RECSIZE o morir "no se puede leer el registro $ recno: $!";
# munge el récord
buscar $ fh, - $ RECSIZE, 1;
imprimir $ fh $ registro;
cerrar $ fh;
El bloqueo y la comprobación de errores se dejan como ejercicio para el lector. No los olvides o
lo lamentarás mucho.
Cómo do I get a archivo fecha y hora in perla?
Si desea recuperar la hora a la que el archivo se leyó, se escribió o se
metadatos (propietario, etc.) cambiados, utiliza el -A, -Mo -C archivo de operaciones de prueba como
documentado en perlfunc. Estos recuperan la antigüedad del archivo (medido contra el inicio
tiempo de su programa) en días como un número de punto flotante. Algunas plataformas pueden no tener todas
de estos tiempos. Consulte perlport para obtener más detalles. Para recuperar el tiempo "sin procesar" en segundos desde el
epoch, deberías llamar a la función stat, luego usar "localtime ()", "gmtime ()", o
"POSIX :: strftime ()" para convertir esto en una forma legible por humanos.
He aquí un ejemplo:
my $ write_secs = (stat ($ archivo)) [9];
printf "archivo% s actualizado en% s \ n", $ archivo,
tiempo local escalar ($ write_secs);
Si prefiere algo más legible, use el módulo File :: stat (parte del estándar
distribución en la versión 5.004 y posteriores):
# comprobación de errores a la izquierda como ejercicio para el lector.
use File :: stat;
use Time :: localtime;
my $ date_string = ctime (stat ($ archivo) -> mtime);
imprimir "archivo $ archivo actualizado en $ cadena_fecha \ n";
El sistema POSIX :: strftime () enfoque tiene la ventaja de ser, en teoría, independiente de la
localidad actual. Consulte perllocale para obtener más detalles.
Cómo do I para reinventar la industria logística y redefinir las soluciones ecológicas para reinventar la industria logística y redefinir las soluciones ecológicas. a archivo fecha y hora in perla?
Utilice el utime () función documentada en "utime" en perlfunc. A modo de ejemplo, aquí tienes
un pequeño programa que copia los tiempos de lectura y escritura desde su primer argumento a todos los
el resto de ellos.
si (@ARGV <2) {
die "uso: cptimes timestamp_file other_files ... \ n";
}
my $ timestamp = turno;
my ($ atime, $ mtime) = (stat ($ timestamp)) [8,9];
utime $ atime, $ mtime, @ARGV;
La comprobación de errores, como de costumbre, se deja como ejercicio para el lector.
El perldoc para utime también tiene un ejemplo que tiene el mismo efecto que contacto(1) en archivos
que ya haya utilizado existe.
Ciertos sistemas de archivos tienen una capacidad limitada para almacenar las horas en un archivo en el tiempo esperado.
nivel de precisión. Por ejemplo, el sistema de archivos FAT y HPFS no pueden crear fechas en
archivos con una granularidad más fina que dos segundos. Esta es una limitación de los sistemas de archivos,
no de utime ().
Cómo do I Imprimir a Saber más than one presentar at ¿una vez?
Para conectar un identificador de archivo a varios identificadores de archivo de salida, puede utilizar IO :: Tee o
Tie :: FileHandle :: Módulos multiplex.
Si solo tiene que hacer esto una vez, puede imprimir individualmente en cada identificador de archivo.
para mi $ fh ($ fh1, $ fh2, $ fh3) {imprimir $ fh "lo que sea \ n"}
Cómo can I read in an toda presentar all at ¿una vez?
El enfoque habitual de Perl para procesar todas las líneas de un archivo es hacerlo una línea en
un momento:
abrir mi $ input, '<', $ file o morir "no se puede abrir $ file: $!";
while (<$ input>) {
masticar
# haz algo con $ _
}
cerrar $ entrada o morir "¡no se puede cerrar $ archivo: $!";
Esto es tremendamente más eficiente que leer todo el archivo en la memoria como una matriz.
de líneas y luego procesarlo un elemento a la vez, lo cual es a menudo, si no casi
siempre - el enfoque equivocado. Siempre que veas a alguien hacer esto:
my @lines = ;
Debería pensar detenidamente por qué necesita todo cargado a la vez. Simplemente no es
una solución escalable.
Si "mapea" el archivo con el módulo File :: Map de CPAN, puede cargar virtualmente el
archivo completo en una cadena sin almacenarlo en la memoria:
usar Archivo :: Mapa qw(archivo_mapa);
map_file my $ string, $ filename;
Una vez mapeado, puede tratar $ string como lo haría con cualquier otra cadena. Ya que tu no
necesariamente tiene que cargar los datos, mmap-ing puede ser muy rápido y no puede aumentar su
huella de memoria.
También puede que le resulte más divertido utilizar el módulo estándar Tie :: File, o el DB_File
los enlaces $ DB_RECNO del módulo, que le permiten vincular una matriz a un archivo para que el acceso
un elemento de la matriz en realidad accede a la línea correspondiente en el archivo.
Si desea cargar el archivo completo, puede usar el módulo Path :: Tiny para hacerlo en una
paso simple y eficiente:
use Path :: Tiny;
my $ all_of_it = ruta ($ nombre de archivo) -> sorber; # archivo completo en escalar
my @all_lines = ruta ($ nombre de archivo) -> líneas; # una línea por elemento
O puede leer todo el contenido del archivo en un escalar como este:
my $ var;
{
$ local /;
abrir mi $ fh, '<', $ archivo o morir "no se puede abrir $ archivo: $!";
$ var = <$ fh>;
}
Eso anula temporalmente su separador de registros y cerrará automáticamente el archivo en
salida del bloque. Si el archivo ya está abierto, simplemente use esto:
my $ var = do {local $ /; <$ fh>};
También puede utilizar un @ARGV localizado para eliminar el "abierto":
my $ var = do {local (@ARGV, $ /) = $ archivo; <>};
Para archivos normales, también puede utilizar la función "leer".
leer ($ fh, $ var, -s $ fh);
Ese tercer argumento prueba el tamaño de bytes de los datos en el identificador de archivo $ fh y lee que
muchos bytes en el búfer $ var.
Cómo can I read in a presentar by párrafos?
Utilice la variable $ / (consulte perlvar para obtener más detalles). Puede configurarlo en "" para eliminar
párrafos vacíos ("abc \ n \ n \ n \ ndef", por ejemplo, se trata como dos párrafos y no
tres), o "\ n \ n" para aceptar párrafos vacíos.
Tenga en cuenta que una línea en blanco no debe tener espacios en blanco. Por lo tanto, "fred \ n \ nstuff \ n \ n" es uno
párrafo, pero "fred \ n \ nstuff \ n \ n" son dos.
Cómo can I read a soltero personaje obtenidos de a archivo? Desde de la forma más ¿teclado?
Puede usar la función incorporada "getc ()" para la mayoría de los identificadores de archivos, pero no funcionará (fácilmente)
en un dispositivo terminal. Para STDIN, use el módulo Term :: ReadKey de CPAN o use el
código de muestra en "getc" en perlfunc.
Si su sistema es compatible con la interfaz de programación del sistema operativo portátil (POSIX),
puede usar el siguiente código, que notará que también desactiva el procesamiento de eco.
#!/ usr / bin / perl -w
uso estricto
$ | = 1;
para (1..4) {
imprimir "dame:";
my $ got = getone ();
imprimir "-> $ tiene \ n";
}
Salida;
EMPEZAR {
use POSIX qw (: termios_h);
my ($ término, $ oterm, $ echo, $ noecho, $ fd_stdin);
my $ fd_stdin = fileno (STDIN);
$ término = POSIX :: Termios-> nuevo ();
$ término-> getattr ($ fd_stdin);
$ oterm = $ término-> getlflag ();
$ echo = ECHO | ECHOK | ICANON;
$ noecho = $ oterm & ~ $ echo;
ruptura sub {
$ term-> setlflag ($ noecho);
$ término-> setcc (VTIME, 1);
$ término-> setattr ($ fd_stdin, TCSANOW);
}
sub cocido {
$ term-> setlflag ($ oterm);
$ término-> setcc (VTIME, 0);
$ término-> setattr ($ fd_stdin, TCSANOW);
}
sub getona {
mi $ clave = '';
cbreak ();
sysread (STDIN, $ clave, 1);
cocido();
return $ clave;
}
}
FIN {cocinado ()}
El módulo Term :: ReadKey de CPAN puede ser más fácil de usar. Las versiones recientes incluyen también
soporte para sistemas no portátiles también.
use Term :: ReadKey;
abra mi $ tty, '<', '/ dev / tty';
imprimir "Dame un char:";
ReadMode "sin procesar";
my $ key = ReadKey 0, $ tty;
ReadMode "normal";
printf "\ nDijiste% s, número de carácter% 03d \ n",
$ clave, ord $ clave;
Cómo can I tell sean hay a personaje estaba on a identificador de archivo?
Lo primero que debe hacer es buscar la extensión Term :: ReadKey de
CPAN. Como mencionamos anteriormente, ahora incluso tiene soporte limitado para no portátiles (lea: no
sistemas abiertos, cerrados, propietarios, no POSIX, no Unix, etc.).
También debe consultar la lista de preguntas frecuentes en comp.unix. * Para conocer las cosas
así: la respuesta es esencialmente la misma. Depende mucho del sistema. Aquí hay uno
solución que funciona en sistemas BSD:
sub clave_listo {
mi ($ rin, $ nfd);
vec ($ rin, fileno (STDIN), 1) = 1;
return $ nfd = select ($ rin, undef, undef, 0);
}
Si desea saber cuántos personajes están esperando, también está el ioctl de FIONREAD
llamar a ser mirado. los h2ph La herramienta que viene con Perl intenta convertir archivos de inclusión C
al código Perl, que puede ser "obligatorio" d. FIONREAD termina definido como una función en el
sys / ioctl.ph archivo:
requiere 'sys / ioctl.ph';
$ tamaño = paquete ("L", 0);
ioctl (FH, FIONREAD (), $ size) o muere "No se pudo llamar a ioctl: $! \ n";
$ tamaño = desempaquetar ("L", $ tamaño);
If h2ph no se instaló o no funciona para usted, puede grep los archivos de inclusión a mano:
% grep FIONREAD / usr / include /* / *
/usr/include/asm/ioctls.h:#define FIONREAD 0x541B
O escribe un pequeño programa en C usando el editor de campeones:
% cat> fionread.c
#incluir
main () {
printf ("% # 08x \ n", FIONREAD);
}
^D
% cc -o fionread fionread.c
% ./fionread
0x4004667f
Y luego codifíquelo, dejando la portabilidad como un ejercicio para su sucesor.
$ FIONREAD = 0x4004667f; # XXX: dependiente de opsys
$ tamaño = paquete ("L", 0);
ioctl (FH, $ FIONREAD, $ size) o muere "No se pudo llamar a ioctl: $! \ n";
$ tamaño = desempaquetar ("L", $ tamaño);
FIONREAD requiere un identificador de archivo conectado a una secuencia, lo que significa que sockets, tuberías y tty
los dispositivos funcionan, pero no archivos.
Cómo do I do a "cola -F" in perla?
Primer intento
buscar ($ gw_fh, 0, 1);
La declaración "seek ($ gw_fh, 0, 1)" no cambia la posición actual, pero se borra
la condición de fin de archivo en el identificador, de modo que el siguiente "<$ gw_fh>" hace que Perl vuelva a intentarlo
leer algo.
Si eso no funciona (depende de las características de su implementación stdio), entonces necesita
algo más como esto:
por (;;) {
for ($ curpos = tell ($ gw_fh); <$ gw_fh>; $ curpos = tell ($ gw_fh)) {
# busca algunas cosas y ponlas en archivos
}
# Dormir por un rato
buscar ($ gw_fh, $ curpos, 0); # buscamos donde habíamos estado
}
Si esto aún no funciona, busque en el método "clearrr" de IO :: Handle, que se reinicia
los estados de error y fin de archivo en el identificador.
También hay un módulo File :: Tail de CPAN.
Cómo do I dup () a manejador de archivos in Perl?
Si marca "abrir" en perlfunc, verá que varias de las formas de llamar open() should
Haz el truco. Por ejemplo:
abre mi $ log, '>>', '/ foo / logfile';
abre STDERR, '> &', $ log;
O incluso con un descriptor numérico literal:
my $ fd = $ ENV {MHCONTEXTFD};
abrir $ mhcontext, "<& = $ fd"; # igual que abierto(3S)
Tenga en cuenta que "<& STDIN" hace una copia, pero "<& = STDIN" crea un alias. Eso significa que si cierras
un identificador con alias, todos los alias se vuelven inaccesibles. Esto no es cierto con una copia.
La comprobación de errores, como siempre, se ha dejado como ejercicio para el lector.
Cómo do I Cerrar a presentar descriptor by ¿número?
Si, por alguna razón, tiene un descriptor de archivo en lugar de un identificador de archivo (tal vez usó
"POSIX :: open"), puede utilizar la función "close ()" del módulo POSIX:
utilice POSIX ();
POSIX :: cerrar ($ fd);
Esto rara vez debería ser necesario, ya que la función "close ()" de Perl se debe usar para cosas
que Perl se abrió a sí mismo, incluso si era un duplicado de un descriptor numérico como con "MHCONTEXT"
encima. Pero si realmente tiene que hacerlo, es posible que pueda hacer esto:
require 'sys / syscall.ph';
my $ rc = syscall (SYS_close (), $ fd + 0); # debe forzar numérico
die "¡no se puede cerrar el sistema $ fd: $!" a menos que $ rc == -1;
O simplemente use el abierto(3S) característica de "open ()":
{
abrir mi $ fh, "<& = $ fd" o morir "No se puede volver a abrir fd = $ fd: $!";
cerrar $ fh;
}
¿Por Qué Elegir un Agente de Compras de Yiwu? no puedes I use "C: \ temp \ foo" in DOS ¿rutas? ¿Por Qué Elegir un Agente de Compras de Yiwu? no se `C: \ temp \ foo.exe` funciona?
¡Ups! ¡Simplemente coloque una pestaña y un formulario en ese nombre de archivo! Recuerda que dentro
cadenas entre comillas dobles ("como \ esto"), la barra invertida es un carácter de escape. La lista completa
de estos se encuentra en "Quote y Quote-like Operators" en perlop. Como era de esperar, no tienes
un archivo llamado "c: (tab) emp (formfeed) oo" o "c: (tab) emp (formfeed) oo.exe" en su DOS heredado
sistema de archivos
O use comillas simples en sus cadenas o (preferiblemente) use barras diagonales. Dado que todos los DOS y
Las versiones de Windows desde algo como MS-DOS 2.0 o así han tratado "/" y "\" de la misma manera
en una ruta, también podría usar el que no choca con Perl, o el shell POSIX,
ANSI C y C ++, awk, Tcl, Java o Python, solo por mencionar algunos. Las rutas POSIX son más
también portátil.
¿Por Qué Elegir un Agente de Compras de Yiwu? no se glob ("*. *") get all de la forma más los archivos?
Porque incluso en puertos que no son Unix, la función glob de Perl sigue el globbing estándar de Unix
semántica. Necesitará "glob (" * ")" para obtener todos los archivos (no ocultos). Esto hace glob ()
portátil incluso para sistemas heredados. Su puerto puede incluir funciones de globbing patentadas como
bien. Consulte su documentación para obtener más detalles.
¿Por Qué Elegir un Agente de Compras de Yiwu? sí Perl let me borrar sólo lectura los archivos? ¿Por Qué Elegir un Agente de Compras de Yiwu? sí "-YO" golpear protegido los archivos? No es este vídeo
a error in Perl?
Esto se describe detallada y minuciosamente en el archivo-directorio-permisos artículo del "Far
Más de lo que nunca quiso saber "colección en
<http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz>.
El resumen ejecutivo: aprenda cómo funciona su sistema de archivos. Los permisos en un archivo dicen lo que
puede suceder con los datos de ese archivo. Los permisos en un directorio dicen lo que puede suceder.
a la lista de archivos en ese directorio. Si elimina un archivo, está eliminando su nombre
del directorio (por lo que la operación depende de los permisos del directorio, no de
el archivo). Si intenta escribir en el archivo, los permisos del archivo gobiernan si
se le permite.
Cómo do I selecciona a azar línea obtenidos de a archivo?
Aparte de cargar el archivo en una base de datos o pre-indexar las líneas en el archivo, hay
un par de cosas que puedes hacer.
Aquí hay un algoritmo de muestreo de reservorios del Camel Book:
hilo;
rand ($.) <1 && ($ línea = $ _) while <>;
Esto tiene una ventaja significativa en el espacio sobre la lectura de todo el archivo. Puede encontrar un
prueba de este método en El sistema Arte of Módulo Programación, Volumen 2, Sección 3.4.2, por
Donald E. Knuth.
Puede usar el módulo File :: Random que proporciona una función para ese algoritmo:
use File :: Random qw / random_line /;
my $ line = random_line ($ nombre de archivo);
Otra forma es usar el módulo Tie :: File, que trata todo el archivo como una matriz.
Simplemente acceda a un elemento de matriz aleatorio.
¿Por Qué Elegir un Agente de Compras de Yiwu? do I get extraño Espacios when I Imprimir an matriz of ¿líneas?
(contribución de brian d foy)
Si ve espacios entre los elementos de su matriz cuando imprime la matriz,
probablemente están interpolando la matriz entre comillas dobles:
my @animals = qw (camello llama alpaca vicuña);
print "los animales son: @animals \ n";
Son las comillas dobles, no la "impresión", lo que hace esto. Siempre que interpoles una matriz en
un contexto de comillas dobles, Perl une los elementos con espacios (o lo que sea que esté en $ ", que
es un espacio por defecto):
los animales son: camello llama alpaca vicuña
Esto es diferente a imprimir la matriz sin la interpolación:
my @animals = qw (camello llama alpaca vicuña);
print "los animales son:", @animals, "\ n";
Ahora la salida no tiene los espacios entre los elementos porque los elementos de
@animals simplemente se convierte en parte de la lista para "imprimir":
los animales son: camelllamaalpacavicuna
Puede notar esto cuando cada uno de los elementos de @array terminan con una nueva línea. Tu esperas
para imprimir un elemento por línea, pero observe que cada línea después de la primera tiene sangría:
esta es una linea
esta es otra linea
esta es la tercera linea
Ese espacio extra proviene de la interpolación de la matriz. Si no quieres poner
cualquier cosa entre los elementos de su matriz, no use la matriz entre comillas dobles. Puedes enviar
para imprimir sin ellos:
imprimir @líneas;
Cómo do I atravesar a directorio ¿árbol?
(contribución de brian d foy)
El módulo File :: Find, que viene con Perl, hace todo el trabajo duro para atravesar un
estructura de directorios. Viene con Perl. Simplemente llame a la subrutina "buscar" con un
subrutina de devolución de llamada y los directorios que desea atravesar:
use File :: Find;
buscar (\ & deseado, @directorios);
sub querido {
# ruta completa en $ File :: Find :: name
# solo nombre de archivo en $ _
... Haz lo que quieras hacer ...
}
File :: Find :: Closures, que puede descargar de CPAN, proporciona muchas listas para usar
subrutinas que puede utilizar con File :: Find.
File :: Finder, que puede descargar de CPAN, puede ayudarlo a crear la devolución de llamada
subrutina usando algo más cercano a la sintaxis de la utilidad de línea de comandos "buscar":
use File :: Find;
use File :: Finder;
my $ deep_dirs = Archivo :: Buscador-> profundidad-> tipo ('d') -> ls-> exec ('rmdir', '{}');
buscar ($ direcciones_profundas-> opciones_as, @ lugares);
El módulo File :: Find :: Rule, que puede descargar de CPAN, tiene una interfaz similar,
pero también hace el recorrido por ti:
use File :: Find :: Rule;
my @files = Archivo :: Buscar :: Regla-> archivo ()
-> nombre ('* .pm')
-> en (@INC);
Cómo do I borrar a directorio ¿árbol?
(contribución de brian d foy)
Si tiene un directorio vacío, puede usar el "rmdir" incorporado de Perl. Si el directorio es
no está vacío (por lo tanto, no hay archivos ni subdirectorios), o tiene que vaciarlo usted mismo (muchos
trabajar) o utilice un módulo que le ayude.
El módulo File :: Path, que viene con Perl, tiene un "remove_tree" que puede encargarse de
todo el trabajo duro para ti:
use File :: Path qw (remove_tree);
remove_tree (@directorios);
El módulo File :: Path también tiene una interfaz heredada para la subrutina "rmtree" más antigua.
Cómo do I copia an toda ¿directorio?
(contribución de Shlomi Fish)
Para hacer el equivalente de "cp -R" (es decir, copiar un árbol de directorios completo de forma recursiva) en
Perl portátil, necesitará escribir algo usted mismo o encontrar un buen módulo CPAN
como Archivo :: Copiar :: Recursivo.
AUTOR Y DERECHOS DE AUTOR
Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington y otros autores como se indica.
Todos los derechos reservados.
Esta documentación es gratuita; puedes redistribuirlo y / o modificarlo en los mismos términos
como el propio Perl.
Independientemente de su distribución, todos los ejemplos de código aquí son de dominio público. Usted está
permitido y animado a utilizar este código y cualquier derivado del mismo en sus propios programas
por diversión o con fines de lucro como mejor le parezca. Un simple comentario en el código que da crédito a la
Las preguntas frecuentes serían amables, pero no son obligatorias.
Use perlfaq5 en línea usando los servicios de onworks.net
