File Management

NOTE
The initial APIs of this module are supported since API version 6. Newly added APIs will be marked with a superscript to indicate their earliest API version.

Modules to Import

import fileio from '@ohos.fileio';

Required Permissions

None

Guidelines

Before using this module to perform operations on a file or directory, obtain the absolute path of the file or directory. For details, see getOrCreateLocalDir of the Context module.

Absolute file or directory path = Application directory + File name or directory name

For example, if the application directory obtained by using getOrCreateLocalDir is dir and the file name is xxx.txt, the absolute path of the file is as follows:

let path = dir + "/xxx.txt";

The file descriptor is as follows:

let fd = fileio.openSync(path);

fileio.stat

stat(path: string): Promise<Stat>

Asynchronously obtains file information. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.stat(path).then(function(stat){
      console.info("getFileInfo successfully:"+ JSON.stringify(stat));
  }).catch(function(err){
      console.info("getFileInfo failed with error:"+ err);
  });
  

fileio.stat

stat(path:string, callback:AsyncCallback<Stat>): void

Asynchronously obtains file information. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.stat(path, function (err, stat) {
      // Example code in Stat
  });
  

fileio.statSync

statSync(path:string): Stat

Synchronously obtains file information.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let stat = fileio.statSync(path);
  // Example code in Stat
  

fileio.opendir

opendir(path: string): Promise<Dir>

Asynchronously opens a directory. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.opendir(path).then(function(dir){
      console.info("opendir successfully:"+ JSON.stringify(dir));
  }).catch(function(err){
      console.info("opendir failed with error:"+ err);
  });
  

fileio.opendir

opendir(path: string, callback: AsyncCallback<Dir>): void

Asynchronously opens a directory. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.opendir(path, function (err, dir) { 
      // Example code in Dir struct
      // Use read/readSync/close.
  });
  

fileio.opendirSync

opendirSync(path: string): Dir

Synchronously opens a directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let dir = fileio.opendirSync(path);
  // Example code in Dir struct
  // Use read/readSync/close.
  

fileio.access

access(path: string, mode?: number): Promise<void>

Asynchronously checks whether the current process can access a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.access(path).then(function() {
      console.info("access successfully");
  }).catch(function(err){
      console.info("access failed with error:"+ err);
  });
  

fileio.access

access(path: string, mode: number, callback: AsyncCallback<void>): void

Asynchronously checks whether the current process can access a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.access(path, function (err) {
      // Do something.
  });
  

fileio.accessSync

accessSync(path: string, mode?: number): void

Synchronously checks whether the current process can access the specified file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  try {
      fileio.accessSync(path);
  } catch(err) {
      console.info("accessSync failed with error:"+ err);
  }
  

fileio.close⁷⁺

close(fd: number):Promise<void>

Asynchronously closes a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path);
  fileio.close(fd).then(function(){
      console.info("close file successfully");
  }).catch(function(err){
      console.info("close file failed with error:"+ err);
  });
  

fileio.close⁷⁺

close(fd: number, callback:AsyncCallback<void>): void

Asynchronously closes a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let fd = fileio.openSync(path);
  fileio.close(fd, function (err) {
      // Do something.
  });
  

fileio.closeSync

closeSync(fd: number): void

Synchronously closes a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.closeSync(fd);
  

fileio.close⁷⁺

close(): Promise<void>

Asynchronously closes the stream. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  fileio.close().then(function(){
      console.info("close file stream successfully");
  }).catch(function(err){
      console.info("close file stream failed with error:"+ err);
  });
  

fileio.close⁷⁺

close(callback: AsyncCallback<void>): void

Asynchronously closes the stream. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.close(function(err){
      // Do something.
  });
  

fileio.copyFile

copyFile(src:string | number, dest:string | number, mode?:number):Promise<void>

Asynchronously copies a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.copyFile(src, dest).then(function(){
      console.info("copyFile successfully");
  }).catch(function(err){
      console.info("copyFile failed with error:"+ err);
  });
  

fileio.copyFile

copyFile(src: string | number, dest: string | number, mode: number, callback: AsyncCallback<void>): void

Asynchronously copies a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.copyFile(src, dest, function (err) {
      // Do something.
  });
  

fileio.copyFileSync

copyFileSync(src: string | number, dest: string | number, mode?: number): void

Synchronously copies a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.copyFileSync(src, dest);
  

fileio.mkdir

mkdir(path:string, mode?: number): Promise<void>

Asynchronously creates a directory. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.mkdir(path).then(function() {
      console.info("mkdir successfully");
  }).catch(function (error){
      console.info("mkdir failed with error:"+ error);
  });
  

fileio.mkdir

mkdir(path: string, mode: number, callback: AsyncCallback<void>): void

Asynchronously creates a directory. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.mkdir(path, function(err) {
    console.info("mkdir successfully");
  });
  

fileio.mkdirSync

mkdirSync(path: string, mode?: number): void

Synchronously creates a directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.mkdirSync(path);
  

fileio.open⁷⁺

open(path: string, flags?: number, mode?: number): Promise<number>

Asynchronously opens a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.open(path, 0o1, 0o0200).then(function(number){
      console.info("open file successfully");
  }).catch(function(error){
      console.info("open file failed with error:"+ err);
  });
  

fileio.open⁷⁺

open(path: string, flags: number, mode: number, callback: AsyncCallback<number>): void

Asynchronously opens a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.open(path, 0, function(err, fd) {
      // Do something.
  });
  

fileio.openSync

openSync(path:string, flags?:number, mode?:number): number

Synchronously opens a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path);
  

fileio.read

read(fd: number, buffer: ArrayBuffer, options?: { offset?: number; length?: number; position?: number; }): Promise<ReadOut>

Asynchronously reads data from a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path, 0o2);
  let buf = new ArrayBuffer(4096);
  fileio.read(fd, buf).then(function(readout){
      console.info("read file data successfully");
      console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
  }).catch(function(error){
      console.info("read file data failed with error:"+ error);
  });
  

fileio.read

read(fd: number, buffer: ArrayBuffer, options: { offset?: number; length?: number; position?: number; }, callback: AsyncCallback<ReadOut>): void

Asynchronously reads data from a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let fd = fileio.openSync(path, 0o2);
  let buf = new ArrayBuffer(4096);
  fileio.read(fd, buf, function (err, readOut) {
      if (readOut) {
          console.info("read file data successfully");
          console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
      }
  });
  

fileio.readSync

readSync(fd: number, buffer: ArrayBuffer, options?: { offset?: number; length?: number; position?: number; }): number

Synchronously reads data from a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path, 0o2);
  let buf = new ArrayBuffer(4096);
  let num = fileio.readSync(fd, buf);
  

fileio.rmdir⁷⁺

rmdir(path: string): Promise<void>

Asynchronously deletes a directory. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.rmdir(path).then(function() {
      console.info("rmdir successfully");
  }).catch(function(err){
      console.info("rmdir failed with error:"+ err);
  });
  

fileio.rmdir⁷⁺

rmdir(path: string, callback:AsyncCallback<void>): void

Asynchronously deletes a directory. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.rmdir(path, function(err){
      // Do something.
      console.info("rmdir successfully");
  });
  

fileio.rmdirSync⁷⁺

rmdirSync(path: string): void

Synchronously deletes a directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.rmdirSync(path);
  

fileio.unlink

unlink(path:string): Promise<void>

Asynchronously deletes a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.unlink(path).then(function(){
      console.info("remove file successfully");
  }).catch(function(error){
      console.info("remove file failed with error:"+ error);
  });
  

fileio.unlink

unlink(path:string, callback:AsyncCallback<void>): void

Asynchronously deletes a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.unlink(path, function(err) {
      console.info("remove file successfully");
  });
  

fileio.unlinkSync

unlinkSync(path: string): void

Synchronously deletes a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.unlinkSync(path);
  

fileio.write

write(fd: number, buffer: ArrayBuffer | string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): Promise<number>

Asynchronously writes data into a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(fpath, 0o100 | 0o2, 0o666);
  fileio.write(fd, "hello, world").then(function(number){
       console.info("write data to file successfully and size is:"+ number);
  }).catch(function(err){
      console.info("write data to file failed with error:"+ err);
  });
  

fileio.write

write(fd: number, buffer: ArrayBuffer | string, options: { offset?: number; length?: number; position?: number; encoding?: string; }, callback: AsyncCallback<number>): void

Asynchronously writes data into a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let fd = fileio.openSync(path, 0o100 | 0o2, 0o666);
  fileio.write(fd, "hello, world", function (err, bytesWritten) {
      if (bytesWritten) {
         console.info("write data to file successfully and size is:"+ bytesWritten);
      }
  });
  

fileio.writeSync

writeSync(fd: number, buffer: ArrayBuffer | string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): number

Synchronously writes data into a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path, 0o100 | 0o2, 0o666);
  let num = fileio.writeSync(fd, "hello, world");
  

fileio.hash

hash(path: string, algorithm: string): Promise<string>

Asynchronously calculates the hash value of a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.hash(path, "sha256").then(function(str){
      console.info("calculate file hash successfully:"+ str);
  }).catch(function(error){
      console.info("calculate file hash failed with error:"+ err);
  });
  

fileio.hash

hash(path: string, algorithm: string, callback: AsyncCallback<string>): void

Asynchronously calculates the hash value of a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.hash(fpath, "sha256", function(err, hashStr) {
      if (hashStr) {
          console.info("calculate file hash successfully:"+ hashStr);
      }
  });
  

fileio.chmod⁷⁺

chmod(path: string, mode: number):Promise<void>

Asynchronously changes the file permissions based on its path. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.chmod(path, mode).then(function() {
      console.info("chmod successfully");
  }).catch(function(err){
      console.info("chmod failed with error:"+ err);
  });
  

fileio.chmod⁷⁺

chmod(path: string, mode: number, callback: AsyncCallback<void>): void

Asynchronously changes the file permissions based on its path. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.chmod(path, mode, function (err) {
      // Do something.
  });
  

fileio.chmodSync⁷⁺

chmodSync(path: string, mode: number): void

Synchronously changes the file permissions based on its path.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.chmodSync(fpath, mode);
  

fileio.fstat⁷⁺

fstat(fd: number): Promise<Stat>

Asynchronously obtains file status information based on the file descriptor. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.fstat(fd).then(function(stat){
      console.info("fstat successfully:"+ JSON.stringify(stat));
  }).catch(function(err){
      console.info("fstat failed with error:"+ err);
  });
  

fileio.fstat⁷⁺

fstat(fd: number, callback: AsyncCallback<Stat>): void

Asynchronously obtains file status information based on the file descriptor. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let fd = fileio.openSync(path);
  fileio.fstat(fd, function (err) {
      // Do something.
  });
  

fileio.fstatSync⁷⁺

fstatSync(fd: number): Stat

Synchronously obtains file status information based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path);
  let stat = fileio.fstatSync(fd);
  

fileio.ftruncate⁷⁺

ftruncate(fd: number, len?: number): Promise<void>

Asynchronously truncates a file based on the file descriptor. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let fd = fileio.openSync(path);
  fileio.ftruncate(fd, 5).then(function(err) {    
      console.info("File truncated successfully.");
  }).catch(function(err){
      console.info("Failed to truncate the file. Error:"+ err);
  });
  

fileio.ftruncate⁷⁺

ftruncate(fd: number, len: number, callback:AsyncCallback<void>): void

Asynchronously truncates a file based on the file descriptor. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.ftruncate(fd, len, function(err){
      // Do something.
  });
  

fileio.ftruncateSync⁷⁺

ftruncateSync(fd: number, len?: number): void

Synchronously truncates a file based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.ftruncateSync(fd, len);
  

fileio.truncate⁷⁺

truncate(path: string, len?: number): Promise<void>

Asynchronously truncates a file based on its path. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.truncate(path, len).then(function(){
      console.info("File truncated successfully.");
  }).catch(function(err){
      console.info("Failed to truncate the file. Error:"+ err);
  });
  

fileio.truncate⁷⁺

truncate(path: string, len: number, callback:AsyncCallback<void>): void

Asynchronously truncates a file based on its path. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.truncate(path, len, function(err){
      // Do something.
  });
  

fileio.truncateSync⁷⁺

truncateSync(path: string, len?: number): void

Synchronously truncates a file based on the file path.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.truncateSync(path, len);
  

fileio.readText⁷⁺

readText(filePath: string, options?: { position?: number; length?: number; encoding?: string; }): Promise<string>

Asynchronously reads the text of a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.readText(path).then(function(str) {
      console.info("readText successfully:"+ str);
  }).catch(function(err){
      console.info("readText failed with error:"+ err);
  });
  

fileio.readText⁷⁺

readText(filePath: string, options: { position?: number; length?: number; encoding?: string; }, callback: AsyncCallback<string>): void

Asynchronously reads the text of a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.readText(path, function(err, str){
      // Do something.
  });
  

fileio.readTextSync⁷⁺

readTextSync(filePath: string, options?: { position?: number; length?: number; encoding?: string; }): string

Synchronously reads the text of a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let str = fileio.readTextSync(path, {position: 1, length: 3});
  

fileio.lstat⁷⁺

lstat(path: string): Promise<Stat>

Asynchronously obtains link status information. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.lstat(path).then(function(stat){
      console.info("Link status obtained:"+ number);
  }).catch(function(err){
      console.info("Failed to obtain the link status. Error:"+ err);
  });
  

fileio.lstat⁷⁺

lstat(path:string, callback:AsyncCallback<Stat>): void

Asynchronously obtains link status information. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.lstat(path, function (err, stat) {
      // Do something.
  });
  

fileio.lstatSync⁷⁺

lstatSync(path:string): Stat

Synchronously obtains link status information.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let stat = fileio.lstatSync(path);
  

fileio.read⁷⁺

read(buffer: ArrayBuffer, options?: { position?: number; offset?: number; length?: number; }): Promise<ReadOut>

Asynchronously reads data from a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.read(new ArrayBuffer(4096)).then(function(readout){
      console.info("read file data successfully");
      console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
  }).catch(function(err){
      console.info("Failed to read file data. Error:"+ err);
  });
  

fileio.read⁷⁺

read(buffer: ArrayBuffer, options: { position?: number; offset?: number; length?: number; }, callback: AsyncCallback<ReadOut>): void

Asynchronously reads data from a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let buf = new ArrayBuffer(4096);
  fileio.read(buf, function (err, readOut) {
      if (readOut) {
          console.info("read file data successfully");
          console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
      }
  });
  

fileio.rename⁷⁺

rename(oldPath: string, newPath: string): Promise<void>

Asynchronously renames a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.rename(oldPath, newPath).then(function() {
      console.info("rename successfully");
  }).catch(function(err){
      console.info("rename failed with error:"+ err);
  });
  

fileio.rename⁷⁺

rename(oldPath: string, newPath: string, callback: AsyncCallback<void>): void

Asynchronously renames a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.rename(oldPath, newPath, function(err){
  });
  

fileio.renameSync⁷⁺

renameSync(oldPath: string, newPath: string): void

Synchronously renames a file.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.renameSync(oldPath, newPath);
  

fileio.fsync⁷⁺

fsync(fd: number): Promise<void>

Asynchronously synchronizes a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.fsync(fd).then(function(){
      console.info("sync data successfully");
  }).catch(function(err){
      console.info("sync data failed with error:"+ err);
  });
  

fileio.fsync⁷⁺

fsync(fd: number, callback: AsyncCallback<void>): void

Asynchronously synchronizes a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.fsync(fd, function(err){
      // Do something.
  });
  

fileio.fsyncSync⁷⁺

fsyncSync(fd: number): void

Synchronizes a file in synchronous mode.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.fyncsSync(fd);
  

fileio.fdatasync⁷⁺

fdatasync(fd: number): Promise<void>

Asynchronously synchronizes data in a file. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.fdatasync(fd).then(function(err) {
      console.info("sync data successfully");
  }).catch(function(err){
      console.info("sync data failed with error:"+ err);
  });
  

fileio.fdatasync⁷⁺

fdatasync(fd: number, callback:AsyncCallback<void>): void

Asynchronously synchronizes data in a file. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.fdatasync (fd, function (err) {
      // Do something.
  });
  

fileio.fdatasyncSync⁷⁺

fdatasyncSync(fd: number): void

Synchronizes data in a file in synchronous mode.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.fdatasyncSync(fd);
  

fileio.symlink⁷⁺

symlink(target: string, srcPath: string): Promise<void>

Asynchronously creates a symbolic link based on a path. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.symlink(target, srcPath).then(function() {
      console.info("symlink successfully");
  }).catch(function(err){
      console.info("symlink failed with error:"+ err);
  });
  

fileio.symlink⁷⁺

symlink(target: string, srcPath: string, callback: AsyncCallback<void>): void

Asynchronously creates a symbolic link based on a path. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.symlink(target, srcPath, function (err) {
      // Do something.
  });
  

fileio.symlinkSync⁷⁺

symlinkSync(target: string, srcPath: string): void

Synchronously creates a symbolic link based on a specified path.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.symlinkSync(target, srcPath);
  

fileio.chown⁷⁺

chown(path: string, uid: number, gid: number): Promise<void>

Asynchronously changes the file owner based on its path. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let stat = fileio.statSync(path);
  fileio.chown(path, stat.uid, stat.gid).then(function(){
      console.info("chown successfully");
  }).catch(function(err){
      console.info("chown failed with error:"+ err);
  });
  

fileio.chown⁷⁺

chown(path: string, uid: number, gid: number, callback: AsyncCallback<void>): void

Asynchronously changes the file owner based on its path. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(fpath)
  fileio.chown(path, stat.uid, stat.gid, function (err){
      // Do something.
  });
  

fileio.chownSync⁷⁺

chownSync(path: string, uid: number, gid: number): void

Synchronously changes the file owner based on its path.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(fpath)
  fileio.chownSync(path, stat.uid, stat.gid);
  

fileio.mkdtemp⁷⁺

mkdtemp(prefix: string): Promise<string>

Asynchronously creates a temporary directory. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.mkdtemp(path + "XXXX").then(function(path){
      console.info("mkdtemp successfully:"+ path);
  }).catch(function(err){
      console.info("mkdtemp failed with error:"+ err);
  });
  

fileio.mkdtemp⁷⁺

mkdtemp(prefix: string, callback: AsyncCallback<string>): void

Asynchronously creates a temporary directory. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.mkdtemp(path + "XXXX", function (err, res) {
      // Do something.
  });
  

fileio.mkdtempSync⁷⁺

mkdtempSync(prefix: string): string

Synchronously creates a temporary directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let res = fileio.mkdtempSync(path + "XXXX");
  

fileio.fchmod⁷⁺

fchmod(fd: number, mode: number): Promise<void>

Asynchronously changes the file permissions based on the file descriptor. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.fchmod(fd, mode).then(function() {
      console.info("chmod successfully");
  }).catch(function(err){
      console.info("chmod failed with error:"+ err);
  });
  

fileio.fchmod⁷⁺

fchmod(fd: number, mode: number, callback: AsyncCallback<void>): void

Asynchronously changes the file permissions based on the file descriptor. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.fchmod(fd, mode, function (err) {
      // Do something.
  });
  

fileio.fchmodSync⁷⁺

fchmodSync(fd: number, mode: number): void

Synchronously changes the file permissions based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

   fileio.fchmodSync(fd, mode);
  

fileio.createStream⁷⁺

createStream(path: string, mode: string): Promise<Stream>

Asynchronously opens a stream based on the file path. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.createStream(path, "r+").then(function(stream){
      console.info("createStream successfully");
  }).catch(function(err){
      console.info("createStream failed with error:"+ err);
  });
  

fileio.createStream⁷⁺

createStream(path: string, mode: string, callback: AsyncCallback<Stream>): void

Asynchronously opens a stream based on the file path. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.createStream(path, mode, function(err, stream){
      // Do something.
  });
  

fileio.createStreamSync⁷⁺

createStreamSync(path: string, mode: string): Stream

Synchronously opens a stream based on the file path.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss = fileio.createStreamSync(path, "r+");
  

fileio.fdopenStream⁷⁺

fdopenStream(fd: number, mode: string): Promise<Stream>

Asynchronously opens a stream based on the file descriptor. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.fdopenStream(fd, mode).then(function(stream){
      console.info("openStream successfully");
  }).catch(function(err){
      console.info("openStream failed with error:"+ err);
  });
  

fileio.fdopenStream⁷⁺

fdopenStream(fd: number, mode: string, callback: AsyncCallback<Stream>): void

Asynchronously opens a stream based on the file descriptor. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.fdopenStream(fd, mode, function (err, stream) {
      // Do something.
  });
  

fileio.fdopenStreamSync⁷⁺

fdopenStreamSync(fd: number, mode: string): Stream

Synchronously opens a stream based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss = fileio.fdopenStreamSync(fd, "r+");
  

fileio.fchown⁷⁺

fchown(fd: number, uid: number, gid: number): Promise<void>

Asynchronously changes the file owner based on the file descriptor. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let stat = fileio.statSync(path);
  fileio.fchown(fd, stat.uid, stat.gid).then(function() {
      console.info("chown successfully");
  }).catch(function(err){
      console.info("chown failed with error:"+ err);
  });
  

fileio.fchown⁷⁺

fchown(fd: number, uid: number, gid: number, callback: AsyncCallback<void>): void

Asynchronously changes the file owner based on the file descriptor. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(fpath);
  fileio.fchown(fd, stat.uid, stat.gid, function (err){
      // Do something.
  });
  

fileio.fchownSync⁷⁺

fchownSync(fd: number, uid: number, gid: number): void

Synchronously changes the file owner based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(fpath);
  fileio.fchownSync(fd, stat.uid, stat.gid);
  

fileio.lchown⁷⁺

lchown(path: string, uid: number, gid: number): Promise<void>

Asynchronously changes the file owner based on the file path, changes the owner of the symbolic link (not the referenced file), and returns the result in a promise.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let stat = fileio.statSync(path);
  fileio.lchown(path, stat.uid, stat.gid).then(function() {
      console.info("chown successfully");
  }).catch(function(err){
      console.info("chown failed with error:"+ err);
  });
  

fileio.lchown⁷⁺

lchown(path: string, uid: number, gid: number, callback: AsyncCallback<void>): void

Asynchronously changes the file owner based on the file path, changes the owner of the symbolic link (not the referenced file), and returns the result in a callback.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(path);
  fileio.lchown(path, stat.uid, stat.gid, function (err){
      // Do something.
  });
  

fileio.lchownSync⁷⁺

lchownSync(path: string, uid: number, gid: number): void

Synchronously changes the file owner based on the file path and changes the owner of the symbolic link (not the referenced file).

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let stat = fileio.statSync(path);
  fileio.lchownSync(path, stat.uid, stat.gid);
  

fileio.createWatcher⁷⁺

createWatcher(filename: string, events: number, callback: AsyncCallback<number>): Watcher

Asynchronously listens for the changes of a file or directory. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  fileio.createWatcher(filename, events, function(watcher){
      // Do something.
  });
  

Readout

Obtains the file read result. This class applies only to the read() method.

System capability: SystemCapability.FileManagement.File.FileIO

Stat

Provides detailed file information. Before calling a method of the Stat class, use the stat() method synchronously or asynchronously to create a Stat instance.

System capability: SystemCapability.FileManagement.File.FileIO

Attributes

isBlockDevice

isBlockDevice(): boolean

Checks whether this file is a block special file. A block special file supports access by block only, and it is cached when accessed.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isBLockDevice = fileio.statSync(path).isBlockDevice();
  

isCharacterDevice

isCharacterDevice(): boolean

Checks whether this file is a character special file. A character special file supports random access, and it is not cached when accessed.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isCharacterDevice = fileio.statSync(path).isCharacterDevice();
  

isDirectory

isDirectory(): boolean

Checks whether this file is a directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isDirectory = fileio.statSync(path).isDirectory(); 
  

isFIFO

isFIFO(): boolean

Checks whether this file is a named pipe (or FIFO). Named pipes are used for inter-process communication.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isFIFO = fileio.statSync(path).isFIFO(); 
  

isFile

isFile(): boolean

Checks whether this file is a regular file.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isFile = fileio.statSync(fpath).isFile();
  

isSocket

isSocket(): boolean

Checks whether this file is a socket.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isSocket = fileio.statSync(path).isSocket(); 
  

isSymbolicLink

isSymbolicLink(): boolean

Checks whether this file is a symbolic link.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let isSymbolicLink = fileio.statSync(path).isSymbolicLink(); 
  

Watcher⁷⁺

Listens for the changes of a file. You can call the Watcher.stop() method synchronously or asynchronously to stop the listening.

stop⁷⁺

stop(): Promise<void>

Asynchronously stops watcher. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Example

  fileio.stop();
  

stop⁷⁺

stop(callback: AsyncCallback<void>): void

Asynchronously stops watcher. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  fileio.stop(function(err){
      // Do something.
  });
  

Stream⁷⁺

File stream. Before calling a method of the Stream class, use the createStream() method synchronously or asynchronously to create a Stream instance.

close⁷⁺

close(): Promise<void>

Asynchronously closes the stream. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let ss= fileio.createStreamSync(path);
  ss.close().then(function(){
      console.info("close fileStream successfully");
  }).catch(function(err){
      console.info("close fileStream  failed with error:"+ err);
  });
  

close⁷⁺

close(callback: AsyncCallback<void>): void

Asynchronously closes the stream. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let ss= fileio.createStreamSync(path);
  ss.close(function (err) {
      // do something
  });
  

closeSync

closeSync(): void

Synchronously closes the stream.

System capability: SystemCapability.FileManagement.File.FileIO

• Example

  let ss= fileio.createStreamSync(path);
  ss.closeSync();
  

flush⁷⁺

flush(): Promise<void>

Asynchronously flushes the stream. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let ss= fileio.createStreamSync(path);
  ss.flush().then(function (){
      console.info("flush successfully");
  }).catch(function(err){
      console.info("flush failed with error:"+ err);
  });
  

flush⁷⁺

flush(callback: AsyncCallback<void>): void

Asynchronously flushes the stream. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let ss= fileio.createStreamSync(path);
  ss.flush(function (err) {
      // do something
  });
  

flushSync⁷⁺

flushSync(): void

Synchronously flushes the stream.

System capability: SystemCapability.FileManagement.File.FileIO

• Example

  let ss= fileio.createStreamSync(path);
  ss.flushSync();
  

write⁷⁺

write(buffer: ArrayBuffer | string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): Promise<number>

Asynchronously writes data into the stream. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss= fileio.createStreamSync(fpath, "r+");
  ss.write("hello, world",{offset: 1,length: 5,position: 5,encoding :'utf-8'}).then(function (number){
      console.info("write successfully and size is:"+ number);
  }).catch(function(err){
      console.info("write failed with error:"+ err);
  });
  

write⁷⁺

write(buffer: ArrayBuffer | string, options: { offset?: number; length?: number; position?: number; encoding?: string; }, callback: AsyncCallback<number>): void

Asynchronously writes data into the stream. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let ss= fileio.createStreamSync(fpath, "r+");
  ss.write("hello, world", {offset: 1, length: 5, position: 5, encoding :'utf-8'}, function (err, bytesWritten) {
      if (bytesWritten) {
         // do something
         console.info("write successfully and size is:"+ bytesWritten);
      }
  });
  

writeSync⁷⁺

writeSync(buffer: ArrayBuffer | string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): number

Synchronously writes data into the stream.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss= fileio.createStreamSync(fpath,"r+");
  let num = ss.writeSync("hello, world", {offset: 1, length: 5, position: 5, encoding :'utf-8'});
  

read⁷⁺

read(buffer: ArrayBuffer, options?: { position?: number; offset?: number; length?: number; }): Promise<ReadOut>

Asynchronously reads data from the stream. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss = fileio.createStreamSync(fpath, "r+");
  ss.read(new ArrayBuffer(4096), {offset: 1, length: 5, position: 5}).then(function (readout){
      console.info("read data successfully");
      console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
  }).catch(function(err){
      console.info("read data failed with error:"+ err);
  });
  

read⁷⁺

read(buffer: ArrayBuffer, options: { position?: number; offset?: number; length?: number; }, callback: AsyncCallback<ReadOut>): void

Asynchronously reads data from the stream. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let ss = fileio.createStreamSync(fpath, "r+");
  ss.read(new ArrayBuffer(4096),{offset: 1, length: 5, position: 5},function (err, readOut) {
      if (readOut) {
          console.info("read data successfully");
          console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer)));
      }
  });
  

readSync⁷⁺

readSync(buffer: ArrayBuffer, options?: { position?: number; offset?: number; length?: number; }): number

Synchronously reads data from the stream.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Return value

• Example

  let ss = fileio.createStreamSync(fpath, "r+");
  let num = ss.readSync(new ArrayBuffer(4096), {offset: 1, length: 5, position: 5});
  

Dir

Manages directories. Before calling a method of the Dir class, use the opendir() method synchronously or asynchronously to create a Dir instance.

read

read(): Promise<Dirent>

Asynchronously reads the next directory entry. This method uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  dir.read().then(function (dirent){
      console.log("read successfully:"+JSON.stringify(dirent));
  }).catch(function(err){
      console.info("read failed with error:"+ err);
  });
  

read

read(callback: AsyncCallback<Dirent>): void

Asynchronously reads the next directory entry. This method uses a callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

• Parameters

• Example

  let dir = fileio.opendirSync(path);
  dir.read(function (err, dirent) {
      if (dirent) {
          // do something
          console.log("read successfully:"+JSON.stringify(dirent));
      }
  });
  

readSync

readSync(): Dirent

Synchronously reads the next directory entry.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let dirent = dir.readSync();
  

closeSync

closeSync(): void

Closes a directory. After a directory is closed, the file descriptor in Dir will be released and no directory entry can be read from Dir.

System capability: SystemCapability.FileManagement.File.FileIO

• Example

  let dir = fileio.opendirSync(path);
  dir.closeSync();
  

Dirent

Provides information about files and directories. Before calling a method of the Dirent class, use the dir.read() method synchronously or asynchronously to create a Dirent instance.

System capability: SystemCapability.FileManagement.File.FileIO

Attributes

isBlockDevice

isBlockDevice(): boolean

Checks whether the current directory entry is a block special file. A block special file supports access by block only, and it is cached when accessed.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isBLockDevice = dir.readSync().isBlockDevice();
  

isCharacterDevice

isCharacterDevice(): boolean

Checks whether a directory entry is a character special file. A character special file supports random access, and it is not cached when accessed.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isCharacterDevice = dir.readSync().isCharacterDevice(); 
  

isDirectory

isDirectory(): boolean

Checks whether a directory entry is a directory.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isDirectory = dir.readSync().isDirectory(); 
  

isFIFO

isFIFO(): boolean

Checks whether the current directory entry is a named pipe (or FIFO). Named pipes are used for inter-process communication.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isFIFO = dir.readSync().isFIFO(); 
  

isFile

isFile(): boolean

Checks whether a directory entry is a regular file.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isFile = dir.readSync().isFile(); 
  

isSocket

isSocket(): boolean

Checks whether a directory entry is a socket.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(dpath);
  let isSocket = dir.readSync().isSocket(); 
  

isSymbolicLink

isSymbolicLink(): boolean

Checks whether a directory entry is a symbolic link.

System capability: SystemCapability.FileManagement.File.FileIO

• Return value

• Example

  let dir = fileio.opendirSync(path);
  let isSymbolicLink = dir.readSync().isSymbolicLink();