Le moyen le plus efficace pour écrire dans un fichier de largeur fixe (Ruby)

Question

Je travaille actuellement avec des fichiers de très grande largeur fixe, parfois bien plus d'un million de lignes. J'ai écrit une méthode qui peut écrire sur les fichiers en fonction d'un ensemble de paramètres, mais je pense qu'il doit y avoir un moyen plus efficace d'y parvenir. Le code actuel J'utilise est:

def self.writefiles(file_name, positions, update_value) 
@file_name = file_name 
@positions = positions.to_i 
@update_value = update_value 

line_number = 0 
@file_contents = File.open(@file_name, 'r').readlines 

    while line_number < @file_contents.length 
     @read_file_contents = @file_contents[line_number] 
     @read_file_contents[@positions] = @update_value 
     @file_contents[line_number] = @read_file_contents 
     line_number += 1 
    end 

write_over_file = File.new(@file_name, 'w') 
line_number = 0 

    while line_number < @file_contents.length 
     write_over_file.write @file_contents[line_number] 
     line_number += 1 
    end 

write_over_file.close 
end 

Par exemple, si la position 25 dans le fichier indiqué qu'il est un fichier d'origine la valeur est réglée sur « O » et si je voulais remplacer cette valeur I utiliserait ClassName.writefiles (filename, 140, "X") pour changer cette position sur chaque ligne. Toute aide pour rendre cette méthode plus efficace serait grandement appréciée!

Merci

Answer 1

#!/usr/bin/ruby 
# replace_at_pos.rb 
pos, char, infile, outfile = $* 
pos = pos.to_i 
File.open(outfile, 'w') do |f| 
    File.foreach(infile) do |line| 
    line[pos] = char 
    f.puts line 
    end 
end 

et vous l'utilisez comme:

replace_at_pos.rb 140 X inputfile.txt outputfile.txt 

Pour remplacer ensemble de valeurs, vous pouvez utiliser un hachage:

replace = { 
    100 => 'a', 
    155 => 'c', 
    151 => 't' 
} 
. . . 
replace.each do |k, v| 
    line[k] = v 
end 

Answer 2

Si c'est un fichier de largeur fixe , vous pouvez ouvrir le fichier pour lire/écrire et utiliser chercher pour aller au début des données que vous voulez écrire, et écrire seulement les données que vous voulez nging et pas toute la ligne. Cela serait probablement plus efficace que de réécrire le fichier entier pour remplacer un champ.

Voici un exemple grossier. Il lit le dernier champ (10,20,30) incrémente par 1, et l'écrit en arrière:

tha_file (10 caractères par ligne, y compris la ligne)

12 3 x 10 
23 4 x 20 
78 9 x 30 

seeker.rb

#!/usr/bin/env ruby 
fh=open("tha_file", "r+") 

$RECORD_WIDTH=10 
$POS=8 
$FIELD_WIDTH=2 

# seek to first field 
fh.seek($POS - 1, IO::SEEK_CUR) 

while !fh.eof? 

    cur_val=fh.read($FIELD_WIDTH).to_i 
    puts "read #{cur_val}" 
    fh.seek(-1 * $FIELD_WIDTH, IO::SEEK_CUR) 
    cur_val = cur_val + 1 

    fh.write(cur_val) 
    puts "wrote #{cur_val}" 

    # Move to start of next field in the middle of next record 
    fh.seek($RECORD_WIDTH - $FIELD_WIDTH, IO::SEEK_CUR) 
end 

Answer 3

Vous allez certainement gagner du temps et beaucoup de mémoire en retravaillant les programmes pour lire à partir du fichier une ligne à la fois (Vous lisez actuellement le fichier en mémoire). Vous écrivez ensuite à une copie de sauvegarde du fichier dans la boucle, puis renommez le fichier à la fin. Quelque chose comme ça. Cela impliquerait évidemment une gestion des erreurs autour de l'élément renommer, ce qui pourrait entraîner la perte de vos données d'entrée.