Ruby Entrées/Sorties de fichiers

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

ClasseIOFournit toutes les méthodes de base, telles queread, write, gets, puts, readline, getcetprintf。

Ce chapitre expliquera toutes les fonctions d'E/S de base disponibles dans Ruby. Pour plus de fonctions, veuillez vous référer à la classeIOde Ruby.

putsInstruction

Dans les chapitres précédents, vous avez attribué des valeurs à des variables, puis utilisé l'instructionputspour afficher la sortie.

putsL'instruction demande au programme d'afficher la valeur stockée dans la variable. Cela ajoute un saut de ligne à la fin de chaque ligne.

Exemple

#!/usr/bin/ruby val1 = "Ceci est la variable un" val2 = "Ceci est la variable deux" puts val1 puts val2

La sortie de l'exemple ci-dessus est :

This is variable one
This is variable two

getsInstruction

getsL'instruction peut être utilisée pour obtenir l'entrée utilisateur depuis l'entrée standard nommée STDIN.

Exemple

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

Exemple

#!/usr/bin/ruby puts "Entrez une valeur :" val = gets puts val

La sortie de l'exemple ci-dessus est :

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

putcInstruction

andputsContrairement à l'instruction,putsl'instruction affiche la chaîne entière à l'écran, tandis queputcl'instruction peut être utilisée pour afficher un caractère à la fois.

Exemple

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

Exemple

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

La sortie de l'exemple ci-dessus est :

H

printInstruction

printL'instruction est similaire à l'instructionputs. La seule différence est queputsl'instruction passe à la ligne suivante après avoir affiché le contenu, tandis qu'en utilisant l'instructionprintinstruction, le curseur est positionné sur la même ligne.

Exemple

#!/usr/bin/ruby print "Hello World" print "Bonjour"

La sortie de l'exemple ci-dessus est :

Hello WorldGood Morning

Ouverture et fermeture de fichiers

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

File.newMéthode

Vous pouvez utiliser la méthodeFile.newpour créer un objetFileen lecture, en écriture ou les deux, selon le paramètre mode. Enfin, vous pouvez utiliser la méthodeFile.closepour fermer le fichier.

Syntaxe

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

File.openMéthode

Vous pouvez utiliser la méthodeFile.openpour créer un nouvel objet fichier et affecter cet objet fichier à un fichier. Cependant,File.openetFile.newIl y a une légère différence entre les méthodes. La différence est que la méthodeFile.openpeut être associée à un bloc, tandis queFile.newne le peut pas.

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

Le tableau suivant répertorie les différents modes d'ouverture de fichiers :

ModeDescription
rMode lecture seule. Le pointeur de fichier est placé au début du fichier. Il s'agit du mode par défaut.
r+Mode lecture-écriture. Le pointeur de fichier est placé au début du fichier.
wMode écriture seule. Si le fichier existe, il écrase le fichier. Si le fichier n'existe pas, un nouveau fichier est créé pour l'écriture.
w+Mode lecture-écriture. Si le fichier existe, il écrase le fichier existant. Si le fichier n'existe pas, un nouveau fichier est créé pour la lecture et l'écriture.
aMode écriture seule. Si le fichier existe, le pointeur de fichier est placé à la fin du fichier. C'est-à-dire que le fichier est en mode ajout. Si le fichier n'existe pas, un nouveau fichier est créé pour l'écriture.
a+Mode lecture-écriture. Si le fichier existe, le pointeur de fichier est placé à la fin du fichier. C'est-à-dire que le fichier est en mode ajout. Si le fichier n'existe pas, un nouveau fichier est créé pour la lecture et l'écriture.

Lecture et écriture de fichiers

Les méthodes utilisées pour les E/S simples peuvent également être utilisées avec tous les objets fichier. Ainsi, gets lit une ligne depuis l'entrée standard,aFile.getset lit une ligne depuis l'objet fichier aFile.

Cependant, les objets d'E/S fournissent des paramètres supplémentaires pour les méthodes d'accès, ce qui nous facilite la tâche.

sysreadMethod

Vous pouvez utiliser la méthodesysreadpour lire le contenu d'un fichier. Lorsque vous utilisez la méthode sysread, vous pouvez ouvrir le fichier dans n'importe quel mode. Par exemple :

Le fichier texte d'entrée est le suivant :

This is a simple text file for testing purpose.

Maintenant, essayons de lire ce fichier :

Exemple

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

Cette instruction lit les 20 premiers caractères du fichier d'entrée. Le pointeur de fichier sera placé à la position du 21e caractère dans le fichier.

syswriteMéthode

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

Exemple

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

Cette instruction écrira "ABCDEF" dans le fichier.

each_byteMéthode

Cette méthode appartient à la classeFile. La méthodeeach_byteest un itérateur qui parcourt chaque caractère d'une chaîne. Regardez l'exemple de code suivant :

Exemple

#!/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 "Impossible d'ouvrir le fichier !" end

Les caractères sont transmis un par 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.readlinesMethod

La classeFileest une sous-classe de la classe IO. La classe IO possède également quelques méthodes pour manipuler des fichiers.

IO.readlinesest 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éthodeIO.readlines:

Exemple

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

Dans ce code, la variable arr est un tableau. Le fichierinput.txtcontient chaque ligne comme élément du tableau arr. Par conséquent, arr

IO.foreachMethod

Cette méthode renvoie également la sortie ligne par ligne. La méthodeforeachet la méthodereadlinesdiffèrent en ce que la méthodeforeachest associée à un bloc. Cependant, contrairement à la méthodereadlines, la méthodeforeachne renvoie pas de tableau. Par exemple :

Exemple

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

Ce code transmettra le contenu du fichiertestligne par ligne à la variable block, puis la sortie sera affichée à l'écran.

Renommer et supprimer des fichiers

Vous pouvez utiliser les méthodesrenameetdeletepour renommer et supprimer des fichiers.

L'exemple suivant renomme un fichier existanttest1.txt：

Exemple

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

L'exemple suivant supprime un fichier existanttest2.txt：

Exemple

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

Modes et propriété des fichiers

Utilisation de la méthodechmodavec un masque pour changer le mode ou la liste des permissions/d'accès d'un fichier :

L'exemple suivant change le mode d'un fichier existanttest.txten une valeur de masque :

Exemple

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

Le tableau suivant liste leschmoddifférents masques qui peuvent être utilisés dans la méthode :

MasqueDescription
0700masque rwx pour le propriétaire
0400r, pour le propriétaire
0200w, pour le propriétaire
0100x, pour le propriétaire
0070masque rwx pour le groupe
0040r, pour le groupe
0020w, pour le groupe
0010x, pour le groupe
0007masque rwx pour les autres
0004r, pour les autres
0002w, pour les autres
0001x, pour les autres
4000Définir l'ID utilisateur lors de l'exécution
2000Définir l'ID de groupe lors de l'exécution
1000Sauvegarder le texte échangé, même après utilisation

Requêtes de fichiers

La commande suivante vérifie si le fichier existe avant d'ouvrir le fichier :

Exemple

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

La commande suivante vérifie si le fichier est bien un fichier :

Exemple

#!/usr/bin/ruby #Renvoie vrai ou faux. File.file?( "text.txt" )

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

Exemple

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

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

Exemple

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

La commande suivante vérifie si la taille du fichier est nulle :

Exemple

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

La commande suivante renvoie la taille du fichier :

Exemple

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

La commande suivante est utilisée pour vérifier le type du fichier :

Exemple

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

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

La commande suivante est utilisée pour vérifier l'heure de création, de modification ou de dernier accès du fichier :

Exemple

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

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

Parcourir les répertoires

Pour changer de répertoire dans un programme Ruby, utilisezDir.chdir. L'exemple suivant remplace le répertoire courant par/usr/bin。

Dir.chdir("/usr/bin")

Vous pouvez utiliser Dir.pwdpour afficher le répertoire courant :

puts Dir.pwd #Renvoie le répertoire courant, similaire à /usr/bin

Vous pouvez utiliserDir.entriespour obtenir la liste des fichiers et des répertoires dans le répertoire spécifié :

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

Dir.entriesRenvoie un tableau contenant tous les éléments du répertoire spécifié.Dir.foreachFournit la même fonctionnalité :

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

Une façon plus concise d'obtenir une liste du contenu d'un répertoire consiste à utiliser les méthodes de type tableau de Dir :

Dir["/usr/bin/*"]

Création de répertoires

Dir.mkdirPeut être utilisé pour créer des répertoires :

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 pour le propriétaire, le groupe et tout le monde (n'importe qui) à rwxr-xr-x, où r = lecture, w = écriture, x = exécution.

Dir.mkdir( "mynewdir", 755 )

Suppression de répertoires

Dir.deletePeut être utilisé pour supprimer un répertoire.Dir.unlinketDir.rmdirEffectuent la même fonction, ce qui nous facilite la tâche.

Dir.delete("testdir")

Création de fichiers et de répertoires temporaires

Les fichiers temporaires sont des informations qui sont simplement créées pendant l'exécution du programme mais qui ne sont pas stockées de façon permanente.

Dir.tmpdirfournit le chemin du répertoire temporaire sur le système actuel, mais cette méthode n'est pas disponible par défaut. Pour rendreDir.tmpdirdisponible, il est nécessaire d'utiliser require 'tmpdir'.

Vous pouvez utiliserDir.tmpdiretFile.joinensemble 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 "Ceci est un fichier temporaire" tempfile.close File.delete(tempfilename)

Ce code crée un fichier temporaire, y écrit des données, puis supprime le fichier. La bibliothèque standard de Ruby inclut également une bibliothèque nomméeTempfilebibliothèque, 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 natives

Ce qui suit fournit une liste complète des fonctions intégrées pour la gestion des fichiers et des répertoires dans Ruby :

Autres extensions