@ohos.fileio (File Management)

The fileio module provides APIs for file storage and management, including basic file management, directory management, file information statistics, and stream read and write.

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.
• The APIs provided by this module are deprecated since API version 9. You are advised to use @ohos.file.fs.

Modules to Import

import fileio from '@ohos.fileio';

Guidelines

Before using the APIs provided by this module to perform operations on files or directories, obtain the path of the application sandbox as follows:

Stage Model

import Ability from '@ohos.application.Ability';
class MainAbility extends Ability {
   onWindowStageCreate(windowStage) {
       let context = this.context;
       let pathDir = context.filesDir;
   }
}

For details about how to obtain the stage model context, see UIAbilityContext.

FA Model

import featureAbility from '@ohos.ability.featureAbility';
let context = featureAbility.getContext();
context.getFilesDir().then((data) => {
     let pathDir = data;
})

For details about how to obtain the FA model context, see Contex.

fileio.stat

stat(path: string): Promise<Stat>

Obtains file information. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "test.txt";
fileio.stat(filePath).then(function (stat) {
    console.info("getFileInfo succeed, the size of file is " + stat.size);
}).catch(function (err) {
    console.info("getFileInfo failed with error:" + err);
});

fileio.stat

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

Obtains file information. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

fileio.stat(pathDir, 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(pathDir);
// Example code in Stat

fileio.opendir

opendir(path: string): Promise<Dir>

Opens a file directory. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let dirPath = pathDir + "/testDir";
fileio.opendir(dirPath).then(function (dir) {
    console.info("opendir succeed");
}).catch(function (err) {
    console.info("opendir failed with error:" + err);
});

fileio.opendir

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

Opens a file directory. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

fileio.opendir(pathDir, 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(pathDir);
// Example code in Dir struct
// Use read/readSync/close.

fileio.access

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

Checks whether the current process can access a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.access(filePath).then(function () {
    console.info("Access successful");
}).catch(function (err) {
    console.info("access failed with error:" + err);
});

fileio.access

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

Checks whether the current process can access a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.access(filePath, 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

let filePath = pathDir + "/test.txt";
try {
    fileio.accessSync(filePath);
} catch(err) {
    console.info("accessSync failed with error:" + err);
}

fileio.close⁷⁺

close(fd: number): Promise<void>

Closes a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.close(fd).then(function () {
    console.info("File closed");
}).catch(function (err) {
    console.info("close file failed with error:" + err);
});

fileio.close⁷⁺

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

Closes a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
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

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.closeSync(fd);

fileio.copyFile

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

Copies a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let srcPath = pathDir + "srcDir/test.txt";
let dstPath = pathDir + "dstDir/test.txt";
fileio.copyFile(srcPath, dstPath).then(function () {
    console.info("File copied");
}).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

Copies a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let srcPath = pathDir + "srcDir/test.txt";
let dstPath = pathDir + "dstDir/test.txt";
fileio.copyFile(srcPath, dstPath, 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

let srcPath = pathDir + "srcDir/test.txt";
let dstPath = pathDir + "dstDir/test.txt";
fileio.copyFileSync(srcPath, dstPath);

fileio.mkdir

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

Creates a directory. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let dirPath = pathDir + '/testDir';
fileio.mkdir(dirPath).then(function () {
    console.info("Directory created");
}).catch(function (error) {
    console.info("mkdir failed with error:" + error);
});

fileio.mkdir

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

Creates a directory. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let dirPath = pathDir + '/testDir';
fileio.mkdir(dirPath, function (err) {
  console.info("Directory created");
});

fileio.mkdirSync

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

Synchronously creates a directory.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let dirPath = path + '/testDir';
fileio.mkdirSync(dirPath);

fileio.open⁷⁺

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

Opens a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.open(filePath, 0o1, 0o0200).then(function (number) {
    console.info("File opened");
}).catch(function (err) {
    console.info("open file failed with error:" + err);
});

fileio.open⁷⁺

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

Opens a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.open(filePath, 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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o102, 0o640);

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o102, 0o666);
fileio.writeSync(fd, 'hello world');
let fd1 = fileio.openSync(filePath, 0o2002);
fileio.writeSync(fd1, 'hello world');
let num = fileio.readSync(fd1, new ArrayBuffer(4096), {position: 0});
console.info("num == " + num);

fileio.read

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

Reads data from a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 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 (err) {
    console.info("read file data failed with error:" + err);
});

fileio.read

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

Reads data from a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o2);
let buf = new ArrayBuffer(4096);
let num = fileio.readSync(fd, buf);

fileio.rmdir⁷⁺

rmdir(path: string): Promise<void>

Deletes a directory. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let dirPath = pathDir + '/testDir';
fileio.rmdir(dirPath).then(function () {
    console.info("Directory deleted");
}).catch(function (err) {
    console.info("rmdir failed with error:" + err);
});

fileio.rmdir⁷⁺

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

Deletes a directory. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let dirPath = pathDir + '/testDir';
fileio.rmdir(dirPath, function (err) {
    // Do something.
    console.info("Directory deleted");
});

fileio.rmdirSync⁷⁺

rmdirSync(path: string): void

Synchronously deletes a directory.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let dirPath = pathDir + '/testDir';
fileio.rmdirSync(dirPath);

fileio.unlink

unlink(path: string): Promise<void>

Deletes a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.unlink(filePath).then(function () {
    console.info("File deleted");
}).catch(function (error) {
    console.info("remove file failed with error:" + error);
});

fileio.unlink

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

Deletes a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.unlink(filePath, function (err) {
    console.info("File deleted");
});

fileio.unlinkSync

unlinkSync(path: string): void

Synchronously deletes a file.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.unlinkSync(filePath);

fileio.write

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

Writes data into a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666);
fileio.write(fd, "hello, world").then(function (number) {
     console.info("write data to file succeed 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

Writes data into a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666);
fileio.write(fd, "hello, world", function (err, bytesWritten) {
    if (bytesWritten) {
       console.info("write data to file succeed 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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666);
let num = fileio.writeSync(fd, "hello, world");

fileio.hash

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

Calculates the hash value of a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.hash(filePath, "sha256").then(function (str) {
    console.info("calculate file hash succeed:" + str);
}).catch(function (err) {
    console.info("calculate file hash failed with error:" + err);
});

fileio.hash

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

Calculates the hash value of a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.hash(filePath, "sha256", function (err, hashStr) {
    if (hashStr) {
        console.info("calculate file hash succeed:" + hashStr);
    }
});

fileio.chmod⁷⁺

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

Changes file permissions. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.chmod(filePath, 0o700).then(function () {
    console.info("File permissions changed");
}).catch(function (err) {
    console.info("chmod failed with error:" + err);
});

fileio.chmod⁷⁺

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

Changes file permissions. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.chmod(filePath, 0o700, function (err) {
    // Do something.
});

fileio.chmodSync⁷⁺

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

Synchronously changes file permissions.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.chmodSync(filePath, 0o700);

fileio.fstat⁷⁺

fstat(fd: number): Promise<Stat>

Obtains file information based on the file descriptor. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fstat(fd).then(function (stat) {
    console.info("fstat succeed, the size of file is " + stat.size);
}).catch(function (err) {
    console.info("fstat failed with error:" + err);
});

fileio.fstat⁷⁺

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

Obtains file information based on the file descriptor. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fstat(fd, function (err) {
    // Do something.
});

fileio.fstatSync⁷⁺

fstatSync(fd: number): Stat

Synchronously obtains file information based on the file descriptor.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let stat = fileio.fstatSync(fd);

fileio.ftruncate⁷⁺

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

Truncates a file based on the file descriptor. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.ftruncate(fd, 5).then(function (err) {    
    console.info("File truncated");
}).catch(function (err) {
    console.info("truncate file failed with error:" + err);
});

fileio.ftruncate⁷⁺

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

Truncates a file based on the file descriptor. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let len = 5;
fileio.ftruncate(fd, 5, 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

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let len = 5;
fileio.ftruncateSync(fd, len);

fileio.truncate⁷⁺

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

Truncates a file based on the file path. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let len = 5;
fileio.truncate(filePath, len).then(function () {
    console.info("File truncated");
}).catch(function (err) {
    console.info("truncate file failed with error:" + err);
});

fileio.truncate⁷⁺

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

Truncates a file based on the file path. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let len = 5;
fileio.truncate(filePath, 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

let filePath = pathDir + "/test.txt";
let len = 5;
fileio.truncateSync(filePath, len);

fileio.readText⁷⁺

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

Reads the text content of a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.readText(filePath).then(function (str) {
    console.info("readText succeed:" + 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

Reads the text content of a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.readText(filePath, { position: 1, encoding: 'UTF-8' }, 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 filePath = pathDir + "/test.txt";
let str = fileio.readTextSync(filePath, {position: 1, length: 3});

fileio.lstat⁷⁺

lstat(path: string): Promise<Stat>

Obtains link information. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.lstat(filePath).then(function (stat) {
    console.info("get link status succeed, the size of file is" + stat.size);
}).catch(function (err) {
    console.info("get link status failed with error:" + err);
});

fileio.lstat⁷⁺

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

Obtains link information. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.lstat(filePath, function (err, stat) {
    // Do something.
});

fileio.lstatSync⁷⁺

lstatSync(path: string): Stat

Synchronously obtains the link information.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let stat = fileio.lstatSync(filePath);

fileio.rename⁷⁺

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

Renames a file. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/new.txt';
fileio.rename(srcFile, dstFile).then(function () {
    console.info("File renamed");
}).catch(function (err) {
    console.info("rename failed with error:" + err);
});

fileio.rename⁷⁺

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

Renames a file. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/new.txt';
fileio.rename(srcFile, dstFile, function (err) {
});

fileio.renameSync⁷⁺

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

Synchronously renames a file.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/new.txt';
fileio.renameSync(srcFile, dstFile);

fileio.fsync⁷⁺

fsync(fd: number): Promise<void>

Flushes data of a file to disk. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fsync(fd).then(function () {
    console.info("Data flushed");
}).catch(function (err) {
    console.info("sync data failed with error:" + err);
});

fileio.fsync⁷⁺

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

Flushes data of a file to disk. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fsync(fd, function (err) {
    // Do something.
});

fileio.fsyncSync⁷⁺

fsyncSync(fd: number): void

Flushes data of a file to disk in synchronous mode.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fsyncSync(fd);

fileio.fdatasync⁷⁺

fdatasync(fd: number): Promise<void>

Flushes data of a file to disk. This API uses a promise to return the result. fdatasync() is similar to fsync(), but does not flush modified metadata unless that metadata is needed.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fdatasync(fd).then(function (err) {
    console.info("Data flushed");
}).catch(function (err) {
    console.info("sync data failed with error:" + err);
});

fileio.fdatasync⁷⁺

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

Flushes data of a file to disk. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let stat = fileio.fdatasyncSync(fd);

fileio.symlink⁷⁺

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

Creates a symbolic link based on the file path. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/test';
fileio.symlink(srcFile, dstFile).then(function () {
    console.info("Symbolic link created");
}).catch(function (err) {
    console.info("symlink failed with error:" + err);
});

fileio.symlink⁷⁺

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

Creates a symbolic link based on the file path. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/test';
fileio.symlink(srcFile, dstFile, 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

let srcFile = pathDir + "/test.txt";
let dstFile = pathDir + '/test';
fileio.symlinkSync(srcFile, dstFile);

fileio.chown⁷⁺

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

Changes the file owner based on the file path. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath);
fileio.chown(filePath, stat.uid, stat.gid).then(function () {
    console.info("File owner changed");
}).catch(function (err) {
    console.info("chown failed with error:" + err);
});

fileio.chown⁷⁺

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

Changes the file owner based on the file path. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath)
fileio.chown(filePath, 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 filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath)
fileio.chownSync(filePath, stat.uid, stat.gid);

fileio.mkdtemp⁷⁺

mkdtemp(prefix: string): Promise<string>

Creates a temporary directory. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

fileio.mkdtemp(pathDir + "/XXXXXX").then(function (pathDir) {
    console.info("mkdtemp succeed:" + pathDir);
}).catch(function (err) {
    console.info("mkdtemp failed with error:" + err);
});

fileio.mkdtemp⁷⁺

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

Creates a temporary directory. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

fileio.mkdtemp(pathDir + "/XXXXXX", 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(pathDir + "/XXXXXX");

fileio.fchmod⁷⁺

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

Changes file permissions based on the file descriptor. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let mode = 0o700;
fileio.fchmod(fd, mode).then(function () {
    console.info("File permissions changed");
}).catch(function (err) {
    console.info("chmod failed with error:" + err);
});

fileio.fchmod⁷⁺

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

Changes file permissions based on the file descriptor. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let mode = 0o700;
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

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let mode = 0o700;
 fileio.fchmodSync(fd, mode);

fileio.createStream⁷⁺

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

Opens a file stream based on the file path. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
fileio.createStream(filePath, "r+").then(function (stream) {
    console.info("Stream created");
}).catch(function (err) {
    console.info("createStream failed with error:" + err);
});

fileio.createStream⁷⁺

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

Opens a file stream based on the file path. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
fileio.createStream(filePath, "r+", 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 filePath = pathDir + "/test.txt";
let ss = fileio.createStreamSync(filePath, "r+");

fileio.fdopenStream⁷⁺

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

Opens a file stream based on the file descriptor. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fdopenStream(fd, "r+").then(function (stream) {
    console.info("Stream opened");
}).catch(function (err) {
    console.info("openStream failed with error:" + err);
});

fileio.fdopenStream⁷⁺

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

Opens a file stream based on the file descriptor. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
fileio.fdopenStream(fd, "r+", 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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let ss = fileio.fdopenStreamSync(fd, "r+");

fileio.fchown⁷⁺

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

Changes the file owner based on the file descriptor. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let stat = fileio.statSync(filePath);
fileio.fchown(fd, stat.uid, stat.gid).then(function () {
    console.info("File owner changed");
}).catch(function (err) {
    console.info("chown failed with error:" + err);
});

fileio.fchown⁷⁺

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

Changes the file owner based on the file descriptor. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let stat = fileio.statSync(filePath);
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 filePath = pathDir + "/test.txt";
let fd = fileio.openSync(filePath);
let stat = fileio.statSync(filePath);
fileio.fchownSync(fd, stat.uid, stat.gid);

fileio.lchown⁷⁺

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

Changes the file owner (owner of the symbolic link, not the file referred to by the symbolic link) based on the file path. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath);
fileio.lchown(filePath, stat.uid, stat.gid).then(function () {
    console.info("File owner changed");
}).catch(function (err) {
    console.info("chown failed with error:" + err);
});

fileio.lchown⁷⁺

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

Changes the file owner (owner of the symbolic link, not the file referred to by the symbolic link) based on the file path. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath);
fileio.lchown(filePath, 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 filePath = pathDir + "/test.txt";
let stat = fileio.statSync(filePath);
fileio.lchownSync(filePath, stat.uid, stat.gid);

fileio.createWatcher⁷⁺

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

Listens for file or directory changes. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir +"/test.txt";
fileio.createWatcher(filePath, 1, function (number) {
   console.info("Monitoring times: " +number);
});

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 filePath = pathDir + "/test.txt";
let isBLockDevice = fileio.statSync(filePath).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 filePath = pathDir + "/test.txt";
let isCharacterDevice = fileio.statSync(filePath).isCharacterDevice();

isDirectory

isDirectory(): boolean

Checks whether this file is a directory.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let dirPath = pathDir + "/test";
let isDirectory = fileio.statSync(dirPath).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 filePath = pathDir + "/test.txt";
let isFIFO = fileio.statSync(filePath).isFIFO(); 

isFile

isFile(): boolean

Checks whether this file is a regular file.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let filePath = pathDir + "/test.txt";
let isFile = fileio.statSync(filePath).isFile();

isSocket

isSocket(): boolean

Checks whether this file is a socket.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let filePath = pathDir + "/test.txt";
let isSocket = fileio.statSync(filePath).isSocket(); 

isSymbolicLink

isSymbolicLink(): boolean

Checks whether this file is a symbolic link.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let filePath = pathDir + "/test";
let isSymbolicLink = fileio.statSync(filePath).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>

Stops the watcher instance. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Example

let filePath = path + "/test.txt";
let watcher = fileio.createWatcher(filePath, 1, function (number) {
    console.info("Monitoring times: " +number);
});
watcher.stop().then(function () {
     console.info("Watcher stopped");
});

stop⁷⁺

stop(callback: AsyncCallback<void>): void

Stops the watcher instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = path +"/test.txt";
let watcher = fileio.createWatcher(filePath, 1, function (number) {
    console.info("Monitoring times: " +number);
});
watcher.stop(function () {
    console.info("Watcher stopped");
})

Stream

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

close⁷⁺

close(): Promise<void>

Closes the stream. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.close().then(function () {
    console.info("File stream closed");
}).catch(function (err) {
    console.info("close fileStream  failed with error:" + err);
});

close⁷⁺

close(callback: AsyncCallback<void>): void

Closes the stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.close(function (err) {
    // Do something.
});

closeSync

closeSync(): void

Synchronously closes the stream.

System capability: SystemCapability.FileManagement.File.FileIO

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.closeSync();

flush⁷⁺

flush(): Promise<void>

Flushes the stream. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.flush().then(function () {
    console.info("Stream flushed");
}).catch(function (err) {
    console.info("flush failed with error:" + err);
});

flush⁷⁺

flush(callback: AsyncCallback<void>): void

Flushes the stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.flush(function (err) {
    // Do something.
});

flushSync⁷⁺

flushSync(): void

Synchronously flushes the stream.

System capability: SystemCapability.FileManagement.File.FileIO

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.flushSync();

write⁷⁺

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

Writes data into the stream. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.write("hello, world",{offset: 1,length: 5,position: 5,encoding :'utf-8'}).then(function (number) {
    console.info("write succeed 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

Writes data into the stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath, "r+");
ss.write("hello, world", {offset: 1, length: 5, position: 5, encoding :'utf-8'}, function (err, bytesWritten) {
    if (bytesWritten) {
       // Do something.
       console.info("write succeed 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 filePath = pathDir + "/test.txt";
let ss= fileio.createStreamSync(filePath,"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>

Reads data from the stream. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Return value

Example

let filePath = pathDir + "/test.txt";
let ss = fileio.createStreamSync(filePath, "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

Reads data from the stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

let filePath = pathDir + "/test.txt";
let ss = fileio.createStreamSync(filePath, "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 filePath = pathDir + "/test.txt";
let ss = fileio.createStreamSync(filePath, "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>

Reads the next directory entry. This API uses a promise to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

dir.read().then(function (dirent) {
    console.log("read succeed, the name of dirent is " + dirent.name);
}).catch(function (err) {
    console.info("read failed with error:" + err);
});

read

read(callback: AsyncCallback<Dirent>): void

Reads the next directory entry. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.FileManagement.File.FileIO

Parameters

Example

dir.read(function (err, dirent) {
    if (dirent) {
        // Do something.
        console.log("read succeed, the name of file is " + dirent.name);
    }
});

readSync

readSync(): Dirent

Synchronously reads the next directory entry.

System capability: SystemCapability.FileManagement.File.FileIO

Return value

Example

let dirent = dir.readSync();

close⁷⁺

close(): Promise<void>

Closes a directory. This API uses a promise to return the result. 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

dir.close().then(function (err) {
    console.info("close dir successfully");
});

close⁷⁺

close(callback: AsyncCallback<void>): void

Closes a directory. This API uses an asynchronous callback to return the result. 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

dir.close(function (err) {
    console.info("close dir successfully");
});

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

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 this 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(pathDir);
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(pathDir);
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(pathDir);
let isDirectory = dir.readSync().isDirectory(); 

isFIFO

isFIFO(): boolean

Checks whether this 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(pathDir);
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(pathDir);
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(pathDir);
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(pathDir);
let isSymbolicLink = dir.readSync().isSymbolicLink();