Entrée et sortie de fichier Ruby


Ruby fournit un ensemble complet de méthodes liées aux E/S, implémentées dans le module du noyau. Toutes les méthodes d'E/S sont dérivées de la classe IO. La classe

IO fournit toutes les méthodes de base, telles que read, write, gets, puts, readline, getc et printf.

Ce chapitre expliquera toutes les fonctions d'E/S de base disponibles dans Ruby. Pour plus de fonctions, consultez la classe IO de Ruby.

Instruction

puts

Dans les chapitres précédents, vous avez attribué des valeurs aux variables, puis utilisé l'instruction puts pour imprimer la sortie. L'instruction

puts demande au programme d'afficher la valeur stockée dans la variable. Cela ajoutera une nouvelle ligne à la fin de chaque ligne.

Instance

#!/usr/bin/ruby

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

Le résultat de l'exécution de l'exemple ci-dessus est :

This is variable one
This is variable two

gets instruction

gets instruction Peut être utilisée pour obtenir la saisie de l'utilisateur à partir d'un écran standard appelé STDIN.

Exemple

Le code suivant montre comment utiliser l'instruction get. Ce code demandera à l'utilisateur une valeur, qui sera stockée dans la variable val et finalement imprimée sur STDOUT.

#!/usr/bin/ruby

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

Le résultat de sortie de l'exemple ci-dessus est :

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

putc L'instruction

est différente de l'instruction puts , puts L'instruction affiche une chaîne entière à l'écran, tandis que l'instruction putc peut être utilisée pour afficher les caractères un par un.

Exemple

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

#!/usr/bin/ruby

str="Hello Ruby!"
putc str

Le résultat de sortie de l'exemple ci-dessus est :

H

<🎜 Instruction >print L'instruction

print est similaire à l'instruction puts. La seule différence est que l'instruction puts passe à la ligne suivante après la sortie du contenu, tandis que lors de l'utilisation de l'instruction print, le curseur est positionné sur la même ligne.

Exemple

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Le résultat de l'exemple ci-dessus est :

Hello WorldGood Morning

Ouverture et fermeture de fichiers

À partir de maintenant, vous avez lu et écrit en standard entrée et sortie. Nous allons maintenant voir comment manipuler les fichiers de données réels. Méthode

File.new

Vous pouvez utiliser la méthode

File.new pour créer un objet File pour la lecture, Les autorisations d'écriture ou de lecture et d'écriture, de lecture et d'écriture dépendent du paramètre mode. Enfin, vous pouvez fermer le fichier en utilisant la méthode File.close.

Syntaxe

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

Méthode File.open

Vous pouvez utiliser la méthode

File.open pour créer un nouvel objet fichier , Et attribuez l'objet fichier au fichier. Cependant, il existe une petite différence entre les méthodes File.open et File.new. La différence est que la méthode File.open peut être associée à un bloc, alors que la méthode File.new ne le peut pas.

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

Le tableau ci-dessous répertorie les différents modes d'ouverture des fichiers :

模式描述
r只读模式。文件指针被放置在文件的开头。这是默认模式。
r+读写模式。文件指针被放置在文件的开头。
w只写模式。如果文件存在,则重写文件。如果文件不存在,则创建一个新文件用于写入。
w+读写模式。如果文件存在,则重写已存在的文件。如果文件不存在,则创建一个新文件用于读写。
a只写模式。如果文件存在,则文件指针被放置在文件的末尾。也就是说,文件是追加模式。如果文件不存在,则创建一个新文件用于写入。
a+读写模式。如果文件存在,则文件指针被放置在文件的末尾。也就是说,文件是追加模式。如果文件不存在,则创建一个新文件用于读写。

Lecture et écriture de fichiers

Les méthodes utilisées pour les E/S simples sont également disponibles pour tous les objets fichiers. Ainsi, gets lit une ligne à partir de l'entrée standard et aFile.gets lit une ligne à partir de l'objet fichier aFile.

Cependant, les objets d'E/S fournissent des paramètres supplémentaires pour les méthodes d'accès afin de nous offrir plus de commodité. Méthode

sysread

Vous pouvez utiliser la méthode sysread pour lire le contenu d'un fichier. Lorsque vous utilisez la méthode sysread, vous pouvez ouvrir le fichier dans l'un ou l'autre mode. Par exemple :

Voici le fichier texte d'entrée :

This is a simple text file for testing purpose.

Essayons maintenant de lire ce fichier :

#!/usr/bin/ruby

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

Cette instruction saisira les 20 premiers caractères du fichier . Le pointeur de fichier sera placé au caractère 21 dans le fichier. Méthode

syswrite

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

#!/usr/bin/ruby

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

Cette instruction écrira "ABCDEF" dans le fichier. Méthode

each_byte

Cette méthode appartient à la classe Fichier. La méthode each_byte peut parcourir chaque caractère de la chaîne. Veuillez regarder l'exemple de code suivant :

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

les caractères sont transmis à la variable ch les uns après les autres, puis affichés à l'écran, comme suit :

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 Method

ClassFile est une sous-classe de la classe IO. La classe IO dispose également de méthodes pour manipuler les fichiers.

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

#!/usr/bin/ruby

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

Dans ce code, la variable arr est un tableau. Chaque ligne du fichier input.txt 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 renvoie également la sortie ligne par ligne. La différence entre la méthode foreach et la méthode readlines est que la méthode foreach est associée à un bloc. Cependant, contrairement à la méthode readlines, la méthode foreach ne renvoie pas de tableau. Par exemple :

#!/usr/bin/ruby

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

Ce code transmettra le contenu du fichier test au bloc variable ligne par ligne, puis la sortie sera affichée à l'écran.

Renommer et supprimer des fichiers

Vous pouvez renommer et supprimer des fichiers via les méthodes renommer et supprimer.

L'exemple suivant renomme un fichier existant test1.txt :

#!/usr/bin/ruby

# 重命名文件 test1.txt 为 test2.txt
File.rename( "test1.txt", "test2.txt" )

L'exemple suivant supprime un fichier existant test2.txt :

#!/usr/bin/ruby

# 删除文件 test2.txt
File.delete("text2.txt")

Mode de fichier et propriété

Utilisez la méthode chmod avec un masque pour changer le mode ou les autorisations/listes d'accès d'un fichier :

ci-dessous Exemple : Modifier le mode d'un fichier test.txt existant à une valeur de masque :

#!/usr/bin/ruby

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

Le tableau suivant répertorie les différents masques pouvant être utilisés dans la méthode chmod Code :

掩码描述
0700rwx 掩码,针对所有者
0400r ,针对所有者
0200w ,针对所有者
0100x ,针对所有者
0070rwx 掩码,针对所属组
0040r ,针对所属组
0020w ,针对所属组
0010x ,针对所属组
0007rwx 掩码,针对其他人
0004r ,针对其他人
0002w ,针对其他人
0001x ,针对其他人
4000执行时设置用户 ID
2000执行时设置所属组 ID
1000保存交换文本,甚至在使用后也会保存

Requête de fichier

La commande suivante vérifie si le fichier existe déjà avant de l'ouvrir :

#!/usr/bin/ruby

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

La commande suivante demande si le fichier est bien un fichier :

#!/usr/bin/ruby

# 返回 true 或false
File.file?( "text.txt" )

La commande suivante vérifie si le nom de fichier donné est un répertoire :

#!/usr/bin/ruby

# 一个目录
File::directory?( "/usr/local/bin" ) # => true

# 一个文件
File::directory?( "file.rb" ) # => false

La commande suivante vérifie si le fichier est lisible, inscriptible et exécutable :

#!/usr/bin/ruby

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

La commande suivante vérifie si le fichier est lisible, inscriptible et exécutable : Si la taille est nulle :

#!/usr/bin/ruby

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

La commande suivante renvoie la taille du fichier :

#!/usr/bin/ruby

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

La commande suivante est utilisée pour vérifier le type de la méthode fichier :

#!/usr/bin/ruby

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

ftype renvoie l'un des éléments suivants. Une certaine valeur identifie le type de fichier : fichier, répertoire, caractèreSpécial, blockSpecial, fifo, link, socket ou inconnu.

Les commandes suivantes sont utilisées pour vérifier quand un fichier a été créé, modifié ou consulté pour la dernière fois :

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

Répertoires dans Ruby

Tous les fichiers sont contenus dans des répertoires, Ruby fournit des moyens pour travailler avec des fichiers et des répertoires. La classe File est utilisée pour gérer les fichiers et la classe Dir est utilisée pour gérer les répertoires.

Parcourir le répertoire

Pour changer de répertoire dans un programme Ruby, utilisez Dir.chdir. L'exemple suivant modifie le répertoire actuel en /usr/bin.

Dir.chdir("/usr/bin")

Vous pouvez afficher le répertoire actuel via Dir.pwd :

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

Vous pouvez utiliser Dir.entries pour obtenir les fichiers et les répertoires dans le répertoire spécifié List :

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

Dir.entries Renvoie un tableau contenant toutes les entrées du répertoire spécifié. Dir.foreach fournit la même fonctionnalité :

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

Un moyen plus simple d'obtenir une liste de répertoires consiste à utiliser la méthode de type tableau de Dir :

Dir["/usr/bin/*"]

Créer un répertoire

Dir.mkdir peut être utilisé pour créer un répertoire :

Dir.mkdir("mynewdir")

Vous pouvez également définir des autorisations sur un nouveau répertoire (pas un répertoire existant) via mkdir :

Remarque : Le masque 755 définit les autorisations du propriétaire, du groupe et du monde [n'importe qui] sur rwxr-xr-x, où r = lire = écrire, x = exécuter.

Dir.mkdir( "mynewdir", 755 )

Supprimer le répertoire

Dir.delete peut être utilisé pour supprimer un répertoire. Dir.unlink et Dir.rmdir remplissent la même fonction pour notre commodité.

Dir.delete("testdir")

Créer des fichiers et des répertoires temporaires

Les fichiers temporaires sont des informations qui sont simplement créées lors de l'exécution du programme mais qui ne sont pas stockées de manière permanente.

Dir.tmpdir fournit le chemin d'accès au répertoire temporaire sur le système actuel, mais cette méthode n'est pas disponible par défaut. Afin de rendre Dir.tmpdir disponible, il est nécessaire d'utiliser le 'tmpdir' requis.

Vous pouvez utiliser Dir.tmpdir et File.join ensemble pour créer un fichier temporaire indépendant de la plateforme :

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)

Ce paragraphe Le code crée un fichier temporaire, y écrit des données, puis supprime le fichier. La bibliothèque standard Ruby contient également une bibliothèque nommée Tempfile, qui peut être utilisée pour créer des fichiers temporaires :

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

Fonctions intégrées

Ce qui suit fournit le traitement dans Ruby Complete liste des fonctions intégrées pour les fichiers et répertoires :

  • Classe et méthodes de fichiers.

  • Classe et méthodes Dir.