Shulou(Shulou.com)06/02 Report--

This article is to share with you which module in nodejs provides file operation api, the editor thinks it is very practical, so I share it with you to learn. I hope you can get something after reading this article.

In nodejs, the file system module provides file manipulation api. File system module (referred to as fs module) allows users to access and interact with the file system on the computer; using fs module can achieve file and directory creation, write, delete and other operations.

This tutorial operating environment: windows7 system, nodejs version 12.19.0, DELL G3 computer.

One: how to read the contents of the whole file?

Note: reading and writing files may be boring, but every time I learn such an article, I always prepare for the next article, because the demo of my next article needs to use this knowledge, so I will record all the knowledge I need to understand.

In Node.js, use the fs module to create, write and delete all files and directories.

1. The method of reading the file:

When performing a file reading operation, you can use the readFile method and the readFileSync method to read the file. The words such as Sync are synchronous methods, while those without the words are asynchronous methods. The difference between synchronous methods and asynchronous methods is that synchronous methods immediately return the results of the operation. First, take a look at the relevant API:

1) readFileSync reads the file API synchronously

Use the method to read as follows:

Fs.readFileSync (filename, [options])

Filename parameter: used to specify the full file path and file name to read the file.

Options parameter: this value is an object, which can be used to specify what action to take when reading a file using the flag attribute. The default is' ritual. You can specify the following values:

'ringing: reads the file and throws an exception if the file does not exist.

'ringing arguments: read and write to the file, throwing an exception if the file does not exist.

'rs': synchronously reads the file and tells the operating system to ignore the cache of the local file system, and throws an exception if the file does not exist.

'wicked: writes to a file, creates it if it does not exist, and empties the contents of the file if it already exists.

'wicked reading: reading and writing files, other functions are the same as'w'.

'awrite: append to a file or create it if it does not exist.

'a written file: read and append to a file, and create a file if it doesn't exist.

In the options parameter, we can use the encoding attribute to specify which encoding format to use to read the file. The attribute value has' utf-8', 'ascii',' base64',. Let's take a look at the simple demo. As follows:

Let's take a look at the directory structure as follows:

# the directory structure is as follows: demo1 # project name | |-- readFile # the folder where the file is read | |-- index.html # html file | |-- index.js # Js file |-- package.json |-- node_modules

The following code reads the file code:

Const fs = require ('fs'); try {const data = fs.readFileSync ('. / index.html', 'utf-8'); / / wait for the result of the operation to return, then print the result console.log (data);} catch (e) {console.log (' error reading file');}

Execute node index.js on the command line and print the results as follows:

2) API is used to read files asynchronously as follows:

Fs.readFile (filename, [options], callback)

The parameters of the filename and options and synchronization methods are the same.

The callback parameter is a callback function that is executed after the file has been read. The following code is shown:

Const fs = require ('fs'); fs.readFile ('. / index.html', 'utf-8', (err, data) = > {if (err) {console.log (' error reading file');} else {console.log (data);}})

The result of the execution is the same as above. There is no screenshot here.

Second: how to write the contents of the whole file?

To write to the file, we use the writeFile method or the wirteFileSync method in the fs module. WriteFile is used as follows (the wirteFileSync method is similar, except that there is no callback parameter):

Fs.writeFile (filename, data, [options], callback)

The filename parameter specifies the full path and file name of the file to be written to.

The data parameter specifies what needs to be written, and the value can be a string or a Buffer object, and the contents of the string or buffer will be fully written to the file.

The options value is an object (optional) and the option name is flag, which has the following option values:

'The flag': is used to specify what action the file should take. The default value is' written', which means to write to the file. All values of the specified item are the same as the values of the readFile above.

(create the file when it does not exist, and overwrite the file when it exists).

'mode': this attribute is used to specify read and write permissions to a file when it is opened. The default value is 0666 (readable and writable). There are a lot of values that you can learn about by Baidu.

'encoding': is used to specify what encoding format to use to write to the file. Property values can be specified as' utf8', 'ascii',' base64'.

Callback: this parameter is used for the callback function that is executed when the file is read.

Let's simply do a demo, write code in the index.js file in our directory, create a message.txt file in that directory and write two lines of text. The code is as follows:

Const fs = require ('fs'); const str =' this is the first line. \ r\ nThis is the second line'; fs.writeFile ('. / message.txt', str, (err) = > {if (err) {console.log ('write file operation failed');} else {console.log ('write file operation succeeded');}})

Execute the command in the following figure:

A message.txt file is generated under the directory, as shown in the following figure

Then we open the file and see what it writes.

2) write the buffer object as follows:

Const fs = require ('fs'); const str = new Buffer (' I love programming'); fs.writeFile ('. / message.txt', str, (err) = > {if (err) {console.log ('write file operation failed');} else {console.log ('write file operation succeeded');}})

You can see the words'I love programming'in message.txt.

3) set the flag attribute options of options parameters, such as appending data, as shown in the following code:

Const fs = require ('fs'); const options = {flag:' a'}; fs.writeFile ('. / message.txt', 'this is the appended data', options, (err) = > {if (err) {console.log ('write file operation failed');} else {console.log ('write file operation succeeded');}})

Message.txt content programming is as follows: I love programming. This is additional data.

4) copy the picture file

We can use the readFile method to read a picture file in the corresponding directory of the application, use base64 encoding when reading the file, and use the writeFile method in the callback function, in which base64 coding is used to copy the read image file data to another picture file. The code is as follows:

Const fs = require ('fs'); fs.readFile ('. / images/1.png', 'base64', (err, data) = > {fs.writeFile ('. / images/xx.png', data.toString (), 'base64', (err) = > {if (err) {console.log (' write file operation failed');} else {console.log ('write file operation succeeded');});})

There is a 1.png under image, which will be copied and then written to xx.png (if the file does not exist before, the image file will be created).

Three: how to read the content at the specified location in the file?

3.1) Open the file open method or openSync method

To read the content at a specified location in the file, we first need to open the file, either the open method or the openSync method in the fs module. The open method is used as follows:

Fs.open (filename, flags, [mode], callback)

The first three parameters have the same meaning as the parameters of readFile. The last parameter is the callback function after the execution is completed. The callback function takes two arguments, the first is the error object that failed to open the file, and the second parameter is an integer value that represents the file descriptor returned when the file is opened.

Let's open the message.txt file we just created, as follows:

Const fs = require ('fs'); fs.open ('. / message.txt', 'ritual, (err, fd) = > {console.log (fd);})

The execution result is as follows:

3.2) read the file from the specified location

For example, after opening the file above, we can use the read method or readSync method in the fs module to read the file from the specified location in the callback function, or we can use the write method or writeSync method in the fs module to write data from the specified place in the file.

Fs.read (fd, buffer, offset, length, position, callback)

The fd parameter is the file descriptor returned by the above open open file.

The buffer parameter is a buffer object that specifies which cache the file data will be read into.

Offset: used to specify where to start writing data to the buffer.

Length: used to specify the number of bytes read from the file.

Position: used to specify where to start when reading the file.

Callback: used to specify the callback function when the file operation is completed. As follows:

Function (err, bytesRead, buffer) {}

Err: the error object when the operation fails.

BytesRead: represents the number of bytes actually read.

Buffer: the buffer object that is read.

Let's take a look at the demo code as follows:

Const fs = require ('fs'); / / message.txt content is as follows: I like programming this is the appended data fs.open ('. / message.txt', 'rDNA, (err, fd) = > {const buf = new Buffer (255); / / the utf of a Chinese character is encoded as three bytes of data fs.read (fd, buf, 0,9,3, (err, bytesRead, buffer) = > {console.log (buffer.slice (0, bytesRead). ToString ()) / / favorite editor});})

As the above code message.txt content is: I like programming this is the additional data, position is 3, read the file from the third byte, and then the length is 9 bytes, a Chinese character 3 bytes, so the result is' love editor'

Fourth: how to write content at a specified location in the file?

After the file is opened, you can use the write method or the writeSync method in the fs module to read data from a cache and write it from a specified location in the file. The usage is as follows:

Fs.write (fd, buffer, offset, length, position, callback)

The fd parameter is a descriptor.

The buffer parameter is a Buffer object that specifies the cache from which the data is read.

The offset parameter is used to specify where to start reading data from the cache.

The length parameter is used to specify the number of bytes read from the cache.

The position parameter value is used to specify where to start when writing to the file.

The callback parameter is used to specify the callback function when the file write operation completes. The callback function is as follows:

Function (err, written, buffer) {}

The err parameter is the error object when the write fails.

Written: represents the number of bytes written.

Buffer: represents the buffer object being read.

Here is a simple demo, as follows:

Const fs = require ('fs'); const buf = new Buffer (' I love programming'); fs.open ('. / message.txt', 'wicked, (err, fd) = > {fs.write (fd, buf, 3,9,0, (err, written, buffer) = > {if (err) {console.log ('write file operation failed');} else {console.log ('write file operation succeeded');}}) });

Make up these three words for love in message.txt.

Five: how to create and read directories?

Create directory mkdir and mkdirSync methods

In the fs module, you can use the mkdir method to create a directory, which is used as follows:

Fs.mkdir (path, [mode], callback)

The path parameter is used to specify the full path and directory name of the directory to be created.

The mode parameter is used to specify permissions for the directory, with a default value of 0777 (meaning that anyone can read and write to the directory).

Callback is a callback function.

Here is a simple demo, as follows:

Const fs = require ('fs'); fs.mkdir ('. / test', (err) = > {if (err) {console.log ('creation directory operation failed');} else {console.log ('directory creation operation succeeded');}})

As follows:

5.2) read directory readdir and readdirSync methods

In the fs module, use the readdir method to read the directory, which uses the following

Fs.readdir (path, callback)

The path parameter is used to specify the full path and directory name of the directory to be read.

The callback parameter is used to specify the callback function for the read directory operation. The callback function is as follows:

Function (err, file) {}

Err is a callback function that failed to read the directory.

The file parameter value is an array that reads all the file names in the file.

As shown in the following demo:

Const fs = require ('fs'); fs.readdir ('. /', (err, files) = > {if (err) {console.log ('failed to read directory operation');} else {console.log (files);}})

As shown in the following figure:

Six: how to view and modify the information of files or directories?

6.1) View information about a file or directory

In the fs module, you can use the stat method or the lstat method to view information about a file or directory. The only difference between the two methods is that when viewing the information in the symbolic link file

The lstat method must be used. The usage is as follows:

Fs.stat (path, callback); fs.lstat (path, callback)

The path parameter is used for the full path and file name or directory name of the file or directory being viewed.

Callback is a callback function. The following callback function

Function (err, stats) {}

The value of the err parameter is the error object that is triggered when the operation to view file or directory information fails.

The value of the stats parameter is a fs.Stats object, which has the following methods that do not contain any parameters.

IsFile: used to determine whether the object being viewed is a file. If so, return true, otherwise return false.

IsDirectory: used to determine whether the object being viewed is a directory. If so, return true, otherwise return false.

There are many other methods, one by one here is not introduced, the use of less, if necessary, you can have a look at Baidu.

Using demo using stat, check the message.txt file in the root directory of the application and what is the output of the second parameter value fs.Stats object in the callback function in the console?

Const fs = require ('fs'); fs.stat ('. / message.txt', (err, stats) = > {console.log (stats);})

As shown in the following figure:

6.2) check for exists and existsSync methods in a file or directory

In the fs module, you can check for the existence of a file or directory using the exists method, which is used as follows:

Fs.exists (path, callback)

Path parameter: used to specify the full path to the file or directory that needs to be checked.

Callback: is a callback function, which is as follows:

Function (exists) {}

The exists parameter, which is true when a file or directory exists, otherwise it is false.

Here is a simple demo, as shown in the following code:

Const fs = require ('fs'); / / the directory exists fs.exists ('. / message.txt', (exists) = > {console.log (exists); / / true}); / / the directory does not exist fs.exists ('. / message2.txt', (exists) = > {console.log (exists); / / false})

6.3) realpath and realpathSync methods to get the absolute path of a file or directory

In the fs module, you can use the realpath method to get the absolute path to a file or directory, which uses the following:

Fs.realpath (path, [cache], callback)

The cache parameter is optional, and path and callback are required.

The path parameter is the full path to the file or directory that needs to be viewed.

The cache parameter is an object that holds some pre-specified paths. Under the specific Baidu, this parameter is not used much.

Callback is a callback function, which takes two parameters, and the err parameter value is the error object that failed to get the absolute path of the directory. The resolvedPath parameter value is to get the

The absolute path to the file or directory to.

Here is a simple demo, as follows:

Const fs = require ('fs'); fs.realpath ('. / message.txt', (err, resolvedPath) = > {if (err) {throw err;} else {console.log (resolvedPath);}})

Perform as follows:

6.4) use ReadStream objects to read files

In the fs module, you can use the createReadStream method to create a ReadStream object that reads the contents of the file as streaming data, using the following method:

Fs.createReadStream (path, [options])

Path this parameter is used to specify the full path and file name of the file to be read.

Options is an object that has the following properties:

Flags: used to specify what action to take on the file. The default value is' ractions, which is the same as the flags property in the readFile method.

Encoding: specifies what encoding to use to read the file, but the value specified is' utf8', 'ascii',' base64'. The default value is null.

Start: specifies the start reading location of the file.

End: specifies the end read location of the file.

There are many other parameters, here do not explain one by one, you can do it under Baidu.

Here's a simple demo to understand how to use: the following code:

Const fs = require ('fs'); / * A Chinese character has three bytes, and the content of message.txt is: I like to write code, so I like to write code from the third position to the twelfth position, so the data should be written for favorite * / const options = {start: 3, end: 12}; const file = fs.createReadStream ('. / message.txt', options) File.on ('open', (fd) = > {console.log (' start reading file'); file.on ('data', (data) = > {console.log (' data read:'+ data);}); file.on ('end', () = > {console.log (' all files have been read');}); file.on ('close', () = > {console.log (' file closed');}) File.on ('error', (err) = > {console.log (' failed to read the file');})

As shown in the following figure:

We can use the pause method of the ReadStream object to pause the firing of the data event, which also means stopping the read operation of the file. The data in the operating system cache that has been read will also be temporarily saved in the operating system buffer. After using the pause method to pause the trigger of the data event, you can also use the resume method of the ReadStream object to restore the trigger of the data event, which means you can continue to read the data of the file.

The following demo:

Const fs = require ('fs'); const readStream = fs.createReadStream ('. / message.txt'); readStream.pause (); readStream.on ('data', (data) = > {console.log (' the data obtained is:'+ data);}); setTimeout () = > {readStream.resume ();}, 1000)

During the reading process, after listening for a second, the data continued to be read out.

Note: the method of writing to a file is WriteStream, which is similar to the way it is read, which is not covered here.

The above is which module of nodejs provides file operation api, the editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.