同步操作将从 OpenHarmony/filemanagement_file_api 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
Currently, the File Api provides apps with JavaScript APIs for I/O capabilities, including APIs for managing files and directories, obtaining file information, reading and writing data streams of files, and receiving URIs rather than absolute paths.
Currently, the File Api provides only local JavaScript file APIs for apps through the FileIO and File modules. The File Api uses LibN to abstract APIs at the NAPI layer, providing basic capabilities such as the basic type system, memory management, and general programming models for the subsystem. This subsystem depends on the engine layer of the JS application development framework to provide the capability of converting JavaScript APIs into C++ code, depends on the application framework to provide app-related directories, and depends on the GLIBC runtimes to provide I/O capabilities.
Figure 1 File Api architecture
foundation/filemanagement/file_api
├── figures # Figures
├── interfaces # APIs
├ └── kits # APIs exposed externally
├── utils # Common Components
├ └── filemgmt_libhilog # Log Components
├ └── filemgmt_libn # Platform related components
Constraints on local I/O APIs:
Currently, the File Api provides APIs for accessing local files and directories. The following table describes the API types classified by function.
Table 1 API types
The URIs used in sandbox file APIs are classified into three types, as described in the following table.
Table 2 URI types
The I/O APIs provided by the File Api can be classified into the following types based on the programming model:
Synchronous programming model
APIs whose names contain Sync are implemented as a synchronous model. When a synchronous API is called, the calling process waits until a value is returned.
The following example opens a file stream in read-only mode, attempts to read the first 4096 bytes, converts them into a UTF-8-encoded string, and then closes the file stream:
import fileio from '@ohos.fileio';
try {
var ss = fileio.createStreamSync("tmp", "r")
buf = new ArrayBuffer(4096)
ss.readSync(buf)
console.log(String.fromCharCode.apply(null, new Uint8Array(buf)))
ss.closeSync()
}
catch (e) {
console.log(e);
}
Asynchronous programming model: Promise
In the @ohos.fileio module, the APIs whose names do not contain Sync and to which a callback is not passed as their input parameter are implemented as the Promise asynchronous model. The Promise asynchronous model is one of the OHOS standard asynchronous models. When an asynchronous API using the Promise model is called, the API returns a Promise object while executing the concerned task asynchronously. The Promise object represents the asynchronous operation result. When there is more than one result, the results are returned as properties of the Promise object.
In the following example, a Promise chain is used to open a file stream in read-only mode, attempt to read the first 4096 bytes of the file, display the length of the content read, and then close the file:
import fileio from '@ohos.fileio';
try {
let openedStream
fileio.createStream("test.txt", "r")
.then(function (ss) {
openedStream = ss;
return ss.read(new ArrayBuffer(4096))
})
.then(function (res) {
console.log(res.bytesRead);
console.log(String.fromCharCode.apply(null, new Uint8Array(res.buffer)))
return openedStream.close()
})
.then(function (undefined) {
console.log("Stream is closed")
})
.catch(function (e) {
console.log(e)
})
} catch (e) {
console.log(e)
}
Asynchronous programming model: Callback
In the @ohos.fileio module, the APIs whose names do not contain Sync and to which a callback is directly passed as their input parameter are implemented as the callback asynchronous model. The callback asynchronous model is also one of the OHOS standard asynchronous models. When an asynchronous API with a callback passed is called, the API executes the concerned task asynchronously and returns the execution result as the input parameters of the registered callback. The first parameter is of the undefined or Error type, indicating that the execution succeeds or fails, respectively.
The following example creates a file stream asynchronously, reads the first 4096 bytes of the file asynchronously in the callback invoked when the file stream is created, and then closes the file asynchronously in the callback invoked when the file is read:
import fileio from '@ohos.fileio';
try {
fileio.createStream("./testdir/test_stream.txt", "r", function (err, ss) {
if (!err) {
ss.read(new ArrayBuffer(4096), {}, function (err, buf, readLen) {
if (!err) {
console.log('readLen: ' + readLen)
console.log('data: ' + String.fromCharCode.apply(null, new Uint8Array(buf)))
} else {
console.log('Cannot read from the stream ' + err)
}
ss.close(function (err) {
console.log(`Stream is ${err ? 'not' : ''}closed`)
});
})
} else {
console.log('Cannot open the stream ' + err)
}
})
} catch (e) {
console.log(e)
}
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。