6.27. Input and output of Ruby files

6.27.1. puts statement #

In the previous section, you assigned a value to a variable and then used the puts statement printout.

puts statement instructs the program to display the value stored in the variable. This adds a new line at the end of each line.

#!/usr/bin/rubyval1="This is variable one"val2="This is variable two"putsval1putsval2 

This is variable one This is variable two 

6.27.2. gets statement #

gets statement can be used to get data from a file named STDIN the user input of the standard screen of

6.27.3. Example #

The following code demonstrates how to use the gets statement. The code will prompt the user for a value that will be stored in the variable val will eventually be printed in the STDOUT go.

#!/usr/bin/rubyputs"Enter a value :"val=getsputsval 

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

6.27.4. putc statement #

Different from the puts statement, puts statement outputs the entire string to the screen, while the putc statement can be used to output one character in turn.

6.27.5. Example #

The output of the following code is just characters H :

#!/usr/bin/rubystr="Hello Ruby!"putcstr 

H 

6.27.6. print statement #

print statement vs puts statement is similar. The only difference is that puts statement jumps to the next line after the output, using the print statement, the cursor is positioned on the same line.

#!/usr/bin/rubyprint"Hello World"print"Good Morning" 

Hello WorldGood Morning 

6.27.7. Open and close files #

As of now, you have read and written standard input and output. Now, we willlook at how to manipulate the actual data file.

6.27.8. File.new method #

You can use the File.new method to create a File object is used toread, write, or read and write, and the read and write permissions depend on the mode parameters. Finally, you can use the File.close methodto close the file.

aFile=File.new("filename","mode")#... process the file aFile.close 

6.27.9. File.open method #

You can use the File.open method to create a new file object and set the file object is assigned to the file. But, File.open and There is a slight difference between File.new methods. The difference isthat File.open method can be associated with a block, while the File.new the method can’t.

File.open("filename","mode")do\|aFile\|#... process the fileend 

The following table lists the different modes for opening files:

6.27.10. Read and write files #

The method for simple Icano can also be used for all file object. So, gets reads a row from standard input aFile.gets from file object aFile read a row.

However, the Imap O object provides additional settings for accessing methods, which makes it convenient for us.

6.27.11. sysread method #

You can use the method sysread to read the contents of the file. When using method sysread you can open the file in any mode. For example:

The following is the input text file:

This is a simple text file for testing purpose. 

Now let’s try to read this file:

#!/usr/bin/rubyaFile=File.new("input.txt","r")ifaFilecontent=aFile.sysread(20)putscontentelseputs"Unable to open file!"end 

6.27.12. syswrite method #

You can use the method syswrite to write to the file. When using method syswrite need to open the file in write mode. For example:

#!/usr/bin/rubyaFile=File.new("input.txt","r+")ifaFileaFile.syswrite("ABCDEF")elseputs"Unable to open file!"end 

6.27.13. each_byte Method #

This method belongs to the class File . each_byte method is an iterator that iterates over each character in a string. Take a look at the following code example:

#!/usr/bin/rubyaFile=File.new("input.txt","r+")ifaFileaFile.syswrite("ABCDEF")aFile.rewindaFile.each_byte{\|ch\|putcch;putc?. }elseputs"Unable to open file!"end 

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... 

6.27.14. IO.readlines method #

Class File is a subclass of the class IO. The class IO also has some methods for manipulating files.

IO.readlines is a method in the IO class. This method returns the contents of the file line by line. The following code shows the method IO.readlines use:

#!/usr/bin/rubyarr=IO.readlines("input.txt")putsarr[0]putsarr[1] 

6.27.15. IO.foreach method #

This method also returns output line by line. Method foreach and methods readlines . The difference between them is that the method foreach associated with a block. But, unlike the method, readlines , method foreach instead of returning an array. For example:

#!/usr/bin/rubyIO.foreach("input.txt"){\|block\|putsblock} 

6.27.16. Rename and delete files #

You can use the rename and delete method to rename and delete files.

The following example renames an existing file test1.txt :

#!/usr/bin/ruby# rename the file test1. txt to test2.txtFile.rename("test1.txt","test2.txt") 

#!/usr/bin/ruby# delete file test2.txtFile.delete("text2.txt") 

6.27.17. File mode and ownership #

Use masked chmod method to change the mode or permission / access list of the file:

The following example changes an existing file test.txt is a mask value

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

6.27.18. File query #

The following command checks whether the file already exists before opening it:

#!/usr/bin/rubyFile.open("file.rb")ifFile::exists?("file.rb") 

#!/usr/bin/ruby# return true or falseFile.file?("text.txt") 

#!/usr/bin/ruby# A directory File::directory?("/usr/local/bin")#=> true# A directory File::directory?("file.rb")#=> false 

#!/usr/bin/rubyFile.readable?("test.txt")#=> trueFile.writable?("test.txt")#=> trueFile.executable?("test.txt")#=> false 

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

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

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

#!/usr/bin/rubyFile::ctime("test.txt")#=> Fri May 09 10:06:37 -0700 2008File::mtime("text.txt")#=> Fri May 09 10:44:44 -0700 2008File::atime("text.txt")#=> Fri May 09 10:45:01 -0700 2008 

6.27.19. Directories in Ruby #

All files are contained in directories, and Ruby provides a way to deal withfiles and directories. File class is used to process files Dir class is used to process directories.

6.27.20. Browse the catalog #

To change the directory in the Ruby program, use the Dir.chdir . The following example changes the current directory to /usr/bin .

Dir.chdir("/usr/bin") 

You can use the Dir.pwd view the current directory:

putsDir.pwd# Return to the current directory, similar to /usr/bin 

You can use the Dir.entries get a list of files and directories in the specified directory:

putsDir.entries("/usr/bin").join('') 

Dir.entries returns an array of all items in the specified directory. Dir.foreach provides the same functionality:

Dir.foreach("/usr/bin")do\|entry\|putsentryend 

A more concise way to get a directory list is by using the Dir the method of the class array of

Dir["/usr/bin/*"] 

6.27.21. Create a directory #

Dir.mkdir can be used to create directories:

Dir.mkdir("mynewdir") 

You can also use the mkdir set permissions on the new directory (not anexisting directory):

Note: mask 755 sets owner (owner), group (group), everyone (world) [anyone] The permissions for) are rwxr-xr-x , of which r = read read, w =write write x = execute execute.

Dir.mkdir("mynewdir",755) 

6.27.22. Delete directory #

Dir.delete can be used to delete directories. Dir.unlink and Dir.rmdir are convenient for us to perform the same function.

Dir.delete("testdir") 

6.27.23. Create a file & temporary directory #

Temporary files are information that is simply created during program execution but is not permanently stored.

The Dir.tmpdir path to the temporary directory on the current system is provided, but this method is not available by default. In order to make Dir.tmpdir available, use the necessary 'tmpdir' is necessary.

You can put Dir.tmpdir and File.join to use together to create a temporary file independent of the platform:

require'tmpdir'tempfilename=File.join(Dir.tmpdir,"tingtong")tempfile=File.new(tempfilename,"w")tempfile.puts"This is a temporary file"tempfile.closeFile.delete(tempfilename) 

This code creates a temporary file, writes data to it, and then deletes the file. The standard library of Ruby also contains a library called Tempfile that can be used to create temporary files

require'tempfile'f=Tempfile.new('tingtong')f.puts"Hello"putsf.pathf.close 

6.27.24. Built-in function #

The following provides a complete list of built-in functions in Ruby that deal with files and directories:

• File classes and methods.

• Dir classes and methods.