用Ruby在文件前添加一行

我想用Ruby在文件的顶部添加一行:

# initial file contents
something
else
# file contents after prepending "hello" on its own line
hello
something
else

下面的代码只是替换整个文件的内容:

f = File.new('myfile', 'w')
f.write "test string"

这是一个非常常见的任务:

original_file = './original_file'
new_file = original_file + '.new'

设置测试:

File.open(original_file, 'w') do |fo|
  %w[something else].each { |w| fo.puts w }
end

这是实际代码:

File.open(new_file, 'w') do |fo|
  fo.puts 'hello'
  File.foreach(original_file) do |li|
    fo.puts li
  end
end

将旧文件重命名为安全文件:

File.rename(original_file, original_file + '.old')
File.rename(new_file, original_file)

显示它可以工作:

puts `cat #{original_file}`
puts '---'
puts `cat #{original_file}.old`

输出:

hello
something
else
---
something
else

你不想尝试将文件完全加载到内存中。这将工作，直到你得到一个比你的RAM分配更大的文件，机器开始爬行，或者更糟，崩溃。

应该逐行读取。读取单行仍然非常快，并且是可扩展的。您的驱动器上必须有足够的空间来存储原始文件和临时文件。

这似乎可以工作:

#!usr/bin/ruby
f = File.open("myfile", "r+")
lines = f.readlines
f.close
lines = ["somethingn"] + lines
output = File.new("myfile", "w")
lines.each { |line| output.write line }
output.close

我想到了这样的东西，它比我见过的其他解决方案更具描述性，更不晦涩:

def file_prepend(file, str)
  new_contents = ""
  File.open(file, 'r') do |fd|
    contents = fd.read
    new_contents = str << contents
  end
  # Overwrite file but now with prepended string on it
  File.open(file, 'w') do |fd| 
    fd.write(new_contents)
  end
end

你可以这样使用:

file_prepend("target_file.txt", "hello world!n")

就像有些人说的，可能不要在较大的文件中使用这个，但这是一个简单的开始。

rd = IO.read 'myfile'
IO.write 'myfile', "hellon" + rd

没有一种机制可以让你轻松地完成你想做的事情。

相反，您需要打开文件，删除文件，以旧名称打开新文件进行写入，写入您的内容，然后从旧文件的内容写入新文件。这听起来很复杂，但在代码中很简单:

$ cat prepend.rb 
#!/usr/bin/ruby
File.open("passwd", "r") do |orig|
    File.unlink("passwd")
    File.open("passwd", "w") do |new|
        new.write "test string"
        new.write(orig.read())
    end
end

请注意，我使用的机制不需要检查错误——您可能应该处理每个File.open()请求和File.unlink()请求的错误——并且它假设文件的整个内容都适合内存。一个简短的例子:

$ rm passwd
$ cp /etc/passwd .
$ ./prepend.rb 
$ head passwd
test stringroot:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
lp:x:7:7:lp:/var/spool/lpd:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
$

如果你想处理不完全适合内存的文件，你应该像这样编写一个循环(未经测试——最好认为它是伪代码):

while (data=orig.read(4096)) {
    new.write(data)
}

作为一种替代方法，您可以写入临时文件，如果写入过程成功，则然后删除该文件并在适当的位置重命名临时文件。

你可以试试:

File.copy_stream(myfile,tempfile)
f = File.open(myfile,'w')
f.write("Hellon#{File.open(tempfile,'r').read}")
f.close
File.delete(tempfile)

在命令行中，您可以这样做:

ruby -i -pe '$_= "prepended textn"+$_ if $. == 1' myfile

或更有效

ruby -i -pe 'BEGIN { gets; print "prepended textn" + $_ }; ' myfile

遗憾的是，事实证明，-i(就地)选项并不是真正的就地(sed的就地选项也不是)—我的文件在op之后将有一个不同的索引节点。

这让我很难过，因为如果我没有足够的磁盘空间来存放两个副本，我就无法过滤(前置)一个大文件。

在适当的位置执行它并不困难(一般来说是过滤，而不仅仅是过滤第一行)。你所需要做的就是:

1)确保你有单独的读和写指针(或者单独的File对象用于读和写)2)确保你已经缓冲了你将要重写的未读部分3)如果你的过滤操作应该以一个更短的文件

结束，截断到file

我在https://github.org/pjump/i_rewriter为它写了一个包装类。

有了它，你可以做

Rewriter.new("myfile") do |line, index|
  index == 0 ? "prepended textn" + line : line
end

或与可执行文件:

$  i_rewriter 'index == 0 ? "prepended textn" + line : line' myfile

小心使用(如果中断的话可能会损坏你的文件)。

纯，但有效。最小化与文件相关的操作。

`#!/bin/ruby
inv_file = File.open("./1.txt","r+") { |f|
    #Read file string by-string
    until f.eof?
        #Searching for some
        if f.readline[/condition here/]
            #remember position
            offset = f.pos
            #Find it? - stop reading
            break
        end
    end
    #Remember what contains rest of file
    tail = f.readlines
    #Again to offset
    f.pos = offset
    #insert what necessary
    f.puts "INSERTED"
    #reconstruct tail
    f.write tail.join
    }`

相关内容

最新更新

热门标签：