How to write to file in Ruby?

Are you looking for the following?

File.open(yourfile, 'w') { |file| file.write("your text") } 

You can use the short version:

File.write('/path/to/file', 'Some glorious content') 

It returns the length written; see ::write for more details and options.

To append to the file, if it already exists, use:

File.write('/path/to/file', 'Some glorious content', mode: 'a') 

This is preferred approach in most cases:

 File.open(yourfile, 'w') { |file| file.write("your text") } 

When a block is passed to File.open, the File object will be automatically closed when the block terminates.

If you don't pass a block to File.open, you have to make sure that file is correctly closed and the content was written to file.

begin file = File.open("/tmp/some_file", "w") file.write("your text") rescue IOError => e #some error occur, dir not writable etc. ensure file.close unless file.nil? end 

You can find it in documentation:

static VALUE rb_io_s_open(int argc, VALUE *argv, VALUE klass) { VALUE io = rb_class_new_instance(argc, argv, klass); if (rb_block_given_p()) { return rb_ensure(rb_yield, io, io_close, io); } return io; } 

Zambri's answer found here is the best.

File.open("out.txt", '<OPTION>') {|f| f.write("write your stuff here") } 

where your options for <OPTION> are:

r - Read only. The file must exist.

w - Create an empty file for writing.

a - Append to a file.The file is created if it does not exist.

r+ - Open a file for update both reading and writing. The file must exist.

w+ - Create an empty file for both reading and writing.

a+ - Open a file for reading and appending. The file is created if it does not exist.

In your case, w is preferable.

For those of us that learn by example...

Write text to a file like this:

IO.write('/tmp/msg.txt', 'hi') 

BONUS INFO ...

Read it back like this

IO.read('/tmp/msg.txt') 

Frequently, I want to read a file into my clipboard ***

Clipboard.copy IO.read('/tmp/msg.txt') 

And other times, I want to write what's in my clipboard to a file ***

IO.write('/tmp/msg.txt', Clipboard.paste) 

*** Assumes you have the clipboard gem installed

See: https://rubygems.org/gems/clipboard

To destroy the previous contents of the file, then write a new string to the file:

open('myfile.txt', 'w') { |f| f << "some text or data structures..." } 

To append to a file without overwriting its old contents:

open('myfile.txt', "a") { |f| f << 'I am appended string' } 

While this answer has many variants of opening a file and writing to it from a block there is no answer of how someone who came from C or Perl or Python might do it in a familiar way.

In the block variant, all the text written or read needs to be local to the block. The file is opened, written to, and closed in one block of code:

File.open('/tmp/test.txt', 'w'){|f| f << "Living the block life"} # closed automatically at the end # the file handle is no longer available 

In C, you would open a file this way:

FILE* fptr; fptr = fopen("/tmp/test.txt", "w"); if (fptr == NULL) { printf(error_msg); exit(-1); } # continue with your file # close when done. IMPORTANT because C can buffer and lose data if not closed fclose(fptr) 

In Perl, kinda similar:

open(FH, '>', '/tmp/test.txt') or die $!; # ^ this is write # you need to close FH explicitly 

In Python, you can have both C style open / use / explicit close:

f = open("/tmp/test.txt", "w") # can write to f but you need to close f explicitly f.close() 

Python also has with blocks that are similar to Ruby's block open / explicit close:

with open("/tmp/test.txt", "w") as f: # do your writing # when f goes out of scope, at the bottom file is automatically closed 

If you want C style file open / explicit close in Ruby:

f=File.open('/tmp/test.txt', 'w') # If that cannot be opened, Ruby's default behavior is equivalent # to Perl's open(FH, '>', '/tmp/test.txt') or die $!; # File.open errors can be rescued also # f needs to be explicitly closed like so: f.close 

Why would you want this? Suppose you have:

f=File.open('/tmp/test.txt', 'w') # rescue if used # ... # Things that don't fit in a block that need that file f.puts(something) # ... f.close