输入输出文件 Ruby

puts L'instruction

Dans les chapitres précédents, vous avez affecté des valeurs aux variables, puis utilisé puts L'instruction affiche la sortie.

puts L'instruction indique que le programme affiche la valeur stockée dans la variable. Cela ajoutera une nouvelle ligne à la fin de chaque ligne.

Exemple en ligne

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

Les résultats de l'exemple ci-dessus sont les suivants :

This is variable one
This is variable two

gets L'instruction

gets L'instruction peut être utilisée pour obtenir l'entrée de l'utilisateur à partir de l'écran standard nommé STDIN.

Exemple en ligne

Le code suivant montre comment utiliser l'instruction gets. Ce code invite l'utilisateur à saisir une valeur, qui est stockée dans la variable val et affichée sur STDOUT.

Exemple en ligne

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

Les résultats de l'exemple ci-dessus sont les suivants :

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

putc L'instruction

et puts L'instruction est différenteputs L'instruction affiche l'ensemble de la chaîne sur l'écran, tandis que putc L'instruction peut être utilisée pour afficher un caractère à la fois.

Exemple en ligne

La sortie du code suivant est simplement le caractère H :

Exemple en ligne

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

Les résultats de l'exemple ci-dessus sont les suivants :

H

print L'instruction

print L'instruction est puts L'instruction est similaire. La seule différence réside dans puts L'instruction saute à la ligne suivante après avoir affiché le contenu, tandis que print Lorsque vous exécutez une instruction print, le curseur se situe sur la même ligne.

Exemple en ligne

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

Les résultats de l'exemple ci-dessus sont les suivants :

Hello WorldGood Morning

Ouvrir et fermer le fichier

Jusqu'à présent, vous avez lu et écrit sur l'entrée et la sortie standard. Maintenant, nous allons voir comment manipuler les fichiers de données réels.

File.new méthode

您可以使用 File.new La méthode pour créer un File L'objet est utilisé pour lire, écrire ou lire-écrire, les permissions en lecture-écriture dépendent du paramètre mode. Enfin, vous pouvez utiliser File.close La méthode pour fermer ce fichier.

Syntaxe

aFile = File.new("filename", "mode")
　　　# ... traiter le fichier
aFile.close

File.open méthode

您可以使用 File.open La méthode crée un nouveau fichier et affecte cet objet fichier au fichier. Cependant,File.open 和 File.new Les méthodes diffèrent légèrement. La différence est File.open La méthode peut être associée à un bloc, tandis que File.new La méthode ne peut pas.

File.open("filename", "mode") do |aFile|
　　　# ... traiter le fichier
end

Le tableau suivant liste les différents modes d'ouverture des fichiers :

Lecture et écriture de fichiers

Pour des opérations simples I/L'objet O offre également des méthodes pour tous les objets file. Donc, gets lit une ligne à partir de l'entrée standard,aFile.gets Lit une ligne à partir de l'objet fichier aFile.

Mais, I/L'objet O fournit des réglages supplémentaires pour accéder aux méthodes, ce qui nous est très utile.

sysread méthode

Vous pouvez utiliser la méthode sysread Pour lire le contenu du fichier. Lorsque vous utilisez la méthode sysread, vous pouvez ouvrir le fichier en n'importe quel mode. Par exemple :

Voici le fichier texte d'entrée :

Ceci est un fichier texte simple pour des tests.

Essayons maintenant de lire ce fichier :

Exemple en ligne

#!/usr/bin/ruby
　
aFile = File.new("input.txt", "r")
if aFile
　　　content = aFile.sysread(20)
　　　puts content
sinon
　　　puts "Impossible d'ouvrir le fichier!"
end

Cette instruction place le pointeur de fichier à l'en-tête du fichier. 20 caractère. Le pointeur de fichier sera placé à la position 21 de la position d'un caractère.

syswrite méthode

Vous pouvez utiliser la méthode syswrite Pour écrire du contenu dans le fichier. Lorsque vous utilisez la méthode syswrite, vous devez ouvrir le fichier en mode écriture. Par exemple :

Exemple en ligne

#!/usr/bin/ruby
　
aFile = File.new("input.txt", "r")+)
if aFile
　　　aFile.syswrite("ABCDEF")
sinon
　　　puts "Impossible d'ouvrir le fichier!"
end

Cette instruction écrit "ABCDEF" dans le fichier.

each_byte méthode

Cette méthode appartient à la classe File. Méthode each_byte C'est une itération possible de chaque caractère d'une chaîne. Regardez l'exemple de code suivant :

Exemple en ligne

#!/usr/bin/ruby
　
aFile = File.new("input.txt", "r")+)
if aFile
　　　aFile.syswrite("ABCDEF")
　　　aFile.rewind
　　　aFile.each_byte {|ch| putc ch; putc ?}
sinon
　　　puts "Impossible d'ouvrir le fichier!"
end

les caractères sont transmis un à un à la variable ch, puis affichés à l'écran, comme indiqué ci-dessous :

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éthode

classe File est une sous-classe de la classe IO. La classe IO a également des méthodes pour manipuler les fichiers.

IO.readlines est une méthode de la classe IO. Cette méthode retourne le contenu du fichier ligne par ligne. Le code suivant montre la méthode IO.readlines l'utilisation :

Exemple en ligne

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

Dans ce code, la variable arr est un tableau. Le fichier input.txt chaque ligne sera un élément du tableau arr. Par conséquent, arr[0] contiendra la première ligne, et arr[1] contiendra la deuxième ligne du fichier.

IO.foreach méthode

Cette méthode retourne également les sorties ligne par ligne. La méthode foreach et la méthode readlines différents entre eux, la méthode foreach lié au bloc. Mais, contrairement à la méthode readlinesméthode foreach ne retourne pas un tableau. Par exemple :

Exemple en ligne

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

ce code transfère le fichier test le contenu du fichier est transmis ligne par ligne à la variable block, puis affiché à l'écran.

renommer et supprimer le fichier

您可以通过 rename 和 delete méthode pour renommer et supprimer le fichier.

l'exemple suivant renomme un fichier existant test1.txt：

Exemple en ligne

#!/usr/bin/ruby
　
#　renommer le fichier　test1.txt　en　test2.txt
File.rename(　"test1.txt",　"test2.txt"　)

l'exemple suivant supprime un fichier existant test2.txt：

Exemple en ligne

#!/usr/bin/ruby
　
#　supprimer le fichier　test2.txt
File.delete("text2.txt")

modèle de fichier et propriété

en utilisant avec masque chmod méthode pour changer le modèle ou les permissions du fichier/liste d'accès :

l'exemple suivant change un fichier existant test.txt le modèle est une valeur de masque :

Exemple en ligne

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

le tableau suivant liste chmod différents masques disponibles dans la méthode :

Recherche de fichiers

Les commandes suivantes vérifient si le fichier existe avant de l'ouvrir :

Exemple en ligne

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

Les commandes suivantes vérifient si le fichier est effectivement un fichier :

Exemple en ligne

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

Les commandes suivantes vérifient si le nom de fichier donné est un répertoire :

Exemple en ligne

#!/usr/bin/ruby
　
# Un répertoire
File::directory?(""/usr/local/bin") => true
　
# Un fichier
File::directory?("file.rb") => false

Les commandes suivantes vérifient si les fichiers sont lisibles, inscriptibles ou exécutables :

Exemple en ligne

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

Les commandes suivantes vérifient si la taille des fichiers est nulle :

Exemple en ligne

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

Les commandes suivantes renvoient la taille des fichiers :

Exemple en ligne

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

Les commandes suivantes sont utilisées pour vérifier le type des fichiers :

Exemple en ligne

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

La méthode ftype identifie le type de fichier en renvoyant l'un des valeurs suivantes :file, directory, characterSpecial, blockSpecial, fifo, link, socket ou inconnu。

Les commandes suivantes sont utilisées pour vérifier le temps de création, de modification ou de dernière accès des fichiers :

Exemple en ligne

#!/usr/bin/ruby
　
File::ctime("test.txt") => Ven. Mai 09　10:06:37　-0700　2008
File::mtime("text.txt") => Ven. Mai 09　10:44:44　-0700　2008
File::atime("text.txt") => Ven. Mai 09　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　"This　is　a　temporary　file"
tempfile.close
File.delete(tempfilename)

这段代码创建了一个临时文件，并向其中写入数据，然后删除文件。Ruby 的标准库也包含了一个名为 Tempfile 的库，该库可用于创建临时文件：

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

函数内建

下面提供了 Ruby 中处理文件和目录的内建函数的完整列表：

• 类和方法 File。

• 类和方法 Dir。