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.
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 MorningOuverture 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éthodeFile.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.
SyntaxeaFile = File.new("filename", "mode")
# ... 处理文件
aFile.close
Méthode File.open
Vous pouvez utiliser la méthodeFile.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 endLe 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 :
掩码 | 描述 |
---|---|
0700 | rwx 掩码,针对所有者 |
0400 | r ,针对所有者 |
0200 | w ,针对所有者 |
0100 | x ,针对所有者 |
0070 | rwx 掩码,针对所属组 |
0040 | r ,针对所属组 |
0020 | w ,针对所属组 |
0010 | x ,针对所属组 |
0007 | rwx 掩码,针对其他人 |
0004 | r ,针对其他人 |
0002 | w ,针对其他人 |
0001 | x ,针对其他人 |
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.