Bienvenidos una vez más a Ruby desde cero, curso con el cual aprendemos del lenguaje sin necesidad de tener previo conocimiento en el tema. En el capítulo anterior estuvimos estudiando el concepto de módulos aplicado al lenguaje. En este nuevo capítulo estaremos estudiando el manejo de archivos en Ruby, desde como abrirlo hasta como escribir y leer información del mismo.

Rutas y Directorios

La rutas son las direcciones que nos indican cómo llegar a un archivo o directorio en el sistema. Para este capítulo aprenderemos una serie de conceptos básicos para manejarnos entre directorios con Ruby.

A continuación estudiaremos una serie de comandos básicos para el manejo de rutas y directorios con Ruby.

Ruta actual pwd()

Para los que están familiarizados con comandos SHELL, seguramente reconocerán este método. pwd simplemente nos da la ruta del directorio actual donde estemos trabajando, aunque este concepto es bastante sencillo. Veamos un ejemplo para comprender mejor el concepto de ruta actual.

$ irb
>> Dir.pwd
   "/Users/ricardosampayo/Desktop"

Como ven el método pwd de la clase Dir nos da la información de la ruta actual donde se ejecute ese comando. En el caso del ejemplo está ubicado en mi escritorio.

Cambiar de Directorio chdir()

chdir simplemente nos permite movernos a un directorio siempre y cuando sepamos la ruta. Este método es similar al cd en SHELL. Veamos un ejemplo:

Todos los ejemplos utilizados en este curso son mediante el REPL irb o pry.

>> Dir.pwd              #ruta actual
   "/Users/ricardosampayo/Desktop"
#nos cambiamos al directorio test dentro del directorio actual
>> Dir.chdir "test"
   0
>> Dir.pwd              #nueva ruta actual
   "/Users/ricardosampayo/Desktop/test"

>> Dir.pwd              #ruta actual
   "/Users/ricardosampayo"
# nos cambiamos a la carptea test utilizando la ruta absoluta
>> Dir.chdir "/Users/ricardosampayo/Desktop/test"
   0
>> Dir.pwd              #nueva ruta actual
   "/Users/ricardosampayo/Desktop/test"

Como pueden ver en los ejemplos, es posible cambiarnos de directorio utilizando tanto la ruta relativa como absoluta del sistema.

Buscar en un directorio glob()

glob nos permite buscar archivos dentro del directorio de trabajo. Veamos un ejemplo para probar este método:

>> Dir.glob "*.rb"          # Consultamos todos los archivos con extensión rb
   ["codeheroRuby.rb", "codeheroRubyClases.rb", "modulo_ruby.rb"]

Como vemos en el ejemplo podemos utilizar un asterisco ** ( * ) ** como un comodín para buscar cualquier coincidencia, por eso en este caso nos lista todos los archivos que terminen en .rb, si colocáramos ** Dir.glob “*” ** nos listaría todos los archivos dentro del directorio que estemos manejando.

Crear nuevos directorios mkdir()

Al igual que en sistemas operativos basados en Unix mkdir nos crea nuevos directorios o carpetas. Este método recibe como variable la ruta y el nombre de la nueva carpeta que estamos creando, veamos el siguiente ejemplo:

# consultamos la carpeta
>> Dir.glob "*"
   []
# creamos la nueva carpeta, no colocamos ruta por lo tanto
# se crea en la carpeta donde estemos trabajando
>> Dir.mkdir "test"
   0
# consultamos nuevamente la dirección para verificar que efectivamente
# creamos una nueva carpeta o directorio
>> Dir.glob "*"
   ["test"]

Archivos

Una vez entendamos cómo manipular los directorios nos vamos a la gestión de archivos. En esta parte del capítulo aprenderemos todo lo relacionado con el manejo de archivos.

¿Cómo crear un archivo?

Para abrir un archivo simplemente debemos crear un objeto de la clase File (File.new()) o utilizar el método estático open (File.open()) y esto nos devolverá un objeto de tipo File al que podremos manipular.

Para acceder a los archivos debemos pasarle un segundo valor por parámetros que nos indica como vamos abrir el archivo. Veamos los parámetros para abrir y crear un archivo:

  • r: (sólo lectura) Modo por defecto.
  • r+: (lectura y escritura) Comienza la escritura al principio del archivo.
  • w: (sólo escritura) Borra el contenido del archivo o crea un nuevo archivo para escritura.
  • w+: (lectura y escritura) Borra el contenido del archivo o crea un nuevo archivo para lectura y escritura.
  • a: (sólo escritura) Comienza la escritura al final del archivo si existe y si no crea uno nuevo.
  • a+: (lectura y escritura) permite leer y escribir ubicando el cursor al final del archivo si éste existe y si no crea uno nuevo.

Veamos ejemplos de cómo crear y obtener un archivo:

#consultamos el directorio donde estamos trabajando
>> Dir.glob "*"
   ["test"]
#creamos y obtenemos un archivo nuevo
>> archivo =File.new("pruebaCodeHero.txt","w")
   File:pruebaCodeHero.txt
#intentamos crear un archivo pasándole por parámetro solo lectura
>> archivo =File.new("pruebaCodeHeroError.txt","r")
   Errno::ENOENT: No such file or directory - pruebaCodeHeroError.txt
# consultamos nuevamente la carpeta
>> Dir.glob "*"
   ["pruebaCodeHero.txt", "test"]

Como vemos en el ejemplo es importante el uso de los parámetros que nos dan los permisos para manejar los archivos. En el ejemplo vemos claramente cómo intentamos crear un archivo otorgándole permisos únicamente de lectura y éste nos da un error ya que el archivo no existe y no tiene permisos de crear uno nuevo.

¿Cómo leer un archivo?

En Ruby el comando para leer un archivo es read().

Es importante tener en cuenta que las cadenas de caracteres(strings) de Ruby pueden tener datos binarios y no sólo de texto.

Veamos un ejemplo simple para ver cómo funciona bien esto. En el ejemplo preparamos un archivo de texto con dos lineas escritas.

#tomamos el archivo (ya estaba creado con las dos lineas escritas)
>> archivo =File.new("pruebaCodeHero.txt","r")
   File:pruebaCodeHero.txt
#leemos el archivo
>> archivo.read
   "Esto es Codehero\nLa mejor herramienta para aprender a programar en espaniol"

Como vemos el read() nos da la lectura completa del archivo pero, ¿qué pasa si necesitamos más, Si necesitamos leer línea por línea?. En Ruby disponemos de una serie de métodos que nos hacen la vida fácil para leer los archivos.

rewind – Nos regresa a la primera línea del archivo
readline – Nos lee una línea y nos ubica en la siguiente línea
readlines – Nos da un arreglo de las líneas que tenemos por delante en el archivo y nos ubica al final.
lineno – Nos da la línea donde estamos ubicados.

Veamos estos métodos aplicados a nuestro ejemplo anterior:

#tomamos el archivo (ya estaba creado con las dos lineas escritas)
>> archivo =File.new("pruebaCodeHero.txt","r")
   File:pruebaCodeHero.txt
#leemos la primera linea
>> archivo.readline
  "Esto es Codehero\n"
#leemos la segunda linea
>> archivo.readline
   "La mejor herramienta para aprender a programar en espaniol"
#en que linea estamos?
>> archivo.lineno
   2
#pedimos una tercera linea (obviamente error)
>> archivo.readline
   EOFError: end of file reached
#regresamos al principio
>> archivo.rewind
   0
#pedimos todas las lineas en un array
>> archivo.readlines
   ["Esto es Codehero\n", "La mejor herramienta para aprender a programar en espaniol"]

En Ruby una vez hayamos leído una línea no la veremos más a menos que regresemos en el archivo.

¿Cómo escribir un archivo?

En Ruby para escribir información en un archivo usamos el método write() o puts(). La principal diferencia es que puts añade un salto de línea luego de escribirla y write no.

Vemos un ejemplo de cómo escribir en nuestro archivo

#tomamos el archivo (al colocar w+ lo limpia)
>> archivo =File.new("pruebaCodeHero.txt","w+")
   File:pruebaCodeHero.txt
#escribimos con un salto de linea al final
>> archivo.puts "Codehero"
   nil
#escribimos
>> archivo.write "los mejores cursos"
   18
#escribimos con un salto de linea al final
>> archivo.puts " en espaniol"
   nil
#escribimos
>> archivo.write "por Ricardo Sampayo"
   19
#regresamos al comienzo de la linea
>> archivo.rewind
   0
#imprimimos un arras con las lineas dentro del archivo
>> archivo.readlines
   ["Codehero\n", "los mejores cursos en espaniol\n", "por Ricardo Sampayo"]

¿Cómo eliminar y renombrar un archivo?

En Ruby podemos remover un archivo usando el método delete(nombre) y renombrarlo con el método rename(nombre_viejo, nombre_nuevo), Veamos un ejemplo de esto

#consultamos el directorio
>> Dir.glob "*"
   ["pruebaCodeHero.txt", "test"]
#renombramos el archivo
>> File.rename("pruebaCodeHero.txt","listoParaBorrar.txt")
   0
#consultamos nuevamente el directorio para ver los cambios
>> Dir.glob "*"
   ["listoParaBorrar.txt", "test"]
#borramos el archivo
>> File.delete("listoParaBorrar.txt")
   1
#consultamos nuevamente el directorio para ver los cambios
>> Dir.glob "*"
   ["test"]

Conclusión

En este capítulo aprendimos todo lo relacionado con el manejo de archivos y directorios en Ruby, funciones básicas como abrirlos, leerlos, editarlos y eliminarlos.

Si te surgen dudas con nuestros cursos, no te detengas y danos tus comentarios, que con gusto estamos dispuestos a resolver tus inquietudes.

¡Hasta el próximo capítulo!