Ruby Entrada y salida de archivos

Ruby proporciona un conjunto completo de métodos relacionados con E/S, implementados en el módulo Kernel. Todos los métodos de E/S derivan de la clase IO.

ClaseIOProporciona todos los métodos básicos, comoread, write, gets, puts, readline, getcyprintf。

Este capítulo explicará todas las funciones básicas de E/S disponibles en Ruby. Para conocer más funciones, consulte laIOclase.

putsSentencia

En los capítulos anteriores, usted asignaba valores a variables y luego usaba laputssentencia para imprimir la salida.

putsLa sentencia puts indica al programa que muestre el valor almacenado en la variable. Esto añadirá una nueva línea al final de cada línea.

Ejemplo

#!/usr/bin/ruby val1 = "This is variable one" val2 = "This is variable two" puts val1 puts val2

El resultado de ejecutar el ejemplo anterior es:

This is variable one
This is variable two

getsSentencia

getsLa sentencia gets se puede utilizar para obtener la entrada del usuario desde la pantalla estándar llamada STDIN.

Ejemplo

El siguiente código demuestra cómo usar la sentencia gets. Este código solicitará al usuario que ingrese un valor, que se almacenará en la variable val y finalmente se imprimirá en STDOUT.

Ejemplo

#!/usr/bin/ruby puts "Enter a value :" val = gets puts val

El resultado de ejecutar el ejemplo anterior es:

Enter a value :
This is entered value
This is entered value

putcSentencia

yputsA diferencia de la sentencia puts,putsla sentencia imprime la cadena completa en la pantalla, mientras que laputcsentencia se puede usar para imprimir un carácter a la vez.

Ejemplo

La salida del siguiente código es solo el carácter H:

Ejemplo

#!/usr/bin/ruby str="Hello Ruby!" putc str

El resultado de ejecutar el ejemplo anterior es:

H

printSentencia

printLa sentencia es similar a laputssentencia. La única diferencia es que laputssentencia salta a la siguiente línea después de generar el contenido, mientras que al usar laprintsentencia, el cursor permanece en la misma línea.

Ejemplo

#!/usr/bin/ruby print "Hello World" print "Good Morning"

El resultado de ejecutar el ejemplo anterior es:

Hello WorldGood Morning

Abrir y cerrar archivos

Hasta ahora, ha leído y escrito en la entrada y salida estándar. Ahora, veremos cómo manipular archivos de datos reales.

File.newMétodo

Puede utilizar el métodoFile.newpara crear unFileobjeto para lectura, escritura o lectura y escritura. Los permisos de lectura y escritura dependen del parámetro mode. Finalmente, puede utilizar el métodoFile.closepara cerrar el archivo.

Sintaxis

aFile = File.new("filename", "mode") #... procesar el archivo aFile.close

File.openMétodo

Puede utilizar el métodoFile.openpara crear un nuevo objeto file y asignar dicho objeto file al archivo. Sin embargo,File.openyFile.newhay una pequeña diferencia entre los métodos. La diferencia es que el métodoFile.openpuede asociarse a un bloque, mientras que el métodoFile.newno puede.

File.open("filename", "mode") do |aFile| # ... process the file end

La siguiente tabla enumera los diferentes modos para abrir un archivo:

ModoDescripción
rModo de solo lectura. El puntero del archivo se coloca al principio del archivo. Este es el modo predeterminado.
r+Modo de lectura y escritura. El puntero del archivo se coloca al principio del archivo.
wModo de solo escritura. Si el archivo existe, se sobrescribe el archivo. Si el archivo no existe, se crea un nuevo archivo para escritura.
w+Modo de lectura y escritura. Si el archivo existe, se sobrescribe el archivo existente. Si el archivo no existe, se crea un nuevo archivo para lectura y escritura.
aModo de solo escritura. Si el archivo existe, el puntero del archivo se coloca al final del archivo. Es decir, el archivo está en modo de agregar (append). Si el archivo no existe, se crea un nuevo archivo para escritura.
a+Modo de lectura y escritura. Si el archivo existe, el puntero del archivo se coloca al final del archivo. Es decir, el archivo está en modo de agregar (append). Si el archivo no existe, se crea un nuevo archivo para lectura y escritura.

Leer y escribir archivos

Los métodos utilizados para E/S simple también se pueden utilizar en todos los objetos file. Así, gets lee una línea desde la entrada estándar, yaFile.getsaFile lee una línea desde el objeto de archivo aFile.

Sin embargo, los objetos I/O proporcionan configuraciones adicionales de métodos de acceso, lo que nos brinda comodidad.

sysreadMétodo

Puede utilizar el métodosysreadpara leer el contenido del archivo. Cuando utilice el método sysread, puede abrir el archivo en cualquiera de los modos. Por ejemplo:

El siguiente es el archivo de texto de entrada:

This is a simple text file for testing purpose.

Ahora intentemos leer este archivo:

Ejemplo

#!/usr/bin/ruby aFile = File.new("input.txt", "r") if aFile content = aFile.sysread(20) puts content else puts "Unable to open file!" end

Esta sentencia leerá los primeros 20 caracteres del archivo de entrada. El puntero del archivo se colocará en la posición del vigésimo primer carácter del archivo.

syswriteMétodo

Puede utilizar el métodosyswritepara escribir contenido en el archivo. Cuando utilice el método syswrite, debe abrir el archivo en modo escritura. Por ejemplo:

Ejemplo

#!/usr/bin/ruby aFile = File.new("input.txt", "r+") if aFile aFile.syswrite("ABCDEF") else puts "Unable to open file!" end

Esta sentencia escribirá "ABCDEF" en el archivo.

each_byteMétodo

Este método pertenece a la claseFile. El métodoeach_bytees un método que puede iterar sobre cada carácter de una cadena. Vea el siguiente ejemplo de código:

Ejemplo

#!/usr/bin/ruby aFile = File.new("input.txt", "r+") if aFile aFile.syswrite("ABCDEF") aFile.rewind aFile.each_byte {|ch| putc ch; putc ?. } else puts "Unable to open file!" end

Los caracteres se pasan uno a uno a la variable ch y luego se muestran en pantalla, de la siguiente manera:

A.B.C.D.E.F.s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...

IO.readlinesMétodo

ClaseFilees una subclase de la clase IO. La clase IO también tiene algunos métodos para manipular archivos.

IO.readlineses un método de la clase IO. Este método devuelve el contenido del archivo línea por línea. El siguiente código demuestraIO.readlinessu uso:

Ejemplo

#!/usr/bin/ruby arr = IO.readlines("input.txt") puts arr[0] puts arr[1]

En este código, la variable arr es un array. El archivoinput.txtcada línea del archivo será un elemento del array arr. Por lo tanto, arr

IO.foreachMétodo

Este método también devuelve la salida línea por línea. El métodoforeachy el métodoreadlinesdifieren en que el métodoforeachse asocia con un bloque. Sin embargo, a diferencia del métodoreadlines, el métodoforeachno devuelve un array. Por ejemplo:

Ejemplo

#!/usr/bin/ruby IO.foreach("input.txt"){|block| puts block}

Este código pasará el contenido del archivotestlínea por línea a la variable block, y luego la salida se mostrará en la pantalla.

Renombrar y eliminar archivos

Puede, mediante los métodosrenameydeleterenombrar y eliminar archivos.

El siguiente ejemplo renombra un archivo existentetest1.txt：

Ejemplo

#!/usr/bin/ruby #Renombrar el archivo test1.txt como test2.txt File.rename( "test1.txt", "test2.txt" )

El siguiente ejemplo elimina un archivo existentetest2.txt：

Ejemplo

#!/usr/bin/ruby #Eliminar el archivo test2.txt File.delete("text2.txt")

Modos de archivo y propiedad

Usando el método con máscarachmodpara cambiar el modo o la lista de permisos/accesos del archivo:

El siguiente ejemplo cambia el modo de un archivo existentetest.txta un valor de máscara:

Ejemplo

#!/usr/bin/ruby file = File.new( "test.txt", "w" ) file.chmod( 0755 )

La siguiente tabla enumerachmodlas diferentes máscaras que se pueden usar en el método:

MáscaraDescripción
0700Máscara rwx, para el propietario
0400r, para el propietario
0200w, para el propietario
0100x, para el propietario
0070Máscara rwx, para el grupo
0040r, para el grupo
0020w, para el grupo
0010x, para el grupo
0007Máscara rwx, para otros
0004r, para otros
0002w, para otros
0001x, para otros
4000Establecer el ID de usuario al ejecutar
2000Establecer el ID del grupo propietario al ejecutar
1000Guardar el texto de intercambio, incluso después de su uso.

Consultas de archivos

El siguiente comando comprueba si el archivo ya existe antes de abrirlo:

Ejemplo

#!/usr/bin/ruby File.open("file.rb") if File::exists?( "file.rb" )

El siguiente comando verifica si el archivo es realmente un archivo:

Ejemplo

#!/usr/bin/ruby #Devuelve true o false File.file?( "text.txt" )

El siguiente comando comprueba si el nombre de archivo dado es un directorio:

Ejemplo

#!/usr/bin/ruby #Un directorio File::directory?( "/usr/local/bin" ) # => true #Un archivo File::directory?( "file.rb" ) # => false

El siguiente comando comprueba si el archivo es legible, escribible y ejecutable:

Ejemplo

#!/usr/bin/ruby File.readable?( "test.txt" ) # => true File.writable?( "test.txt" ) # => true File.executable?( "test.txt" ) # => false

El siguiente comando comprueba si el archivo tiene tamaño cero:

Ejemplo

#!/usr/bin/ruby File.zero?( "test.txt" ) # => true

El siguiente comando devuelve el tamaño del archivo:

Ejemplo

#!/usr/bin/ruby File.size?( "text.txt" ) # => 1002

El siguiente comando se utiliza para comprobar el tipo de archivo:

Ejemplo

#!/usr/bin/ruby File::ftype( "test.txt" ) # => file

El método ftype identifica el tipo de archivo devolviendo uno de los siguientes valores:file, directory, characterSpecial, blockSpecial, fifo, link, socket o unknown。

El siguiente comando se utiliza para comprobar la hora de creación, modificación o último acceso del archivo:

Ejemplo

#!/usr/bin/ruby File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008 File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008 File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Directorios en Ruby

Todos los archivos están contenidos en directorios, y Ruby proporciona formas de manejar archivos y directorios.FileLa clase se utiliza para manejar archivos,DirLa clase se utiliza para manejar directorios.

Explorar directorios

Para cambiar de directorio en un programa Ruby, utiliceDir.chdir. El siguiente ejemplo cambia el directorio actual a/usr/bin。

Dir.chdir("/usr/bin")

Puede Dir.pwdver el directorio actual:

puts Dir.pwd #Devuelve el directorio actual, similar a /usr/bin

Puede utilizarDir.entriespara obtener la lista de archivos y directorios del directorio especificado:

puts Dir.entries("/usr/bin").join(' ')

Dir.entriesDevuelve un array que contiene todos los elementos del directorio especificado.Dir.foreachProporciona la misma funcionalidad:

Dir.foreach("/usr/bin") do |entry| puts entry end

Una forma más concisa de obtener la lista de directorios es mediante el método similar a un array de Dir:

Dir["/usr/bin/*"]

Crear directorios

Dir.mkdirSe puede utilizar para crear directorios:

Dir.mkdir("mynewdir")

También puede establecer permisos en el nuevo directorio (no en un directorio ya existente) mediante mkdir:

Nota:La máscara 755 establece los permisos del propietario (owner), del grupo (group) y de todos (world [anyone]) como rwxr-xr-x, donde r = read (lectura), w = write (escritura), x = execute (ejecución).

Dir.mkdir( "mynewdir", 755 )

Eliminar directorios

Dir.deleteSe puede utilizar para eliminar directorios.Dir.unlinkyDir.rmdirRealiza la misma función, lo que nos resulta conveniente.

Dir.delete("testdir")

Crear archivos y directorios temporales

Los archivos temporales son aquellos que se crean simplemente durante la ejecución del programa, pero no se almacenan de forma permanente.

Dir.tmpdirProporciona la ruta del directorio temporal del sistema actual, pero este método no está disponible por defecto. Para queDir.tmpdiresté disponible, es necesario utilizar el 'tmpdir' requerido.

PuedeDir.tmpdiryFile.joinusarlos juntos para crear un archivo temporal independiente de la plataforma:

require 'tmpdir' tempfilename = File.join(Dir.tmpdir, "tingtong") tempfile = File.new(tempfilename, "w") tempfile.puts "This is a temporary file" tempfile.close File.delete(tempfilename)

Este código crea un archivo temporal, escribe datos en él y luego elimina el archivo. La biblioteca estándar de Ruby también incluye una biblioteca llamadaTempfileque se puede utilizar para crear archivos temporales:

require 'tempfile' f = Tempfile.new('tingtong') f.puts "Hello" puts f.path f.close

Funciones integradas

A continuación se proporciona la lista completa de las funciones integradas en Ruby para manejar archivos y directorios:

Otras extensiones