Entrada y salida de archivos en Ruby

puts 语句

在前面的章节中，您赋值给变量，然后使用 puts 语句打印输出。

puts 语句指示程序显示存储在变量中的值。这将在每行末尾添加一个新行。

Ejemplo en línea

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

以上示例运行输出结果为：

This is variable one
This is variable two

gets 语句

gets 语句可用于获取来自名为 STDIN 的标准屏幕的用户输入。

Ejemplo en línea

下面的代码演示了如何使用 gets 语句。该代码将提示用户输入一个值，该值将被存储在变量 val 中，最后会被打印在 STDOUT 上。

Ejemplo en línea

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

以上示例运行输出结果为：

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

putc 语句

与 puts 语句不同，puts 语句输出整个字符串到屏幕上，而 putc 语句可用于依次输出一个字符。

Ejemplo en línea

下面代码的输出只是字符 H：

Ejemplo en línea

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

以上示例运行输出结果为：

H

print 语句

print 语句与 puts 语句类似。唯一的不同在于 puts 语句在输出内容后会跳到下一行，而使用 print 语句时，光标定位在同一行。

Ejemplo en línea

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

以上示例运行输出结果为：

Hello WorldGood Morning

打开和关闭文件

截至现在，您已经读取并写入标准输入和输出。现在，我们将看看如何操作实际的数据文件。

File.new método

您可以使用 File.new 方法创建一个 File 对象用于读取、写入或者读写，读写权限取决于 mode 参数。最后，您可以使用 File.close 方法来关闭该文件。

语法

aFile = File.new("filename", "mode")
　　　# ... 处理文件
aFile.close

File.open método

您可以使用 File.open 方法创建一个新的 file 对象，并把该 file 对象赋值给文件。但是，File.open 和 File.new 方法之间有一点不同。不同点是 File.open 方法可与块关联，而 File.new 方法不能。

File.open("filename", "mode") do |aFile|
　　　# ... procesar el archivo
end

La siguiente tabla enumera los diferentes modos de apertura de archivos:

lectura y escritura de archivos

para la lectura simple I/Los métodos de O también se pueden usar para todos los objetos file. Por lo tanto, gets lee una línea desde la entrada estándar,aFile.gets Leer una línea del objeto de archivo aFile.

Pero, I/El objeto O proporciona configuraciones adicionales para métodos de acceso, lo que nos facilita.

sysread método

Puede usar el método sysread Para leer el contenido del archivo. Al usar el método sysread, puede abrir el archivo en cualquier modo. Por ejemplo:

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

Este es un archivo de texto simple para propósitos de prueba.

Ahora intentemos leer este archivo:

Ejemplo en línea

#!/usr/bin/ruby
　
aFile = File.new("input.txt", "r")
if aFile
　　　content = aFile.sysread(20)
　　　puts content
else
　　　puts "No se puede abrir el archivo!"
end

Esta instrucción colocará el puntero de archivo en el inicio del archivo. 20 carácter. El puntero de archivo se colocará en el archivo en la posición del carácter 21 en la posición del carácter.

syswrite método

Puede usar el método syswrite Para escribir contenido en el archivo. Al usar el método syswrite, debe abrir el archivo en modo de escritura. Por ejemplo:

Ejemplo en línea

#!/usr/bin/ruby
　
aFile = File.new("input.txt", "r")+)
if aFile
　　　aFile.syswrite("ABCDEF")
else
　　　puts "No se puede abrir el archivo!"
end

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

each_byte método

Este método pertenece a la clase File. Método each_byte es una función que puede iterar cada carácter de una cadena. Vea el siguiente ejemplo de código:

Ejemplo en línea

#!/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 "No se puede abrir el archivo!"
end

carácter a carácter se transmite a la variable ch y se muestra en la pantalla, como se muestra a continuación:

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.readlines método

clase File es un subclase de la clase IO. La clase IO también tiene métodos para operar archivos.

IO.readlines es un método de la clase IO. Este método devuelve el contenido del archivo línea por línea. El siguiente código muestra el método IO.readlines Uso:

Ejemplo en línea

#!/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 archivo input.txt Cada línea será un elemento del array arr. Por lo tanto, arr[0] contendrá la primera línea, y arr[1] contendrá la segunda línea del archivo.

IO.foreach método

Este método también devuelve la salida línea por línea. El método foreach con el método readlines diferente es que el método foreach asociado con el bloque. Pero, a diferencia del método readlines，método foreach No devuelve un array. Por ejemplo:

Ejemplo en línea

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

Este código transmitirá el archivo test El contenido del archivo se transmite línea por línea a la variable block, y luego se muestra en la pantalla.

Renombrar y eliminar archivos

您可以通过 rename 和 delete Métodos para renombrar y eliminar archivos.

El siguiente ejemplo renombra un archivo existente test1.txt：

Ejemplo en línea

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

El siguiente ejemplo elimina un archivo existente test2.txt：

Ejemplo en línea

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

Modo de archivo y propiedad

Usar con máscara chmod Método para cambiar el modo o los permisos del archivo/Lista de acceso:

El siguiente ejemplo cambia un archivo existente test.txt El modo de un valor de máscara es:

Ejemplo en línea

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

La siguiente tabla enumera chmod Diferentes máscaras disponibles en el método:

Consulta de archivos

Las siguientes órdenes verifican si el archivo existe antes de abrirlo:

Ejemplo en línea

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

Las siguientes órdenes consultan si el archivo es realmente un archivo:

Ejemplo en línea

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

Las siguientes órdenes verifican si el nombre del archivo dado es un directorio:

Ejemplo en línea

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

Las siguientes órdenes verifican si el archivo es legible, escribible o ejecutable:

Ejemplo en línea

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

Las siguientes órdenes verifican si el tamaño del archivo es cero:

Ejemplo en línea

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

Las siguientes órdenes devuelven el tamaño del archivo:

Ejemplo en línea

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

Las siguientes órdenes se utilizan para verificar el tipo de archivo:

Ejemplo en línea

#!/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 desconocido.

Las siguientes órdenes se utilizan para verificar el tiempo de creación, modificación o acceso del archivo:

Ejemplo en línea

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

Ruby 中的目录

所有的文件都是包含在目录中，Ruby 提供了处理文件和目录的方式。File 类用于处理文件，Dir 类用于处理目录。

浏览目录

为了在 Ruby 程序中改变目录，请使用 Dir.chdir。下面的示例改变当前目录为 /usr/bin.

Dir.chdir("/usr/bin")

您可以通过 Dir.pwd 查看当前目录：

puts Dir.pwd # 返回当前目录，类似　/usr/bin

您可以使用 Dir.entries 获取指定目录内的文件和目录列表：

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

Dir.entries 返回一个数组，包含指定目录内的所有项。Dir.foreach 提供了相同的功能：

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

获取目录列表的一个更简洁的方式是通过使用 Dir 的类数组的方法：

Dir["/usr/bin/*"]

创建目录

Dir.mkdir 可用于创建目录：

Dir.mkdir("mynewdir")

您也可以通过 mkdir 在新目录（不是已存在的目录）上设置权限：

注意：掩码 755 设置所有者(owner)、所属组(group)、每个人（world [anyone]）的权限为 rwxr-xr-x，其中 r = read 读取，w = write 写入，x = execute 执行。

Dir.mkdir( "mynewdir",　755　)

删除目录

Dir.delete 可用于删除目录。Dir.unlink 和 Dir.rmdir 执行同样的功能，为我们提供了便利。

Dir.delete("testdir")

创建文件 & 临时目录

临时文件是那些在程序执行过程中被简单地创建，但不会永久性存储的信息。

Dir.tmpdir 提供了当前系统上临时目录的路径，但是该方法默认情况下是不可用的。为了让 Dir.tmpdir 可用，使用必需的 'tmpdir' 是必要的。

您可以把 Dir.tmpdir 和 File.join 一起使用，来创建一个独立于平台的临时文件：

require 'tmpdir'
tempfilename = File.join(Dir.tmpdir, "tingtong")
tempfile = File.new(tempfilename, "w")
tempfile.puts "Este es un archivo temporal"
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 llamada Tempfile de la biblioteca, que se puede usar 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 una lista completa de las funciones integradas para manejar archivos y directorios en Ruby:

• Clase y métodos de File.

• Clase y métodos de Dir.