Ruby: E / S 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 se derivan de la clase IO.

La clase IO proporciona todos los métodos básicos, como leer, escribir, obtener, poner, readline, getc y printf .

Este capítulo cubrirá todas las funciones básicas de E / S disponibles en Ruby. Para obtener más funciones, consulte Ruby Class IO .

La declaración de put

En los capítulos anteriores, asignó valores a las variables y luego imprimió la salida usando la declaración de venta .

El pone declaración da instrucciones al programa para que muestre el valor almacenado en la variable. Esto agregará una nueva línea al final de cada línea que escriba.

Ejemplo

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

Esto producirá el siguiente resultado:

This is variable one
This is variable two

La declaración de gets

La instrucción gets se puede utilizar para tomar cualquier entrada del usuario desde la pantalla estándar llamada STDIN.

Ejemplo

El siguiente código le muestra cómo usar la instrucción gets. Este código le pedirá al usuario que ingrese un valor, que se almacenará en una variable val y finalmente se imprimirá en STDOUT.

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

Esto producirá el siguiente resultado:

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

La declaración de putc

A diferencia de la pone declaración, que emite la cadena completa en la pantalla, el putc declaración puede ser usada para dar salida a un carácter a la vez.

Ejemplo

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

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

Esto producirá el siguiente resultado:

H

La declaración impresa

La declaración de impresión es similar a la declaración de venta . La única diferencia es que la instrucción put pasa a la siguiente línea después de imprimir el contenido, mientras que con la instrucción print el cursor se coloca en la misma línea.

Ejemplo

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Esto producirá el siguiente resultado:

Hello WorldGood Morning

Abrir y cerrar archivos

Hasta ahora, ha estado leyendo y escribiendo en la entrada y salida estándar. Ahora, veremos cómo jugar con archivos de datos reales.

El método File.new

Puede crear un objeto File utilizando el método File.new para leer, escribir o ambos, según la cadena de modo. Finalmente, puede usar el método File.close para cerrar ese archivo.

Sintaxis

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

El método File.open

Puede utilizar el método File.open para crear un nuevo objeto de archivo y asignar ese objeto de archivo a un archivo. Sin embargo, hay una diferencia entre los métodos File.open y File.new . La diferencia es que el método File.open se puede asociar con un bloque, mientras que no se puede hacer lo mismo con el método File.new .

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

Aquí hay una lista de los diferentes modos de abrir un archivo:

No Señor.	Modos y descripción
1	r Modo de solo lectura. El puntero de archivo se coloca al principio del archivo. Este es el modo por defecto.
2	r+ Modo lectura-escritura. El puntero del archivo estará al principio del archivo.
3	w Modo de solo escritura. Sobrescribe el archivo si existe. Si el archivo no existe, crea un nuevo archivo para escribir.
4	w+ Modo lectura-escritura. Sobrescribe el archivo existente si el archivo existe. Si el archivo no existe, crea un nuevo archivo para leer y escribir.
5	a Modo de solo escritura. El puntero de archivo está al final del archivo si el archivo existe. Es decir, el archivo está en modo adjuntar. Si el archivo no existe, crea un nuevo archivo para escribir.
6	a+ Modo de lectura y escritura. El puntero de archivo está al final del archivo si el archivo existe. El archivo se abre en modo anexar. Si el archivo no existe, crea un nuevo archivo para lectura y escritura.

Leer y escribir archivos

Los mismos métodos que hemos estado usando para E / S 'simples' están disponibles para todos los objetos de archivo. Entonces, gets lee una línea de la entrada estándar y aFile.gets lee una línea del objeto de archivo aFile.

Sin embargo, los objetos de E / S proporcionan un conjunto adicional de métodos de acceso para facilitar nuestras vidas.

El método sysread

Puede utilizar el método sysread para leer el contenido de un archivo. Puede abrir el archivo en cualquiera de los modos cuando utilice el método sysread. Por ejemplo

A continuación se muestra el archivo de texto de entrada:

This is a simple text file for testing purpose.

Ahora intentemos leer este archivo:

#!/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 declaración generará los primeros 20 caracteres del archivo. El puntero del archivo ahora se colocará en el carácter 21 del archivo.

El método syswrite

Puede utilizar el método syswrite para escribir el contenido en un archivo. Debe abrir el archivo en modo escritura cuando utilice el método syswrite. Por ejemplo

#!/usr/bin/ruby

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

Esta declaración escribirá "ABCDEF" en el archivo.

El método each_byte

Este método pertenece a la clase File . El método each_byte siempre está asociado con un bloque. Considere el siguiente ejemplo de código:

#!/usr/bin/ruby

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

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

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...
.
.

El método IO.readlines

La clase File es una subclase de la clase IO. La clase IO también tiene algunos métodos, que pueden usarse para manipular archivos.

Uno de los métodos de la clase IO es IO.readlines . Este método devuelve el contenido del archivo línea por línea. El siguiente código muestra el uso del método IO.readlines -

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

En este código, la variable arr es una matriz. Cada línea del archivo input.txt será un elemento de la matriz arr. Por lo tanto, arr [0] contendrá la primera línea, mientras que arr [1] contendrá la segunda línea del archivo.

El método IO para cada uno

Este método también devuelve la salida línea por línea. La diferencia entre el método foreach y el método readlines es que el método foreach está asociado con un bloque. Sin embargo, a diferencia del método readlines , el método foreach no devuelve una matriz. Por ejemplo

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

Este código pasará el contenido del archivo de prueba línea por línea al bloque de variables, y luego la salida se mostrará en la pantalla.

Cambiar el nombre y eliminar archivos

Puede cambiar el nombre y eliminar archivos mediante programación con Ruby con los métodos de cambio de nombre y eliminación .

A continuación se muestra el ejemplo para cambiar el nombre de un archivo existente test1.txt :

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

A continuación se muestra el ejemplo para eliminar un archivo test2.txt existente :

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

Modos de archivo y propiedad

Use el método chmod con una máscara para cambiar el modo o los permisos / lista de acceso de un archivo -

A continuación se muestra el ejemplo para cambiar el modo de un archivo test.txt existente a un valor de máscara:

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )

A continuación se muestra la tabla, que puede ayudarlo a elegir una máscara diferente para el método chmod :

No Señor.	Máscara y descripción
1	0700 máscara rwx para el propietario
2	0400 r para propietario
3	0200 w para propietario
4	0100 x para propietario
5	0070 máscara rwx para grupo
6	0040 r para grupo
7	0020 w para grupo
8	0010 x para grupo
9	0007 máscara rwx para otros
10	0004 r para otros
11	0002 w para otros
12	0001 x para otro
13	4000 Establecer ID de usuario en ejecución
14	2000 Establecer ID de grupo en ejecución
15	1000 Guarde el texto intercambiado, incluso después de su uso

Consultas de archivos

El siguiente comando prueba si un archivo existe antes de abrirlo:

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

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

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

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

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

El siguiente comando busca si el archivo se puede leer, escribir o ejecutar:

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

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

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

El siguiente comando devuelve el tamaño del archivo:

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

El siguiente comando se puede utilizar para encontrar un tipo de archivo:

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

El método ftype identifica el tipo de archivo al devolver uno de los siguientes: archivo, directorio, characterSpecial, blockSpecial, FIFo, link, socket o unknown.

El siguiente comando se puede usar para encontrar cuándo se creó, modificó o accedió por última vez a un archivo:

#!/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 varios directorios y Ruby no tiene problemas para manejarlos también. Mientras que la clase File maneja archivos, los directorios se manejan con la clase Dir .

Navegar por directorios

Para cambiar de directorio dentro de un programa Ruby, use Dir.chdir de la siguiente manera. Este ejemplo cambia el directorio actual a / usr / bin .

Dir.chdir("/usr/bin")

Puede averiguar cuál es el directorio actual con Dir.pwd -

puts Dir.pwd # This will return something like /usr/bin

Puede obtener una lista de los archivos y directorios dentro de un directorio específico usando Dir.entries -

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

Dir.entries devuelve una matriz con todas las entradas dentro del directorio especificado. Dir.foreach ofrece la misma función:

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

Una forma aún más concisa de obtener listados de directorios es utilizando el método de matriz de clases de Dir:

Dir["/usr/bin/*"]

Crear un directorio

El Dir.mkdir se puede utilizar para crear directorios:

Dir.mkdir("mynewdir")

También puede establecer permisos en un nuevo directorio (no uno que ya exista) con mkdir -

NOTE - La máscara 755 establece los permisos propietario, grupo, mundo [cualquiera] en rwxr-xr-x donde r = leer, w = escribir y x = ejecutar.

Dir.mkdir( "mynewdir", 755 )

Eliminar un directorio

El Dir.delete se puede utilizar para eliminar un directorio. Los Dir.unlink y Dir.rmdir realiza exactamente la misma función y se proporcionan por conveniencia.

Dir.delete("testdir")

Creación de archivos y directorios temporales

Los archivos temporales son aquellos que pueden crearse brevemente durante la ejecución de un programa, pero no son un almacén permanente de información.

Dir.tmpdir proporciona la ruta al directorio temporal en el sistema actual, aunque el método no está disponible de forma predeterminada. Para que Dir.tmpdir esté disponible, es necesario utilizar require 'tmpdir'.

Puede usar Dir.tmpdir con File.join 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 lo elimina. La biblioteca estándar de Ruby también incluye una biblioteca llamada Tempfile que puede crear archivos temporales para usted:

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

Funciones integradas

Aquí están las funciones integradas de ruby ​​para procesar archivos y directorios:

• Clase de archivo y métodos .

• Dir Clase y métodos .