Opens the file named byfilename.

mode must be one of the following file open modes:

Mode       | Description
-----------+------------------------------------------------------
r rb       | Read-only, starts at the beginning of the file.
r+ r+b rb+ | Read-write, starts at the beginning of the file.
w wb       | Write-only, truncates existing file to zero length or
           | creates a new file if the file doesn't exist.
w+ w+b wb+ | Read-write, truncates existing file to zero length or
           | creates a new file if the file doesn't exist.
a ab       | Write-only, all writes seek to the end of the file,
           | creates a new file if the file doesn't exist.
a+ a+b ab+ | Read-write, all writes seek to the end of the file,
           | creates a new file if the file doesn't exist.

Line endings are preserved on all platforms. Theb mode flag has no effect; it is provided only for POSIX compatibility.

NOTE Theblocking arg is deprecated since Crystal 1.17. It used to be true by default to denote a regular disk file (always ready in system event loops) and could be set to false when the file was known to be a fifo, pipe, or character device (for example/dev/tty). The event loop now chooses the appropriate blocking mode automatically and there are no reasons to change it anymore.

NOTE On macOS files are always opened in blocking mode because non-blocking FIFO files don't work — the OS exhibits issues with readiness notifications.

DEPRECATED parameterblocking

Opens the file named byfilename. If a file is being created, its initial permissions may be set using theperm parameter.

Seeself.new for whatmode can be.

DEPRECATED parameterblocking

Returns the last component of the givenpath.

Ifsuffix is present at the end ofpath, it is removed.

File.basename("/foo/bar/file.cr", ".cr") # => "file"

Returns the last component of the givenpath.

File.basename("/foo/bar/file.cr") # => "file.cr"

Changes the permissions of the specified file.

Symlinks are dereferenced, so that only the permissions of the symlink destination are changed, never the permissions of the symlink itself.

File.chmod("foo", 0o755)
File.info("foo").permissions.value # => 0o755

File.chmod("foo", 0o700)
File.info("foo").permissions.value # => 0o700

Use#chmod if theFile is already open.

Changes the owner of the specified file.

File.chown("/foo/bar/baz.cr", 1001, 100)
File.chown("/foo/bar", gid: 100)

Unlessfollow_symlinks is set totrue, then the owner symlink itself will be changed, otherwise the owner of the symlink destination file will be changed. For example, assuming symlinks asfoo -> bar -> baz:

File.chown("foo", gid: 100)                        # changes foo's gid
File.chown("foo", gid: 100, follow_symlinks: true) # changes baz's gid

Use#chown if theFile is already open.

Copies the filesrc to the filedst. Permission bits are copied too.

File.touch("afile")
File.chmod("afile", 0o600)
File.copy("afile", "afile_copy")
File.info("afile_copy").permissions.value # => 0o600

Deletes the file atpath. RaisesFile::Error on failure.

On Windows, this also deletes reparse points, including symbolic links, regardless of whether the reparse point is a directory.

File.write("foo", "")
File.delete("./foo")
File.delete("./bar") # raises File::NotFoundError (No such file or directory)

Deletes the file atpath, or returnsfalse if the file does not exist. RaisesFile::Error on other kinds of failure.

On Windows, this also deletes reparse points, including symbolic links, regardless of whether the reparse point is a directory.

File.write("foo", "")
File.delete?("./foo") # => true
File.delete?("./bar") # => false

Returnstrue if the givenpath exists and is a directory.

File.write("foo", "")
Dir.mkdir("dir2")
File.directory?("foo")    # => false
File.directory?("dir2")   # => true
File.directory?("foobar") # => false

Returns all components of the givenpath except the last one.

File.dirname("/foo/bar/file.cr") # => "/foo/bar"

Yields each line infilename to the given block.

File.write("foobar", "foo\nbar")

array = [] of String
File.each_line("foobar") do |line|
  array << line
end
array # => ["foo", "bar"]

DEPRECATED parameterblocking

Returnstrue if the file atpath is empty, otherwise returnsfalse. RaisesFile::NotFoundError if the file atpath does not exist.

File.write("foo", "")
File.empty?("foo") # => true
File.write("foo", "foo")
File.empty?("foo") # => false

Returnstrue ifpath is executable by the real user id of this process else returnsfalse.

File.write("foo", "foo")
File.executable?("foo") # => false

DEPRECATED UseFile::Info.executable? instead

Returns whether the file given bypath exists.

Symbolic links are dereferenced, possibly recursively. Returnsfalse if a symbolic link refers to a non-existent file.

File.delete("foo") if File.exists?("foo")
File.exists?("foo") # => false
File.write("foo", "foo")
File.exists?("foo") # => true

Convertspath to an absolute path. Relative paths are referenced from the current working directory of the process unless dir is given, in which case it will be used as the starting point. "~" is expanded to the value passed tohome. If it isfalse (default), home is not expanded. Iftrue, it is expanded to the user's home directory (Path.home).

File.expand_path("foo")                 # => "/home/.../foo"
File.expand_path("~/foo", home: "/bar") # => "/bar/foo"
File.expand_path("baz", "/foo/bar")     # => "/foo/bar/baz"

Returnsfilename's extension, or an empty string if it has no extension.

File.extname("foo.cr") # => ".cr"

Returnstrue if givenpath exists and is a file.

File.write("foo", "")
Dir.mkdir("dir1")
File.file?("foo")    # => true
File.file?("dir1")   # => false
File.file?("foobar") # => false

Returns aFile::Info object for the file given bypath or raises File::Error in case of an error.

Iffollow_symlinks is set (the default), symbolic links are followed. Otherwise, symbolic links return information on the symlink itself.

File.write("foo", "foo")
File.info("foo").size              # => 3
File.info("foo").modification_time # => 2015-09-23 06:24:19Z

File.symlink("foo", "bar")
File.info("bar", follow_symlinks: false).type.symlink? # => true

UseIO::FileDescriptor#info if the file is already open.

Returns aFile::Info object for the file given bypath or returnsnil if the file does not exist.

Iffollow_symlinks is set (the default), symbolic links are followed. Otherwise, symbolic links return information on the symlink itself.

File.write("foo", "foo")
File.info?("foo").try(&.size) # => 3
File.info?("non_existent")    # => nil

File.symlink("foo", "bar")
File.info?("bar", follow_symlinks: false).try(&.type.symlink?) # => true

UseIO::FileDescriptor#info if the file is already open.

Returns a new string formed by joining the strings usingFile::SEPARATOR.

File.join({"foo", "bar", "baz"})       # => "foo/bar/baz"
File.join({"foo/", "/bar/", "/baz"})   # => "foo/bar/baz"
File.join(["/foo/", "/bar/", "/baz/"]) # => "/foo/bar/baz/"

Returns a new string formed by joining the strings usingFile::SEPARATOR.

File.join("foo", "bar", "baz")       # => "foo/bar/baz"
File.join("foo/", "/bar/", "/baz")   # => "foo/bar/baz"
File.join("/foo/", "/bar/", "/baz/") # => "/foo/bar/baz/"

Creates a new link (also known as a hard link) atnew_path to an existing file given byold_path.

Matchespath againstpattern.

The pattern syntax is similar to shell filename globbing. It may contain the following metacharacters:

• *: Wildcard matches zero or more characters, except for directory separators.
• **: Globstar matches zero or more characters, including directory separators. It must match a complete path segment, i.e. it must be wrapped in/ except for the beginning and end of the pattern.
• ?: Matches a single Unicode character, except for directory separators.
• Character classes:
  • [abc]: Character set matches one of the Unicode characters contained in the brackets.
  • [^abc]: Negated character set matches any Unicode characterexcept those contained in the brackets.
  • [a-z]: Character range matches one Unicode character contained in the character range.
  • [^a-z]: Negated character range matches one Unicode characterexcept those contained in the character range.
• {a,b}: Branches matches one of the subpatterns contained in the braces. Subpatterns may contain any other pattern feature, including nested branches (max nesting depth is 10 levels deep).
• \\: Backslash escapes the next character.

Multiple character pattern can be combined in the same brackets to define a character class (for example:[0-9a-f]).

Ifpath is aPath, all directory separators supported bypath are recognized, according to the path's kind. Ifpath is aString, only/ is considered a directory separator.

NOTE Only/ inpattern matches directory separators inpath.

Opens the file named byfilename. If a file is being created, its initial permissions may be set using theperm parameter. Then given block will be passed the opened file as an argument, the file will be automatically closed when the block returns.

Seeself.new for whatmode can be.

DEPRECATED parameterblocking

Returns the content offilename as a string.

RaisesFile::Error if the file cannot be read.

File.write("bar", "foo")
File.read("bar") # => "foo"

File.read("non-existent") # raises File::NotFoundError

DEPRECATED parameterblocking

Returns all lines infilename as an array of strings.

File.write("foobar", "foo\nbar")
File.read_lines("foobar") # => ["foo", "bar"]

DEPRECATED parameterblocking

Returnstrue ifpath is readable by the real user id of this process else returnsfalse.

File.write("foo", "foo")
File.readable?("foo") # => true

DEPRECATED UseFile::Info.readable? instead

Returns the target of a symbolic link.

Returns the target of a symbolic link.

Returnsnil ifpath does not exist or is not a symbolic link.

Resolves the real path ofpath by following symbolic links.

DEPRECATED Use.realpath instead.

Resolves the real path ofpath by following symbolic links.

Movesold_filename tonew_filename.

File.write("afile", "foo")
File.exists?("afile") # => true

File.rename("afile", "afile.cr")
File.exists?("afile")    # => false
File.exists?("afile.cr") # => true

Returnstrue ifpath1 andpath2 represents the same file. The comparison take symlinks in consideration iffollow_symlinks istrue.

Compares two filesfilename1 tofilename2 to determine if they are identical. Returnstrue if content are the same,false otherwise.

File.write("file.cr", "1")
File.write("bar.cr", "1")
File.same_content?("file.cr", "bar.cr") # => true

Returns the size of the file atfilename in bytes. RaisesFile::NotFoundError if the file atfilename does not exist.

File.size("foo") # raises File::NotFoundError
File.write("foo", "foo")
File.size("foo") # => 3

Creates a symbolic link atnew_path to an existing file given byold_path.

Returnstrue if thepath is a symbolic link.

Creates a temporary file.

tempfile = File.tempfile("foo", ".bar")
tempfile.delete

prefix andsuffix are appended to the front and end of the file name, respectively.

NOTE These path values may contain directory separators. It's the caller's responsibility to ensure they are used safely. For example by rejecting user-provided values that would result in navigating the directory tree.

The file will be placed indir which defaults to the standard temporary directoryDir.tempdir.

encoding andinvalid are passed toIO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

Creates a temporary file.

tempfile = File.tempfile(".bar")
tempfile.delete

prefix andsuffix are appended to the front and end of the file name, respectively.

NOTE These path values may contain directory separators. It's the caller's responsibility to ensure they are used safely. For example by rejecting user-provided values that would result in navigating the directory tree.

The file will be placed indir which defaults to the standard temporary directoryDir.tempdir.

encoding andinvalid are passed toIO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

Creates a temporary file and yields it to the given block. It is closed and returned at the end of this method call.

tempfile = File.tempfile("foo", ".bar") do |file|
  file.print("bar")
end
File.read(tempfile.path) # => "bar"
tempfile.delete

prefix andsuffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The file will be placed indir which defaults to the standard temporary directoryDir.tempdir.

encoding andinvalid are passed toIO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

Creates a temporary file and yields it to the given block. It is closed and returned at the end of this method call.

tempfile = File.tempfile(".bar") do |file|
  file.print("bar")
end
File.read(tempfile.path) # => "bar"
tempfile.delete

prefix andsuffix are appended to the front and end of the file name, respectively.

NOTE These path values may contain directory separators. It's the caller's responsibility to ensure they are used safely. For example by rejecting user-provided values that would result in navigating the directory tree.

The file will be placed indir which defaults to the standard temporary directoryDir.tempdir.

encoding andinvalid are passed toIO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

Returns a fully-qualified path to a temporary file. The file is not actually created on the file system.

File.tempname("foo", ".sock") # => "/tmp/foo20171206-1234-449386.sock"

prefix andsuffix are appended to the front and end of the file name, respectively.

NOTE These path values may contain directory separators. It's the caller's responsibility to ensure they are used safely. For example by rejecting user-provided values that would result in navigating the directory tree.

The path will be placed indir which defaults to the standard temporary directoryDir.tempdir.

Returns a fully-qualified path to a temporary file. The optionalsuffix is appended to the file name.

File.tempname          # => "/tmp/20171206-1234-449386"
File.tempname(".sock") # => "/tmp/20171206-1234-449386.sock"

Attempts to set the access and modification times of the file named in thefilename parameter to the value given intime.

If the file does not exist, it will be created.

Use#touch if theFile is already open.

Sets the access and modification times offilename.

Use#utime if theFile is already open.

Returnstrue ifpath is writable by the real user id of this process else returnsfalse.

File.write("foo", "foo")
File.writable?("foo") # => true

DEPRECATED UseFile::Info.writable? instead

Writes the givencontent tofilename.

By default, an existing file will be overwritten.

filename will be created if it does not already exist.

File.write("foo", "bar")
File.write("foo", "baz", mode: "a")

NOTE If the content is aSlice(UInt8), those bytes will be written. If it's anIO, all bytes from theIO will be written. Otherwise, the string representation ofcontent will be written (the result of invokingto_s oncontent).

Seeself.new for whatmode can be.

DEPRECATED parameterblocking

Changes the permissions of the specified file.

file.chmod(0o755)
file.info.permissions.value # => 0o755

file.chmod(0o700)
file.info.permissions.value # => 0o700

Changes the owner of the specified file.

file.chown(1001, 100)
file.chown(gid: 100)

Deletes this file.

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

Yields anIO to read a section inside this file. Multiple sections can be read concurrently.

Rename the currentFile

Returns the size in bytes of the currently opened file.

Attempts to set the access and modification times to the value given intime.

Truncates the file to the specifiedsize. Requires that the current file is opened for writing.

Sets the access and modification times