1# @ohos.fileio (文件管理) 2 3该模块提供文件存储管理能力，包括文件基本管理、文件目录管理、文件信息统计、文件流式读写等常用功能。 4 5> **说明：** 6> 本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 7> 本模块自API 9开始废弃，建议使用[@ohos.file.fs](js-apis-file-fs.md)替代。 8 9## 导入模块 10 11```js 12import fileio from '@ohos.fileio'; 13``` 14 15 16## 使用说明 17 18使用该功能模块对文件/目录进行操作前，需要先获取其应用沙箱路径，获取方式及其接口用法请参考： 19 20**Stage模型** 21 22 ```js 23import Ability from '@ohos.application.Ability'; 24class MainAbility extends Ability { 25 onWindowStageCreate(windowStage) { 26 let context = this.context; 27 let pathDir = context.filesDir; 28 } 29} 30 ``` 31 32 Stage模型context的具体获取方法参见[Stage模型](js-apis-inner-application-uiAbilityContext.md)。 33 34**FA模型** 35 36 ```js 37 import featureAbility from '@ohos.ability.featureAbility'; 38 let context = featureAbility.getContext(); 39 context.getFilesDir().then((data) => { 40 let pathDir = data; 41 }) 42 ``` 43 44 FA模型context的具体获取方法参见[FA模型](js-apis-inner-app-context.md#Context模块)。 45 46## fileio.stat 47 48stat(path: string): Promise<Stat> 49 50获取文件信息，使用Promise异步回调。 51 52**系统能力**：SystemCapability.FileManagement.File.FileIO 53 54**参数：** 55 56| 参数名 | 类型 | 必填 | 说明 | 57| ------ | ------ | ---- | -------------------------- | 58| path | string | 是 | 待获取文件的应用沙箱路径。 | 59 60**返回值：** 61 62 | 类型 | 说明 | 63 | ---------------------------- | ---------- | 64 | Promise<[Stat](#stat)> | Promise对象。返回文件的具体信息。 | 65 66**示例：** 67 68 ```js 69 let filePath = pathDir + "test.txt"; 70 fileio.stat(filePath).then(function (stat) { 71 console.info("getFileInfo succeed, the size of file is " + stat.size); 72 }).catch(function (err) { 73 console.info("getFileInfo failed with error:" + err); 74 }); 75 ``` 76 77 78## fileio.stat 79 80stat(path: string, callback: AsyncCallback<Stat>): void 81 82获取文件信息，使用callback异步回调。 83 84**系统能力**：SystemCapability.FileManagement.File.FileIO 85 86**参数：** 87 88| 参数名 | 类型 | 必填 | 说明 | 89| -------- | ---------------------------------- | ---- | ------------------------------ | 90| path | string | 是 | 待获取文件的应用沙箱路径。 | 91| callback | AsyncCallback<[Stat](#stat)> | 是 | 异步获取文件的信息之后的回调。 | 92 93**示例：** 94 95 ```js 96 fileio.stat(pathDir, function (err, stat) { 97 // example code in Stat 98 }); 99 ``` 100 101 102## fileio.statSync 103 104statSync(path: string): Stat 105 106以同步方法获取文件的信息。 107 108**系统能力**：SystemCapability.FileManagement.File.FileIO 109 110**参数：** 111 112| 参数名 | 类型 | 必填 | 说明 | 113| ------ | ------ | ---- | -------------------------- | 114| path | string | 是 | 待获取文件的应用沙箱路径。 | 115 116 117**返回值：** 118 119 | 类型 | 说明 | 120 | ------------- | ---------- | 121 | [Stat](#stat) | 表示文件的具体信息。 | 122 123**示例：** 124 125 ```js 126 let stat = fileio.statSync(pathDir); 127 // example code in Stat 128 ``` 129 130 131## fileio.opendir 132 133opendir(path: string): Promise<Dir> 134 135打开文件目录，使用Promise异步回调。 136 137**系统能力**：SystemCapability.FileManagement.File.FileIO 138 139**参数：** 140 141| 参数名 | 类型 | 必填 | 说明 | 142| ------ | ------ | ---- | ------------------------------ | 143| path | string | 是 | 待打开文件目录的应用沙箱路径。 | 144 145**返回值：** 146 147 | 类型 | 说明 | 148 | -------------------------- | -------- | 149 | Promise<[Dir](#dir)> | Promise对象。返回Dir对象。 | 150 151**示例：** 152 153 ```js 154 let dirPath = pathDir + "/testDir"; 155 fileio.opendir(dirPath).then(function (dir) { 156 console.info("opendir succeed"); 157 }).catch(function (err) { 158 console.info("opendir failed with error:" + err); 159 }); 160 ``` 161 162 163## fileio.opendir 164 165opendir(path: string, callback: AsyncCallback<Dir>): void 166 167打开文件目录，使用callback异步回调。 168 169**系统能力**：SystemCapability.FileManagement.File.FileIO 170 171**参数：** 172 173| 参数名 | 类型 | 必填 | 说明 | 174| -------- | -------------------------------- | ---- | ------------------------------ | 175| path | string | 是 | 待打开文件目录的应用沙箱路径。 | 176| callback | AsyncCallback<[Dir](#dir)> | 是 | 异步打开文件目录之后的回调。 | 177 178**示例：** 179 180 ```js 181 fileio.opendir(pathDir, function (err, dir) { 182 // example code in Dir struct 183 // use read/readSync/close 184 }); 185 ``` 186 187 188## fileio.opendirSync 189 190opendirSync(path: string): Dir 191 192以同步方法打开文件目录。 193 194**系统能力**：SystemCapability.FileManagement.File.FileIO 195 196 197**参数：** 198 199| 参数名 | 类型 | 必填 | 说明 | 200| ------ | ------ | ---- | ------------------------------ | 201| path | string | 是 | 待打开文件目录的应用沙箱路径。 | 202 203**返回值：** 204 205 | 类型 | 说明 | 206 | ----------- | -------- | 207 | [Dir](#dir) | 返回Dir对象。 | 208 209**示例：** 210 211 ```js 212 let dir = fileio.opendirSync(pathDir); 213 // example code in Dir struct 214 // use read/readSync/close 215 ``` 216 217 218## fileio.access 219 220access(path: string, mode?: number): Promise<void> 221 222检查当前进程是否可访问某文件，使用Promise异步回调。 223 224**系统能力**：SystemCapability.FileManagement.File.FileIO 225 226**参数：** 227 228| 参数名 | 类型 | 必填 | 说明 | 229| ------ | ------ | ---- | ------------------------------------------------------------ | 230| path | string | 是 | 待访问文件的应用沙箱路径。 | 231| mode | number | 否 | 访问文件时的选项，可给定如下选项，以按位或的方式使用多个选项，默认给定0。<br/>确认当前进程是否具有对应权限：<br/>- 0：确认文件是否存在。<br/>- 1：确认当前进程是否具有可执行权限。<br/>- 2：确认当前进程是否具有写权限。<br/>- 4：确认当前进程是否具有读权限。 | 232 233**返回值：** 234 235 | 类型 | 说明 | 236 | ------------------- | ---------------------------- | 237 | Promise<void> | Promise对象。无返回值。 | 238 239**示例：** 240 241 ```js 242 let filePath = pathDir + "/test.txt"; 243 fileio.access(filePath).then(function () { 244 console.info("access succeed"); 245 }).catch(function (err) { 246 console.info("access failed with error:" + err); 247 }); 248 ``` 249 250 251## fileio.access 252 253access(path: string, mode?: number, callback: AsyncCallback<void>): void 254 255检查当前进程是否可访问某文件，使用callback异步回调。 256 257**系统能力**：SystemCapability.FileManagement.File.FileIO 258 259**参数：** 260 261| 参数名 | 类型 | 必填 | 说明 | 262| -------- | ------------------------- | ---- | ------------------------------------------------------------ | 263| path | string | 是 | 待访问文件的应用沙箱路径。 | 264| mode | number | 否 | 访问文件时的选项，可给定如下选项，以按位或的方式使用多个选项，默认给定0。<br/>确认当前进程是否具有对应权限：<br/>- 0：确认文件是否存在。<br/>- 1：确认当前进程是否具有可执行权限。<br/>- 2：确认当前进程是否具有写权限。<br/>- 4：确认当前进程是否具有读权限。 | 265| callback | AsyncCallback<void> | 是 | 异步检查当前进程是否可访问某文件之后的回调。 | 266 267**示例：** 268 269 ```js 270 let filePath = pathDir + "/test.txt"; 271 fileio.access(filePath, function (err) { 272 // do something 273 }); 274 ``` 275 276 277## fileio.accessSync 278 279accessSync(path: string, mode?: number): void 280 281以同步方法检查当前进程是否可访问某文件。 282 283**系统能力**：SystemCapability.FileManagement.File.FileIO 284 285**参数：** 286 287| 参数名 | 类型 | 必填 | 说明 | 288| ------ | ------ | ---- | ------------------------------------------------------------ | 289| path | string | 是 | 待访问文件的应用沙箱路径。 | 290| mode | number | 否 | 访问文件时的选项，可给定如下选项，以按位或的方式使用多个选项，默认给定0。<br/>确认当前进程是否具有对应权限：<br/>- 0：确认文件是否存在。<br/>- 1：确认当前进程是否具有可执行权限。<br/>- 2：确认当前进程是否具有写权限。<br/>- 4：确认当前进程是否具有读权限。 | 291 292**示例：** 293 294 ```js 295 let filePath = pathDir + "/test.txt"; 296 try { 297 fileio.accessSync(filePath); 298 } catch(err) { 299 console.info("accessSync failed with error:" + err); 300 } 301 ``` 302 303 304## fileio.close<sup>7+</sup> 305 306close(fd: number): Promise<void> 307 308关闭文件，使用Promise异步回调。 309 310**系统能力**：SystemCapability.FileManagement.File.FileIO 311 312**参数：** 313 314 | 参数名 | 类型 | 必填 | 说明 | 315 | ---- | ------ | ---- | ------------ | 316 | fd | number | 是 | 待关闭文件的文件描述符。 | 317 318**返回值：** 319 320 | 类型 | 说明 | 321 | ------------------- | ---------------------------- | 322 | Promise<void> | Promise对象。无返回值。 | 323 324**示例：** 325 326 ```js 327 let filePath = pathDir + "/test.txt"; 328 let fd = fileio.openSync(filePath); 329 fileio.close(fd).then(function () { 330 console.info("close file succeed"); 331 }).catch(function (err) { 332 console.info("close file failed with error:" + err); 333 }); 334 ``` 335 336 337## fileio.close<sup>7+</sup> 338 339close(fd: number, callback: AsyncCallback<void>): void 340 341关闭文件，使用callback异步回调。 342 343**系统能力**：SystemCapability.FileManagement.File.FileIO 344 345**参数：** 346 347 | 参数名 | 类型 | 必填 | 说明 | 348 | -------- | ------------------------- | ---- | ------------ | 349 | fd | number | 是 | 待关闭文件的文件描述符。 | 350 | callback | AsyncCallback<void> | 是 | 异步关闭文件之后的回调。 | 351 352**示例：** 353 354 ```js 355 let filePath = pathDir + "/test.txt"; 356 let fd = fileio.openSync(filePath); 357 fileio.close(fd, function (err) { 358 // do something 359 }); 360 ``` 361 362 363## fileio.closeSync 364 365closeSync(fd: number): void 366 367以同步方法关闭文件。 368 369**系统能力**：SystemCapability.FileManagement.File.FileIO 370 371**参数：** 372 373 | 参数名 | 类型 | 必填 | 说明 | 374 | ---- | ------ | ---- | ------------ | 375 | fd | number | 是 | 待关闭文件的文件描述符。 | 376 377**示例：** 378 379 ```js 380 let filePath = pathDir + "/test.txt"; 381 let fd = fileio.openSync(filePath); 382 fileio.closeSync(fd); 383 ``` 384 385 386## fileio.copyFile 387 388copyFile(src: string|number, dest: string|number, mode?: number): Promise<void> 389 390复制文件，使用Promise异步回调。 391 392**系统能力**：SystemCapability.FileManagement.File.FileIO 393 394**参数：** 395 396 | 参数名 | 类型 | 必填 | 说明 | 397 | ---- | -------------------------- | ---- | ---------------------------------------- | 398 | src | string\|number | 是 | 待复制文件的路径或待复制文件的描述符。 | 399 | dest | string\|number | 是 | 目标文件路径或目标文件描述符。 | 400 | mode | number | 否 | mode提供覆盖文件的选项，当前仅支持0，且默认为0。<br/>0：完全覆盖目标文件，未覆盖部分将被裁切掉。 | 401 402**返回值：** 403 404 | 类型 | 说明 | 405 | ------------------- | ---------------------------- | 406 | Promise<void> | Promise对象。无返回值。 | 407 408**示例：** 409 410 ```js 411 let srcPath = pathDir + "srcDir/test.txt"; 412 let dstPath = pathDir + "dstDir/test.txt"; 413 fileio.copyFile(srcPath, dstPath).then(function () { 414 console.info("copyFile succeed"); 415 }).catch(function (err) { 416 console.info("copyFile failed with error:" + err); 417 }); 418 ``` 419 420 421## fileio.copyFile 422 423copyFile(src: string|number, dest: string|number, mode: number, callback: AsyncCallback<void>): void 424 425复制文件，使用callback异步回调。 426 427**系统能力**：SystemCapability.FileManagement.File.FileIO 428 429**参数：** 430 431 | 参数名 | 类型 | 必填 | 说明 | 432 | -------- | -------------------------- | ---- | ---------------------------------------- | 433 | src | string\|number | 是 | 待复制文件的路径或待复制文件的描述符。 | 434 | dest | string\|number | 是 | 目标文件路径或目标文件描述符。 | 435 | mode | number | 否 | mode提供覆盖文件的选项，当前仅支持0，且默认为0。<br/>0：完全覆盖目标文件，未覆盖部分将被裁切掉。 | 436 | callback | AsyncCallback<void> | 是 | 异步复制文件之后的回调。 | 437 438**示例：** 439 440 ```js 441 let srcPath = pathDir + "srcDir/test.txt"; 442 let dstPath = pathDir + "dstDir/test.txt"; 443 fileio.copyFile(srcPath, dstPath, function (err) { 444 // do something 445 }); 446 ``` 447 448 449## fileio.copyFileSync 450 451copyFileSync(src: string|number, dest: string|number, mode?: number): void 452 453以同步方法复制文件。 454 455**系统能力**：SystemCapability.FileManagement.File.FileIO 456 457**参数：** 458 459 | 参数名 | 类型 | 必填 | 说明 | 460 | ---- | -------------------------- | ---- | ---------------------------------------- | 461 | src | string\|number | 是 | 待复制文件的路径或待复制文件的描述符。 | 462 | dest | string\|number | 是 | 目标文件路径或目标文件描述符。 | 463 | mode | number | 否 | mode提供覆盖文件的选项，当前仅支持0，且默认为0。<br/>0：完全覆盖目标文件，未覆盖部分将被裁切掉。 | 464 465**示例：** 466 467 ```js 468 let srcPath = pathDir + "srcDir/test.txt"; 469 let dstPath = pathDir + "dstDir/test.txt"; 470 fileio.copyFileSync(srcPath, dstPath); 471 ``` 472 473 474## fileio.mkdir 475 476mkdir(path: string, mode?: number): Promise<void> 477 478创建目录，使用Promise异步回调。 479 480**系统能力**：SystemCapability.FileManagement.File.FileIO 481 482**参数：** 483 484| 参数名 | 类型 | 必填 | 说明 | 485| ------ | ------ | ---- | ------------------------------------------------------------ | 486| path | string | 是 | 待创建目录的应用沙箱路径。 | 487| mode | number | 否 | 创建目录的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o775。<br/>- 0o775：所有者具有读、写及可执行权限，其余用户具有读及可执行权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 488 489**返回值：** 490 491 | 类型 | 说明 | 492 | ------------------- | ---------------------------- | 493 | Promise<void> | Promise对象。无返回值。 | 494 495**示例：** 496 497 ```js 498 let dirPath = pathDir + '/testDir'; 499 fileio.mkdir(dirPath).then(function () { 500 console.info("mkdir succeed"); 501 }).catch(function (error) { 502 console.info("mkdir failed with error:" + error); 503 }); 504 ``` 505 506 507## fileio.mkdir 508 509mkdir(path: string, mode: number, callback: AsyncCallback<void>): void 510 511创建目录，使用callback异步回调。 512 513**系统能力**：SystemCapability.FileManagement.File.FileIO 514 515**参数：** 516 517| 参数名 | 类型 | 必填 | 说明 | 518| -------- | ------------------------- | ---- | ------------------------------------------------------------ | 519| path | string | 是 | 待创建目录的应用沙箱路径。 | 520| mode | number | 否 | 创建目录的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o775。<br/>- 0o775：所有者具有读、写及可执行权限，其余用户具有读及可执行权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 521| callback | AsyncCallback<void> | 是 | 异步创建目录操作完成之后的回调。 | 522 523**示例：** 524 525 ```js 526 let dirPath = pathDir + '/testDir'; 527 fileio.mkdir(dirPath, function (err) { 528 console.info("mkdir succeed"); 529 }); 530 ``` 531 532 533## fileio.mkdirSync 534 535mkdirSync(path: string, mode?: number): void 536 537以同步方法创建目录。 538 539**系统能力**：SystemCapability.FileManagement.File.FileIO 540 541**参数：** 542 543| 参数名 | 类型 | 必填 | 说明 | 544| ------ | ------ | ---- | ------------------------------------------------------------ | 545| path | string | 是 | 待创建目录的应用沙箱路径。 | 546| mode | number | 否 | 创建目录的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o775。<br/>- 0o775：所有者具有读、写及可执行权限，其余用户具有读及可执行权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 547 548**示例：** 549 550 ```js 551 let dirPath = path + '/testDir'; 552 fileio.mkdirSync(dirPath); 553 ``` 554 555 556## fileio.open<sup>7+</sup> 557 558open(path: string, flags?: number, mode?: number): Promise<number> 559 560打开文件，使用Promise异步回调。 561 562**系统能力**：SystemCapability.FileManagement.File.FileIO 563 564**参数：** 565 566| 参数名 | 类型 | 必填 | 说明 | 567| ------ | ------ | ---- | ------------------------------------------------------------ | 568| path | string | 是 | 待打开文件的应用沙箱路径。 | 569| flags | number | 否 | 打开文件的选项，必须指定如下选项中的一个，默认以只读方式打开：<br/>- 0o0：只读打开。<br/>- 0o1：只写打开。<br/>- 0o2：读写打开。<br/>同时，也可给定如下选项，以按位或的方式追加，默认不给定任何额外选项：<br/>- 0o100：若文件不存在，则创建文件。使用该选项时必须指定第三个参数 mode。<br/>- 0o200：如果追加了0o100选项，且文件已经存在，则出错。<br/>- 0o1000：如果文件存在且以只写或读写的方式打开文件，则将其长度裁剪为零。<br/>- 0o2000：以追加方式打开，后续写将追加到文件末尾。<br/>- 0o4000：如果path指向FIFO、块特殊文件或字符特殊文件，则本次打开及后续 IO 进行非阻塞操作。<br/>- 0o200000：如果path不指向目录，则出错。<br/>- 0o400000：如果path指向符号链接，则出错。<br/>- 0o4010000：以同步IO的方式打开文件。 | 570| mode | number | 否 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o660。<br/>- 0o660：所有者具有读、写权限，所有用户组具有读、写权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 571 572**返回值：** 573 574 | 类型 | 说明 | 575 | --------------------- | ----------- | 576 | Promise<number> | Promise对象。返回打开文件的文件描述符。 | 577 578**示例：** 579 580 ```js 581 let filePath = pathDir + "/test.txt"; 582 fileio.open(filePath, 0o1, 0o0200).then(function (number) { 583 console.info("open file succeed"); 584 }).catch(function (err) { 585 console.info("open file failed with error:" + err); 586 }); 587 ``` 588 589 590## fileio.open<sup>7+</sup> 591 592open(path: string, flags: number, mode: number, callback: AsyncCallback<number>): void 593 594打开文件，使用callback异步回调。 595 596**系统能力**：SystemCapability.FileManagement.File.FileIO 597 598**参数：** 599 600| 参数名 | 类型 | 必填 | 说明 | 601| -------- | ------------------------------- | ---- | ------------------------------------------------------------ | 602| path | string | 是 | 待打开文件的应用沙箱路径。 | 603| flags | number | 否 | 打开文件的选项，必须指定如下选项中的一个，默认以只读方式打开：<br/>- 0o0：只读打开。<br/>- 0o1：只写打开。<br/>- 0o2：读写打开。<br/>同时，也可给定如下选项，以按位或的方式追加，默认不给定任何额外选项：<br/>- 0o100：若文件不存在，则创建文件。使用该选项时必须指定第三个参数 mode。<br/>- 0o200：如果追加了0o100选项，且文件已经存在，则出错。<br/>- 0o1000：如果文件存在且以只写或读写的方式打开文件，则将其长度裁剪为零。<br/>- 0o2000：以追加方式打开，后续写将追加到文件末尾。<br/>- 0o4000：如果path指向FIFO、块特殊文件或字符特殊文件，则本次打开及后续 IO 进行非阻塞操作。<br/>- 0o200000：如果path不指向目录，则出错。<br/>- 0o400000：如果path指向符号链接，则出错。<br/>- 0o4010000：以同步IO的方式打开文件。 | 604| mode | number | 否 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o660。<br/>- 0o660：所有者具有读、写权限，所有用户组具有读、写权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 605| callback | AsyncCallback<number> | 是 | 异步打开文件之后的回调。 | 606 607**示例：** 608 609 ```js 610 let filePath = pathDir + "/test.txt"; 611 fileio.open(filePath, 0, function (err, fd) { 612 // do something 613 }); 614 ``` 615 616 617## fileio.openSync 618 619openSync(path: string, flags?: number, mode?: number): number 620 621以同步方法打开文件。 622 623**系统能力**：SystemCapability.FileManagement.File.FileIO 624 625**参数：** 626 627| 参数名 | 类型 | 必填 | 说明 | 628| ------ | ------ | ---- | ------------------------------------------------------------ | 629| path | string | 是 | 待打开文件的应用沙箱路径。 | 630| flags | number | 否 | 打开文件的选项，必须指定如下选项中的一个，默认以只读方式打开：<br/>- 0o0：只读打开。<br/>- 0o1：只写打开。<br/>- 0o2：读写打开。<br/>同时，也可给定如下选项，以按位或的方式追加，默认不给定任何额外选项：<br/>- 0o100：若文件不存在，则创建文件。使用该选项时必须指定第三个参数 mode。<br/>- 0o200：如果追加了0o100选项，且文件已经存在，则出错。<br/>- 0o1000：如果文件存在且以只写或读写的方式打开文件，则将其长度裁剪为零。<br/>- 0o2000：以追加方式打开，后续写将追加到文件末尾。<br/>- 0o4000：如果path指向FIFO、块特殊文件或字符特殊文件，则本次打开及后续 IO 进行非阻塞操作。<br/>- 0o200000：如果path不指向目录，则出错。<br/>- 0o400000：如果path指向符号链接，则出错。<br/>- 0o4010000：以同步IO的方式打开文件。 | 631| mode | number | 否 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限，默认给定0o660。<br/>- 0o660：所有者具有读、写权限，所有用户组具有读、写权限。<br/>- 0o640：所有者具有读、写权限，所有用户组具有读权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。<br/>创建出的文件权限受umask影响，umask随进程启动确定，其修改当前不开放。 | 632 633**返回值：** 634 635 | 类型 | 说明 | 636 | ------ | ----------- | 637 | number | 打开文件的文件描述符。 | 638 639**示例：** 640 641 ```js 642 let filePath = pathDir + "/test.txt"; 643 let fd = fileio.openSync(filePath, 0o102, 0o640); 644 ``` 645 ```js 646 let filePath = pathDir + "/test.txt"; 647 let fd = fileio.openSync(filePath, 0o102, 0o666); 648 fileio.writeSync(fd, 'hello world'); 649 let fd1 = fileio.openSync(filePath, 0o2002); 650 fileio.writeSync(fd1, 'hello world'); 651 let num = fileio.readSync(fd1, new ArrayBuffer(4096), {position: 0}); 652 console.info("num == " + num); 653 ``` 654 655 656## fileio.read 657 658read(fd: number, buffer: ArrayBuffer, options?: { offset?: number; length?: number; position?: number; }): Promise<ReadOut> 659 660从文件读取数据，使用Promise异步回调。 661 662**系统能力**：SystemCapability.FileManagement.File.FileIO 663 664**参数：** 665 666| 参数名 | 类型 | 必填 | 说明 | 667| ------- | ----------- | ---- | ------------------------------------------------------------ | 668| fd | number | 是 | 待读取文件的文件描述符。 | 669| buffer | ArrayBuffer | 是 | 用于保存读取到的文件数据的缓冲区。 | 670| options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 671 672**返回值：** 673 674 | 类型 | 说明 | 675 | ---------------------------------- | ------ | 676 | Promise<[ReadOut](#readout)> | Promise对象。返回读取的结果。 | 677 678**示例：** 679 680 ```js 681 let filePath = pathDir + "/test.txt"; 682 let fd = fileio.openSync(filePath, 0o2); 683 let buf = new ArrayBuffer(4096); 684 fileio.read(fd, buf).then(function (readOut) { 685 console.info("read file data succeed"); 686 console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer))); 687 }).catch(function (err) { 688 console.info("read file data failed with error:" + err); 689 }); 690 ``` 691 692 693## fileio.read 694 695read(fd: number, buffer: ArrayBuffer, options: { offset?: number; length?: number; position?: number; }, callback: AsyncCallback<ReadOut>): void 696 697从文件读取数据，使用callback异步回调。 698 699**系统能力**：SystemCapability.FileManagement.File.FileIO 700 701**参数：** 702 703 | 参数名 | 类型 | 必填 | 说明 | 704 | -------- | ---------------------------------------- | ---- | ---------------------------------------- | 705 | fd | number | 是 | 待读取文件的文件描述符。 | 706 | buffer | ArrayBuffer | 是 | 用于保存读取到的文件数据的缓冲区。 | 707 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 708 | callback | AsyncCallback<[ReadOut](#readout)> | 是 | 异步读取数据之后的回调。 | 709 710**示例：** 711 712 ```js 713 let filePath = pathDir + "/test.txt"; 714 let fd = fileio.openSync(filePath, 0o2); 715 let buf = new ArrayBuffer(4096); 716 fileio.read(fd, buf, function (err, readOut) { 717 if (readOut) { 718 console.info("read file data succeed"); 719 console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer))); 720 } 721 }); 722 ``` 723 724 725## fileio.readSync 726 727readSync(fd: number, buffer: ArrayBuffer, options?: { offset?: number; length?: number; position?: number; }): number 728 729以同步方法从文件读取数据。 730 731**系统能力**：SystemCapability.FileManagement.File.FileIO 732 733**参数：** 734 735 | 参数名 | 类型 | 必填 | 说明 | 736 | ------- | ----------- | ---- | ---------------------------------------- | 737 | fd | number | 是 | 待读取文件的文件描述符。 | 738 | buffer | ArrayBuffer | 是 | 用于保存读取到的文件数据的缓冲区。 | 739 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 740 741**返回值：** 742 743 | 类型 | 说明 | 744 | ------ | -------- | 745 | number | 实际读取的长度。 | 746 747**示例：** 748 749 ```js 750 let filePath = pathDir + "/test.txt"; 751 let fd = fileio.openSync(filePath, 0o2); 752 let buf = new ArrayBuffer(4096); 753 let num = fileio.readSync(fd, buf); 754 ``` 755 756 757## fileio.rmdir<sup>7+</sup> 758 759rmdir(path: string): Promise<void> 760 761删除目录，使用Promise异步回调。 762 763**系统能力**：SystemCapability.FileManagement.File.FileIO 764 765**参数：** 766 767| 参数名 | 类型 | 必填 | 说明 | 768| ------ | ------ | ---- | -------------------------- | 769| path | string | 是 | 待删除目录的应用沙箱路径。 | 770 771**返回值：** 772 773 | 类型 | 说明 | 774 | ------------------- | ---------------------------- | 775 | Promise<void> | Promise对象。无返回值。 | 776 777**示例：** 778 779 ```js 780 let dirPath = pathDir + '/testDir'; 781 fileio.rmdir(dirPath).then(function () { 782 console.info("rmdir succeed"); 783 }).catch(function (err) { 784 console.info("rmdir failed with error:" + err); 785 }); 786 ``` 787 788 789## fileio.rmdir<sup>7+</sup> 790 791rmdir(path: string, callback: AsyncCallback<void>): void 792 793删除目录，使用callback异步回调。 794 795**系统能力**：SystemCapability.FileManagement.File.FileIO 796 797**参数：** 798 799| 参数名 | 类型 | 必填 | 说明 | 800| -------- | ------------------------- | ---- | -------------------------- | 801| path | string | 是 | 待删除目录的应用沙箱路径。 | 802| callback | AsyncCallback<void> | 是 | 异步删除目录之后的回调。 | 803 804**示例：** 805 806 ```js 807 let dirPath = pathDir + '/testDir'; 808 fileio.rmdir(dirPath, function (err) { 809 // do something 810 console.info("rmdir succeed"); 811 }); 812 ``` 813 814 815## fileio.rmdirSync<sup>7+</sup> 816 817rmdirSync(path: string): void 818 819以同步方法删除目录。 820 821**系统能力**：SystemCapability.FileManagement.File.FileIO 822 823**参数：** 824 825| 参数名 | 类型 | 必填 | 说明 | 826| ------ | ------ | ---- | -------------------------- | 827| path | string | 是 | 待删除目录的应用沙箱路径。 | 828 829**示例：** 830 831 ```js 832 let dirPath = pathDir + '/testDir'; 833 fileio.rmdirSync(dirPath); 834 ``` 835 836 837## fileio.unlink 838 839unlink(path: string): Promise<void> 840 841删除文件，使用Promise异步回调。 842 843**系统能力**：SystemCapability.FileManagement.File.FileIO 844 845**参数：** 846 847| 参数名 | 类型 | 必填 | 说明 | 848| ------ | ------ | ---- | -------------------------- | 849| path | string | 是 | 待删除文件的应用沙箱路径。 | 850 851**返回值：** 852 853 | 类型 | 说明 | 854 | ------------------- | ---------------------------- | 855 | Promise<void> | Promise对象。无返回值。 | 856 857**示例：** 858 859 ```js 860 let filePath = pathDir + "/test.txt"; 861 fileio.unlink(filePath).then(function () { 862 console.info("remove file succeed"); 863 }).catch(function (error) { 864 console.info("remove file failed with error:" + error); 865 }); 866 ``` 867 868 869## fileio.unlink 870 871unlink(path: string, callback: AsyncCallback<void>): void 872 873删除文件，使用callback异步回调。 874 875**系统能力**：SystemCapability.FileManagement.File.FileIO 876 877**参数：** 878 879| 参数名 | 类型 | 必填 | 说明 | 880| -------- | ------------------------- | ---- | -------------------------- | 881| path | string | 是 | 待删除文件的应用沙箱路径。 | 882| callback | AsyncCallback<void> | 是 | 异步删除文件之后的回调。 | 883 884**示例：** 885 886 ```js 887 let filePath = pathDir + "/test.txt"; 888 fileio.unlink(filePath, function (err) { 889 console.info("remove file succeed"); 890 }); 891 ``` 892 893 894## fileio.unlinkSync 895 896unlinkSync(path: string): void 897 898以同步方法删除文件。 899 900**系统能力**：SystemCapability.FileManagement.File.FileIO 901 902**参数：** 903 904| 参数名 | 类型 | 必填 | 说明 | 905| ------ | ------ | ---- | -------------------------- | 906| path | string | 是 | 待删除文件的应用沙箱路径。 | 907 908**示例：** 909 910 ```js 911 let filePath = pathDir + "/test.txt"; 912 fileio.unlinkSync(filePath); 913 ``` 914 915 916## fileio.write 917 918write(fd: number, buffer: ArrayBuffer|string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): Promise<number> 919 920将数据写入文件，使用Promise异步回调。 921 922**系统能力**：SystemCapability.FileManagement.File.FileIO 923 924**参数：** 925 926 | 参数名 | 类型 | 必填 | 说明 | 927 | ------- | ------------------------------- | ---- | ---------------------------------------- | 928 | fd | number | 是 | 待写入文件的文件描述符。 | 929 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 930 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 931 932**返回值：** 933 934 | 类型 | 说明 | 935 | --------------------- | -------- | 936 | Promise<number> | Promise对象。返回实际写入的长度。 | 937 938**示例：** 939 940 ```js 941 let filePath = pathDir + "/test.txt"; 942 let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666); 943 fileio.write(fd, "hello, world").then(function (number) { 944 console.info("write data to file succeed and size is:" + number); 945 }).catch(function (err) { 946 console.info("write data to file failed with error:" + err); 947 }); 948 ``` 949 950 951## fileio.write 952 953write(fd: number, buffer: ArrayBuffer|string, options: { offset?: number; length?: number; position?: number; encoding?: string; }, callback: AsyncCallback<number>): void 954 955将数据写入文件，使用callback异步回调。 956 957**系统能力**：SystemCapability.FileManagement.File.FileIO 958 959**参数：** 960 961 | 参数名 | 类型 | 必填 | 说明 | 962 | -------- | ------------------------------- | ---- | ---------------------------------------- | 963 | fd | number | 是 | 待写入文件的文件描述符。 | 964 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 965 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 966 | callback | AsyncCallback<number> | 是 | 异步将数据写入完成后执行的回调函数。 | 967 968**示例：** 969 970 ```js 971 let filePath = pathDir + "/test.txt"; 972 let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666); 973 fileio.write(fd, "hello, world", function (err, bytesWritten) { 974 if (bytesWritten) { 975 console.info("write data to file succeed and size is:" + bytesWritten); 976 } 977 }); 978 ``` 979 980 981## fileio.writeSync 982 983writeSync(fd: number, buffer: ArrayBuffer|string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): number 984 985以同步方法将数据写入文件。 986 987**系统能力**：SystemCapability.FileManagement.File.FileIO 988 989**参数：** 990 991 | 参数名 | 类型 | 必填 | 说明 | 992 | ------- | ------------------------------- | ---- | ---------------------------------------- | 993 | fd | number | 是 | 待写入文件的文件描述符。 | 994 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 995 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 996 997**返回值：** 998 999 | 类型 | 说明 | 1000 | ------ | -------- | 1001 | number | 实际写入的长度。 | 1002 1003**示例：** 1004 1005 ```js 1006 let filePath = pathDir + "/test.txt"; 1007 let fd = fileio.openSync(filePath, 0o100 | 0o2, 0o666); 1008 let num = fileio.writeSync(fd, "hello, world"); 1009 ``` 1010 1011 1012## fileio.hash 1013 1014hash(path: string, algorithm: string): Promise<string> 1015 1016计算文件的哈希值，使用Promise异步回调。 1017 1018**系统能力**：SystemCapability.FileManagement.File.FileIO 1019 1020**参数：** 1021 1022| 参数名 | 类型 | 必填 | 说明 | 1023| --------- | ------ | ---- | ------------------------------------------------------------ | 1024| path | string | 是 | 待计算哈希值文件的应用沙箱路径。 | 1025| algorithm | string | 是 | 哈希计算采用的算法。可选 "md5"、"sha1" 或 "sha256"。建议采用安全强度更高的 "sha256"。 | 1026 1027**返回值：** 1028 1029 | 类型 | 说明 | 1030 | --------------------- | -------------------------- | 1031 | Promise<string> | Promise对象。返回文件的哈希值。表示为十六进制数字串，所有字母均大写。 | 1032 1033**示例：** 1034 1035 ```js 1036 let filePath = pathDir + "/test.txt"; 1037 fileio.hash(filePath, "sha256").then(function (str) { 1038 console.info("calculate file hash succeed:" + str); 1039 }).catch(function (err) { 1040 console.info("calculate file hash failed with error:" + err); 1041 }); 1042 ``` 1043 1044 1045## fileio.hash 1046 1047hash(path: string, algorithm: string, callback: AsyncCallback<string>): void 1048 1049计算文件的哈希值，使用callback异步回调。 1050 1051**系统能力**：SystemCapability.FileManagement.File.FileIO 1052 1053**参数：** 1054 1055| 参数名 | 类型 | 必填 | 说明 | 1056| --------- | --------------------------- | ---- | ------------------------------------------------------------ | 1057| path | string | 是 | 待计算哈希值文件的应用沙箱路径。 | 1058| algorithm | string | 是 | 哈希计算采用的算法。可选 "md5"、"sha1" 或 "sha256"。建议采用安全强度更高的 "sha256"。 | 1059| callback | AsyncCallback<string> | 是 | 异步计算文件哈希操作之后的回调函数（其中给定文件哈希值表示为十六进制数字串，所有字母均大写）。 | 1060 1061**示例：** 1062 1063 ```js 1064 let filePath = pathDir + "/test.txt"; 1065 fileio.hash(filePath, "sha256", function (err, hashStr) { 1066 if (hashStr) { 1067 console.info("calculate file hash succeed:" + hashStr); 1068 } 1069 }); 1070 ``` 1071 1072 1073## fileio.chmod<sup>7+</sup> 1074 1075chmod(path: string, mode: number): Promise<void> 1076 1077改变文件权限，使用Promise异步回调。 1078 1079**系统能力**：SystemCapability.FileManagement.File.FileIO 1080 1081**参数：** 1082 1083| 参数名 | 类型 | 必填 | 说明 | 1084| ------ | ------ | ---- | ------------------------------------------------------------ | 1085| path | string | 是 | 所需变更权限的文件的应用沙箱路径。 | 1086| mode | number | 是 | 改变文件权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 1087 1088**返回值：** 1089 1090 | 类型 | 说明 | 1091 | ------------------- | ---------------------------- | 1092 | Promise<void> | Promise对象。无返回值。 | 1093 1094**示例：** 1095 1096 ```js 1097 let filePath = pathDir + "/test.txt"; 1098 fileio.chmod(filePath, 0o700).then(function () { 1099 console.info("chmod succeed"); 1100 }).catch(function (err) { 1101 console.info("chmod failed with error:" + err); 1102 }); 1103 ``` 1104 1105 1106## fileio.chmod<sup>7+</sup> 1107 1108chmod(path: string, mode: number, callback: AsyncCallback<void>): void 1109 1110改变文件权限，使用callback异步回调。 1111 1112**系统能力**：SystemCapability.FileManagement.File.FileIO 1113 1114**参数：** 1115 1116| 参数名 | 类型 | 必填 | 说明 | 1117| -------- | ------------------------- | ---- | ------------------------------------------------------------ | 1118| path | string | 是 | 所需变更权限的文件的应用沙箱路径。 | 1119| mode | number | 是 | 改变文件权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 1120| callback | AsyncCallback<void> | 是 | 异步改变文件权限之后的回调。 | 1121 1122**示例：** 1123 1124 ```js 1125 let filePath = pathDir + "/test.txt"; 1126 fileio.chmod(filePath, 0o700, function (err) { 1127 // do something 1128 }); 1129 ``` 1130 1131 1132## fileio.chmodSync<sup>7+</sup> 1133 1134chmodSync(path: string, mode: number): void 1135 1136以同步方法改变文件权限。 1137 1138**系统能力**：SystemCapability.FileManagement.File.FileIO 1139 1140**参数：** 1141 1142| 参数名 | 类型 | 必填 | 说明 | 1143| ------ | ------ | ---- | ------------------------------------------------------------ | 1144| path | string | 是 | 所需变更权限的文件的应用沙箱路径。 | 1145| mode | number | 是 | 改变文件权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 1146 1147**示例：** 1148 1149 ```js 1150 let filePath = pathDir + "/test.txt"; 1151 fileio.chmodSync(filePath, 0o700); 1152 ``` 1153 1154 1155## fileio.fstat<sup>7+</sup> 1156 1157fstat(fd: number): Promise<Stat> 1158 1159基于文件描述符获取文件状态信息，使用Promise异步回调。 1160 1161**系统能力**：SystemCapability.FileManagement.File.FileIO 1162 1163**参数：** 1164 1165 | 参数名 | 类型 | 必填 | 说明 | 1166 | ---- | ------ | ---- | ------------ | 1167 | fd | number | 是 | 待获取文件状态的文件描述符。 | 1168 1169**返回值：** 1170 1171 | 类型 | 说明 | 1172 | ---------------------------- | ---------- | 1173 | Promise<[Stat](#stat)> | Promise对象。返回表示文件状态的具体信息。 | 1174 1175**示例：** 1176 1177 ```js 1178 let filePath = pathDir + "/test.txt"; 1179 let fd = fileio.openSync(filePath); 1180 fileio.fstat(fd).then(function (stat) { 1181 console.info("fstat succeed, the size of file is " + stat.size); 1182 }).catch(function (err) { 1183 console.info("fstat failed with error:" + err); 1184 }); 1185 ``` 1186 1187 1188## fileio.fstat<sup>7+</sup> 1189 1190fstat(fd: number, callback: AsyncCallback<Stat>): void 1191 1192基于文件描述符获取文件状态信息，使用callback异步回调。 1193 1194**系统能力**：SystemCapability.FileManagement.File.FileIO 1195 1196**参数：** 1197 1198 | 参数名 | 类型 | 必填 | 说明 | 1199 | -------- | ---------------------------------- | ---- | ---------------- | 1200 | fd | number | 是 | 待获取文件状态的文件描述符。 | 1201 | callback | AsyncCallback<[Stat](#stat)> | 是 | 异步获取文件状态信息之后的回调。 | 1202 1203**示例：** 1204 1205 ```js 1206 let filePath = pathDir + "/test.txt"; 1207 let fd = fileio.openSync(filePath); 1208 fileio.fstat(fd, function (err) { 1209 // do something 1210 }); 1211 ``` 1212 1213 1214## fileio.fstatSync<sup>7+</sup> 1215 1216fstatSync(fd: number): Stat 1217 1218以同步方法基于文件描述符获取文件状态信息。 1219 1220**系统能力**：SystemCapability.FileManagement.File.FileIO 1221 1222**参数：** 1223 1224 | 参数名 | 类型 | 必填 | 说明 | 1225 | ---- | ------ | ---- | ------------ | 1226 | fd | number | 是 | 待获取文件状态的文件描述符。 | 1227 1228**返回值：** 1229 1230 | 类型 | 说明 | 1231 | ------------- | ---------- | 1232 | [Stat](#stat) | 表示文件状态的具体信息。 | 1233 1234**示例：** 1235 1236 ```js 1237 let filePath = pathDir + "/test.txt"; 1238 let fd = fileio.openSync(filePath); 1239 let stat = fileio.fstatSync(fd); 1240 ``` 1241 1242 1243## fileio.ftruncate<sup>7+</sup> 1244 1245ftruncate(fd: number, len?: number): Promise<void> 1246 1247基于文件描述符截断文件，使用Promise异步回调。 1248 1249**系统能力**：SystemCapability.FileManagement.File.FileIO 1250 1251**参数：** 1252 1253 | 参数名 | 类型 | 必填 | 说明 | 1254 | ---- | ------ | ---- | ---------------- | 1255 | fd | number | 是 | 待截断文件的文件描述符。 | 1256 | len | number | 否 | 文件截断后的长度，以字节为单位。 | 1257 1258**返回值：** 1259 1260 | 类型 | 说明 | 1261 | ------------------- | ---------------------------- | 1262 | Promise<void> | Promise对象。无返回值。| 1263 1264**示例：** 1265 1266 ```js 1267 let filePath = pathDir + "/test.txt"; 1268 let fd = fileio.openSync(filePath); 1269 fileio.ftruncate(fd, 5).then(function (err) { 1270 console.info("truncate file succeed"); 1271 }).catch(function (err) { 1272 console.info("truncate file failed with error:" + err); 1273 }); 1274 ``` 1275 1276 1277## fileio.ftruncate<sup>7+</sup> 1278 1279ftruncate(fd: number, len?: number, callback: AsyncCallback<void>): void 1280 1281基于文件描述符截断文件，使用callback异步回调。 1282 1283**系统能力**：SystemCapability.FileManagement.File.FileIO 1284 1285**参数：** 1286 1287 | 参数名 | 类型 | 必填 | 说明 | 1288 | -------- | ------------------------- | ---- | ---------------- | 1289 | fd | number | 是 | 待截断文件的文件描述符。 | 1290 | len | number | 否 | 文件截断后的长度，以字节为单位。 | 1291 | callback | AsyncCallback<void> | 是 | 回调函数，本调用无返回值。 | 1292 1293**示例：** 1294 1295 ```js 1296 let filePath = pathDir + "/test.txt"; 1297 let fd = fileio.openSync(filePath); 1298 let len = 5; 1299 fileio.ftruncate(fd, 5, function (err) { 1300 // do something 1301 }); 1302 ``` 1303 1304 1305## fileio.ftruncateSync<sup>7+</sup> 1306 1307ftruncateSync(fd: number, len?: number): void 1308 1309以同步方法基于文件描述符截断文件。 1310 1311**系统能力**：SystemCapability.FileManagement.File.FileIO 1312 1313**参数：** 1314 1315 | 参数名 | 类型 | 必填 | 说明 | 1316 | ---- | ------ | ---- | ---------------- | 1317 | fd | number | 是 | 待截断文件的文件描述符。 | 1318 | len | number | 否 | 文件截断后的长度，以字节为单位。 | 1319 1320**示例：** 1321 1322 ```js 1323 let filePath = pathDir + "/test.txt"; 1324 let fd = fileio.openSync(filePath); 1325 let len = 5; 1326 fileio.ftruncateSync(fd, len); 1327 ``` 1328 1329 1330## fileio.truncate<sup>7+</sup> 1331 1332truncate(path: string, len?: number): Promise<void> 1333 1334基于文件路径截断文件，使用Promise异步回调。 1335 1336**系统能力**：SystemCapability.FileManagement.File.FileIO 1337 1338**参数：** 1339 1340| 参数名 | 类型 | 必填 | 说明 | 1341| ------ | ------ | ---- | -------------------------------- | 1342| path | string | 是 | 待截断文件的应用沙箱路径。 | 1343| len | number | 否 | 文件截断后的长度，以字节为单位。 | 1344 1345**返回值：** 1346 1347 | 类型 | 说明 | 1348 | ------------------- | ---------------------------- | 1349 | Promise<void> | Promise对象。无返回值。 | 1350 1351**示例：** 1352 1353 ```js 1354 let filePath = pathDir + "/test.txt"; 1355 let len = 5; 1356 fileio.truncate(filePath, len).then(function () { 1357 console.info("truncate file succeed"); 1358 }).catch(function (err) { 1359 console.info("truncate file failed with error:" + err); 1360 }); 1361 ``` 1362 1363 1364## fileio.truncate<sup>7+</sup> 1365 1366truncate(path: string, len?: number, callback: AsyncCallback<void>): void 1367 1368基于文件路径截断文件，使用callback异步回调。 1369 1370**系统能力**：SystemCapability.FileManagement.File.FileIO 1371 1372**参数：** 1373 1374| 参数名 | 类型 | 必填 | 说明 | 1375| -------- | ------------------------- | ---- | -------------------------------- | 1376| path | string | 是 | 待截断文件的应用沙箱路径。 | 1377| len | number | 否 | 文件截断后的长度，以字节为单位。 | 1378| callback | AsyncCallback<void> | 是 | 回调函数，本调用无返回值。 | 1379 1380**示例：** 1381 1382 ```js 1383 let filePath = pathDir + "/test.txt"; 1384 let len = 5; 1385 fileio.truncate(filePath, len, function (err) { 1386 // do something 1387 }); 1388 ``` 1389 1390 1391## fileio.truncateSync<sup>7+</sup> 1392 1393truncateSync(path: string, len?: number): void 1394 1395以同步方法基于文件路径截断文件。 1396 1397**系统能力**：SystemCapability.FileManagement.File.FileIO 1398 1399**参数：** 1400 1401| 参数名 | 类型 | 必填 | 说明 | 1402| ------ | ------ | ---- | -------------------------------- | 1403| path | string | 是 | 待截断文件的应用沙箱路径。 | 1404| len | number | 否 | 文件截断后的长度，以字节为单位。 | 1405 1406**示例：** 1407 1408 ```js 1409 let filePath = pathDir + "/test.txt"; 1410 let len = 5; 1411 fileio.truncateSync(filePath, len); 1412 ``` 1413 1414 1415## fileio.readText<sup>7+</sup> 1416 1417readText(filePath: string, options?: { position?: number; length?: number; encoding?: string; }): Promise<string> 1418 1419基于文本方式读取文件（即直接读取文件的文本内容），使用Promise异步回调。 1420 1421**系统能力**：SystemCapability.FileManagement.File.FileIO 1422 1423**参数：** 1424 1425| 参数名 | 类型 | 必填 | 说明 | 1426| -------- | ------ | ---- | ------------------------------------------------------------ | 1427| filePath | string | 是 | 待读取文件的应用沙箱路径。 | 1428| options | Object | 否 | 支持如下选项：<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读取。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- encoding，string类型，当数据是 string 类型时有效，表示数据的编码方式，默认 'utf-8'，仅支持 'utf-8'。 | 1429 1430**返回值：** 1431 1432 | 类型 | 说明 | 1433 | --------------------- | ---------- | 1434 | Promise<string> | Promise对象。返回读取文件的内容。 | 1435 1436**示例：** 1437 1438 ```js 1439 let filePath = pathDir + "/test.txt"; 1440 fileio.readText(filePath).then(function (str) { 1441 console.info("readText succeed:" + str); 1442 }).catch(function (err) { 1443 console.info("readText failed with error:" + err); 1444 }); 1445 ``` 1446 1447 1448## fileio.readText<sup>7+</sup> 1449 1450readText(filePath: string, options: { position?: number; length?: number; encoding?: string; }, callback: AsyncCallback<string>): void 1451 1452基于文本方式读取文件（即直接读取文件的文本内容），使用callback异步回调。 1453 1454**系统能力**：SystemCapability.FileManagement.File.FileIO 1455 1456**参数：** 1457 1458| 参数名 | 类型 | 必填 | 说明 | 1459| -------- | --------------------------- | ---- | ------------------------------------------------------------ | 1460| filePath | string | 是 | 待读取文件的应用沙箱路径。 | 1461| options | Object | 否 | 支持如下选项：<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读取。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- encoding，string类型，表示数据的编码方式，默认 'utf-8'，仅支持 'utf-8'。 | 1462| callback | AsyncCallback<string> | 是 | 回调函数，返回读取文件的内容。 | 1463 1464**示例：** 1465 1466 ```js 1467 let filePath = pathDir + "/test.txt"; 1468 fileio.readText(filePath, { position: 1, encoding: 'UTF-8' }, function (err, str) { 1469 // do something 1470 }); 1471 ``` 1472 1473 1474## fileio.readTextSync<sup>7+</sup> 1475 1476readTextSync(filePath: string, options?: { position?: number; length?: number; encoding?: string; }): string 1477 1478以同步方法基于文本方式读取文件（即直接读取文件的文本内容）。 1479 1480**系统能力**：SystemCapability.FileManagement.File.FileIO 1481 1482**参数：** 1483 1484| 参数名 | 类型 | 必填 | 说明 | 1485| -------- | ------ | ---- | ------------------------------------------------------------ | 1486| filePath | string | 是 | 待读取文件的应用沙箱路径。 | 1487| options | Object | 否 | 支持如下选项：<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读取。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- encoding，string类型，当数据是 string 类型时有效，表示数据的编码方式，默认 'utf-8'，仅支持 'utf-8'。 | 1488 1489**返回值：** 1490 1491 | 类型 | 说明 | 1492 | ------ | -------------------- | 1493 | string | 返回读取文件的内容。 | 1494 1495**示例：** 1496 1497 ```js 1498 let filePath = pathDir + "/test.txt"; 1499 let str = fileio.readTextSync(filePath, {position: 1, length: 3}); 1500 ``` 1501 1502 1503## fileio.lstat<sup>7+</sup> 1504 1505lstat(path: string): Promise<Stat> 1506 1507获取链接信息，使用Promise异步回调。 1508 1509**系统能力**：SystemCapability.FileManagement.File.FileIO 1510 1511**参数：** 1512 1513| 参数名 | 类型 | 必填 | 说明 | 1514| ------ | ------ | ---- | -------------------------------------- | 1515| path | string | 是 | 目标文件的应用沙箱路径。 | 1516 1517**返回值：** 1518 1519 | 类型 | 说明 | 1520 | ---------------------------- | ---------- | 1521 | Promise<[Stat](#stat)> | promise对象，返回文件对象，表示文件的具体信息，详情见stat。 | 1522 1523**示例：** 1524 1525 ```js 1526 let filePath = pathDir + "/test.txt"; 1527 fileio.lstat(filePath).then(function (stat) { 1528 console.info("get link status succeed, the size of file is" + stat.size); 1529 }).catch(function (err) { 1530 console.info("get link status failed with error:" + err); 1531 }); 1532 ``` 1533 1534 1535## fileio.lstat<sup>7+</sup> 1536 1537lstat(path: string, callback: AsyncCallback<Stat>): void 1538 1539获取链接信息，使用callback异步回调。 1540 1541**系统能力**：SystemCapability.FileManagement.File.FileIO 1542 1543**参数：** 1544 1545| 参数名 | 类型 | 必填 | 说明 | 1546| -------- | ---------------------------------- | ---- | -------------------------------------- | 1547| path | string | 是 | 目标文件的应用沙箱路径。 | 1548| callback | AsyncCallback<[Stat](#stat)> | 是 | 回调函数，返回文件的具体信息。 | 1549 1550**示例：** 1551 1552 ```js 1553 let filePath = pathDir + "/test.txt"; 1554 fileio.lstat(filePath, function (err, stat) { 1555 // do something 1556 }); 1557 ``` 1558 1559 1560## fileio.lstatSync<sup>7+</sup> 1561 1562lstatSync(path: string): Stat 1563 1564以同步方法获取链接信息。 1565 1566**系统能力**：SystemCapability.FileManagement.File.FileIO 1567 1568**参数：** 1569 1570| 参数名 | 类型 | 必填 | 说明 | 1571| ------ | ------ | ---- | -------------------------------------- | 1572| path | string | 是 | 目标文件的应用沙箱路径。 | 1573 1574**返回值：** 1575 1576 | 类型 | 说明 | 1577 | ------------- | ---------- | 1578 | [Stat](#stat) | 表示文件的具体信息。 | 1579 1580**示例：** 1581 1582 ```js 1583 let filePath = pathDir + "/test.txt"; 1584 let stat = fileio.lstatSync(filePath); 1585 ``` 1586 1587 1588## fileio.rename<sup>7+</sup> 1589 1590rename(oldPath: string, newPath: string): Promise<void> 1591 1592重命名文件，使用Promise异步回调。 1593 1594**系统能力**：SystemCapability.FileManagement.File.FileIO 1595 1596**参数：** 1597 1598| 参数名 | 类型 | 必填 | 说明 | 1599| ------- | ------ | ---- | ---------------------------- | 1600| oldPath | string | 是 | 目标文件的当前应用沙箱路径。 | 1601| newPath | string | 是 | 目标文件的新应用沙箱路径。 | 1602 1603**返回值：** 1604 1605 | 类型 | 说明 | 1606 | ------------------- | ---------------------------- | 1607 | Promise<void> | Promise对象。无返回值。 | 1608 1609**示例：** 1610 1611 ```js 1612 let srcFile = pathDir + "/test.txt"; 1613 let dstFile = pathDir + '/new.txt'; 1614 fileio.rename(srcFile, dstFile).then(function () { 1615 console.info("rename succeed"); 1616 }).catch(function (err) { 1617 console.info("rename failed with error:" + err); 1618 }); 1619 ``` 1620 1621 1622## fileio.rename<sup>7+</sup> 1623 1624rename(oldPath: string, newPath: string, callback: AsyncCallback<void>): void 1625 1626重命名文件，使用callback异步回调。 1627 1628**系统能力**：SystemCapability.FileManagement.File.FileIO 1629 1630**参数：** 1631 1632| 参数名 | 类型 | 必填 | 说明 | 1633| -------- | ------------------------- | ---- | ---------------------------- | 1634| oldPath | string | 是 | 目标文件的当前应用沙箱路径。 | 1635| newPath | string | 是 | 目标文件的新应用沙箱路径。 | 1636| callback | AsyncCallback<void> | 是 | 异步重命名文件之后的回调。 | 1637 1638**示例：** 1639 1640 ```js 1641 let srcFile = pathDir + "/test.txt"; 1642 let dstFile = pathDir + '/new.txt'; 1643 fileio.rename(srcFile, dstFile, function (err) { 1644 }); 1645 ``` 1646 1647 1648## fileio.renameSync<sup>7+</sup> 1649 1650renameSync(oldPath: string, newPath: string): void 1651 1652以同步方法重命名文件。 1653 1654**系统能力**：SystemCapability.FileManagement.File.FileIO 1655 1656**参数：** 1657 1658| 参数名 | 类型 | 必填 | 说明 | 1659| ------- | ------ | ---- | ---------------------------- | 1660| oldPath | string | 是 | 目标文件的当前应用沙箱路径。 | 1661| newPath | string | 是 | 目标文件的新应用沙箱路径。 | 1662 1663**示例：** 1664 1665 ```js 1666 let srcFile = pathDir + "/test.txt"; 1667 let dstFile = pathDir + '/new.txt'; 1668 fileio.renameSync(srcFile, dstFile); 1669 ``` 1670 1671 1672## fileio.fsync<sup>7+</sup> 1673 1674fsync(fd: number): Promise<void> 1675 1676同步文件数据，使用Promise异步回调。 1677 1678**系统能力**：SystemCapability.FileManagement.File.FileIO 1679 1680**参数：** 1681 1682 | 参数名 | 类型 | 必填 | 说明 | 1683 | ---- | ------ | ---- | ------------ | 1684 | fd | number | 是 | 待同步文件的文件描述符。 | 1685 1686**返回值：** 1687 1688 | 类型 | 说明 | 1689 | ------------------- | ---------------------------- | 1690 | Promise<void> | Promise对象。无返回值。 | 1691 1692**示例：** 1693 1694 ```js 1695 let filePath = pathDir + "/test.txt"; 1696 let fd = fileio.openSync(filePath); 1697 fileio.fsync(fd).then(function () { 1698 console.info("sync data succeed"); 1699 }).catch(function (err) { 1700 console.info("sync data failed with error:" + err); 1701 }); 1702 ``` 1703 1704 1705## fileio.fsync<sup>7+</sup> 1706 1707fsync(fd: number, callback: AsyncCallback<void>): void 1708 1709同步文件数据，使用callback异步回调。 1710 1711**系统能力**：SystemCapability.FileManagement.File.FileIO 1712 1713**参数：** 1714 1715 | 参数名 | 类型 | 必填 | 说明 | 1716 | -------- | ------------------------- | ---- | --------------- | 1717 | fd | number | 是 | 待同步文件的文件描述符。 | 1718 | Callback | AsyncCallback<void> | 是 | 异步将文件数据同步之后的回调。 | 1719 1720**示例：** 1721 1722 ```js 1723 let filePath = pathDir + "/test.txt"; 1724 let fd = fileio.openSync(filePath); 1725 fileio.fsync(fd, function (err) { 1726 // do something 1727 }); 1728 ``` 1729 1730 1731## fileio.fsyncSync<sup>7+</sup> 1732 1733fsyncSync(fd: number): void 1734 1735以同步方法同步文件数据。 1736 1737**系统能力**：SystemCapability.FileManagement.File.FileIO 1738 1739**参数：** 1740 1741 | 参数名 | 类型 | 必填 | 说明 | 1742 | ---- | ------ | ---- | ------------ | 1743 | fd | number | 是 | 待同步文件的文件描述符。 | 1744 1745**示例：** 1746 1747 ```js 1748 let filePath = pathDir + "/test.txt"; 1749 let fd = fileio.openSync(filePath); 1750 fileio.fsyncSync(fd); 1751 ``` 1752 1753 1754## fileio.fdatasync<sup>7+</sup> 1755 1756fdatasync(fd: number): Promise<void> 1757 1758实现文件内容数据同步，使用Promise异步回调。 1759 1760**系统能力**：SystemCapability.FileManagement.File.FileIO 1761 1762**参数：** 1763 1764 | 参数名 | 类型 | 必填 | 说明 | 1765 | ---- | ------ | ---- | ------------ | 1766 | fd | number | 是 | 待同步文件的文件描述符。 | 1767 1768**返回值：** 1769 1770 | 类型 | 说明 | 1771 | ------------------- | ---------------------------- | 1772 | Promise<void> | Promise对象。无返回值。 | 1773 1774**示例：** 1775 1776 ```js 1777 let filePath = pathDir + "/test.txt"; 1778 let fd = fileio.openSync(filePath); 1779 fileio.fdatasync(fd).then(function (err) { 1780 console.info("sync data succeed"); 1781 }).catch(function (err) { 1782 console.info("sync data failed with error:" + err); 1783 }); 1784 ``` 1785 1786 1787## fileio.fdatasync<sup>7+</sup> 1788 1789fdatasync(fd: number, callback: AsyncCallback<void>): void 1790 1791实现文件内容数据同步，使用callback异步回调。 1792 1793**系统能力**：SystemCapability.FileManagement.File.FileIO 1794 1795**参数：** 1796 1797 | 参数名 | 类型 | 必填 | 说明 | 1798 | -------- | ------------------------------- | ---- | ----------------- | 1799 | fd | number | 是 | 待同步文件的文件描述符。 | 1800 | callback | AsyncCallback<void> | 是 | 异步将文件内容数据同步之后的回调。 | 1801 1802**示例：** 1803 1804 ```js 1805 let filePath = pathDir + "/test.txt"; 1806 let fd = fileio.openSync(filePath); 1807 fileio.fdatasync (fd, function (err) { 1808 // do something 1809 }); 1810 ``` 1811 1812 1813## fileio.fdatasyncSync<sup>7+</sup> 1814 1815fdatasyncSync(fd: number): void 1816 1817以同步方法实现文件内容数据同步。 1818 1819**系统能力**：SystemCapability.FileManagement.File.FileIO 1820 1821**参数：** 1822 1823 | 参数名 | 类型 | 必填 | 说明 | 1824 | ---- | ------ | ---- | ------------ | 1825 | fd | number | 是 | 待同步文件的文件描述符。 | 1826 1827**示例：** 1828 1829 ```js 1830 let filePath = pathDir + "/test.txt"; 1831 let fd = fileio.openSync(filePath); 1832 let stat = fileio.fdatasyncSync(fd); 1833 ``` 1834 1835 1836## fileio.symlink<sup>7+</sup> 1837 1838symlink(target: string, srcPath: string): Promise<void> 1839 1840基于文件路径创建符号链接，使用Promise异步回调。 1841 1842**系统能力**：SystemCapability.FileManagement.File.FileIO 1843 1844**参数：** 1845 1846| 参数名 | 类型 | 必填 | 说明 | 1847| ------- | ------ | ---- | ---------------------------- | 1848| target | string | 是 | 目标文件的应用沙箱路径。 | 1849| srcPath | string | 是 | 符号链接文件的应用沙箱路径。 | 1850 1851**返回值：** 1852 1853 | 类型 | 说明 | 1854 | ------------------- | ---------------------------- | 1855 | Promise<void> | Promise对象。无返回值。 | 1856 1857**示例：** 1858 1859 ```js 1860 let srcFile = pathDir + "/test.txt"; 1861 let dstFile = pathDir + '/test'; 1862 fileio.symlink(srcFile, dstFile).then(function () { 1863 console.info("symlink succeed"); 1864 }).catch(function (err) { 1865 console.info("symlink failed with error:" + err); 1866 }); 1867 ``` 1868 1869 1870## fileio.symlink<sup>7+</sup> 1871 1872symlink(target: string, srcPath: string, callback: AsyncCallback<void>): void 1873 1874基于文件路径创建符号链接，使用callback异步回调。 1875 1876**系统能力**：SystemCapability.FileManagement.File.FileIO 1877 1878**参数：** 1879 1880| 参数名 | 类型 | 必填 | 说明 | 1881| -------- | ------------------------- | ---- | -------------------------------- | 1882| target | string | 是 | 目标文件的应用沙箱路径。 | 1883| srcPath | string | 是 | 符号链接文件的应用沙箱路径。 | 1884| callback | AsyncCallback<void> | 是 | 异步创建符号链接信息之后的回调。 | 1885 1886**示例：** 1887 1888 ```js 1889 let srcFile = pathDir + "/test.txt"; 1890 let dstFile = pathDir + '/test'; 1891 fileio.symlink(srcFile, dstFile, function (err) { 1892 // do something 1893 }); 1894 ``` 1895 1896 1897## fileio.symlinkSync<sup>7+</sup> 1898 1899symlinkSync(target: string, srcPath: string): void 1900 1901以同步的方法基于文件路径创建符号链接。 1902 1903**系统能力**：SystemCapability.FileManagement.File.FileIO 1904 1905**参数：** 1906 1907| 参数名 | 类型 | 必填 | 说明 | 1908| ------- | ------ | ---- | ---------------------------- | 1909| target | string | 是 | 目标文件的应用沙箱路径。 | 1910| srcPath | string | 是 | 符号链接文件的应用沙箱路径。 | 1911 1912**示例：** 1913 1914 ```js 1915 let srcFile = pathDir + "/test.txt"; 1916 let dstFile = pathDir + '/test'; 1917 fileio.symlinkSync(srcFile, dstFile); 1918 ``` 1919 1920 1921## fileio.chown<sup>7+</sup> 1922 1923chown(path: string, uid: number, gid: number): Promise<void> 1924 1925基于文件路径改变文件所有者，使用Promise异步回调。 1926 1927**系统能力**：SystemCapability.FileManagement.File.FileIO 1928 1929**参数：** 1930 1931| 参数名 | 类型 | 必填 | 说明 | 1932| ------ | ------ | ---- | -------------------------- | 1933| path | string | 是 | 待改变文件的应用沙箱路径。 | 1934| uid | number | 是 | 新的UID（UserID）。 | 1935| gid | number | 是 | 新的GID（GroupID）。 | 1936 1937**返回值：** 1938 1939 | 类型 | 说明 | 1940 | ------------------- | ---------------------------- | 1941 | Promise<void> | Promise对象。无返回值。 | 1942 1943**示例：** 1944 1945 ```js 1946 let filePath = pathDir + "/test.txt"; 1947 let stat = fileio.statSync(filePath); 1948 fileio.chown(filePath, stat.uid, stat.gid).then(function () { 1949 console.info("chown succeed"); 1950 }).catch(function (err) { 1951 console.info("chown failed with error:" + err); 1952 }); 1953 ``` 1954 1955 1956## fileio.chown<sup>7+</sup> 1957 1958chown(path: string, uid: number, gid: number, callback: AsyncCallback<void>): void 1959 1960基于文件路径改变文件所有者，使用callback异步回调。 1961 1962**系统能力**：SystemCapability.FileManagement.File.FileIO 1963 1964**参数：** 1965 1966| 参数名 | 类型 | 必填 | 说明 | 1967| -------- | ------------------------- | ---- | ------------------------------ | 1968| path | string | 是 | 待改变文件的应用沙箱路径。 | 1969| uid | number | 是 | 新的UID。 | 1970| gid | number | 是 | 新的GID。 | 1971| callback | AsyncCallback<void> | 是 | 异步改变文件所有者之后的回调。 | 1972 1973**示例：** 1974 1975 ```js 1976 let filePath = pathDir + "/test.txt"; 1977 let stat = fileio.statSync(filePath) 1978 fileio.chown(filePath, stat.uid, stat.gid, function (err) { 1979 // do something 1980 }); 1981 ``` 1982 1983 1984## fileio.chownSync<sup>7+</sup> 1985 1986chownSync(path: string, uid: number, gid: number): void 1987 1988以同步的方法基于文件路径改变文件所有者。 1989 1990**系统能力**：SystemCapability.FileManagement.File.FileIO 1991 1992**参数：** 1993 1994| 参数名 | 类型 | 必填 | 说明 | 1995| ------ | ------ | ---- | -------------------------- | 1996| path | string | 是 | 待改变文件的应用沙箱路径。 | 1997| uid | number | 是 | 新的UID。 | 1998| gid | number | 是 | 新的GID。 | 1999 2000**示例：** 2001 2002 ```js 2003 let filePath = pathDir + "/test.txt"; 2004 let stat = fileio.statSync(filePath) 2005 fileio.chownSync(filePath, stat.uid, stat.gid); 2006 ``` 2007 2008 2009## fileio.mkdtemp<sup>7+</sup> 2010 2011mkdtemp(prefix: string): Promise<string> 2012 2013创建临时目录，使用Promise异步回调。 2014 2015**系统能力**：SystemCapability.FileManagement.File.FileIO 2016 2017**参数：** 2018 2019 | 参数名 | 类型 | 必填 | 说明 | 2020 | ------ | ------ | ---- | --------------------------- | 2021 | prefix | string | 是 | 用随机产生的字符串替换以“XXXXXX”结尾目录路径。 | 2022 2023**返回值：** 2024 2025 | 类型 | 说明 | 2026 | --------------------- | ---------- | 2027 | Promise<string> | Promise对象。返回生成的唯一目录路径。 | 2028 2029**示例：** 2030 2031 ```js 2032 fileio.mkdtemp(pathDir + "/XXXXXX").then(function (pathDir) { 2033 console.info("mkdtemp succeed:" + pathDir); 2034 }).catch(function (err) { 2035 console.info("mkdtemp failed with error:" + err); 2036 }); 2037 ``` 2038 2039 2040## fileio.mkdtemp<sup>7+</sup> 2041 2042mkdtemp(prefix: string, callback: AsyncCallback<string>): void 2043 2044创建临时目录，使用callback异步回调。 2045 2046**系统能力**：SystemCapability.FileManagement.File.FileIO 2047 2048**参数：** 2049 2050 | 参数名 | 类型 | 必填 | 说明 | 2051 | -------- | --------------------------- | ---- | --------------------------- | 2052 | prefix | string | 是 | 用随机产生的字符串替换以“XXXXXX”结尾目录路径。 | 2053 | callback | AsyncCallback<string> | 是 | 异步创建临时目录之后的回调。 | 2054 2055**示例：** 2056 2057 ```js 2058 fileio.mkdtemp(pathDir + "/XXXXXX", function (err, res) { 2059 // do something 2060 }); 2061 ``` 2062 2063 2064## fileio.mkdtempSync<sup>7+</sup> 2065 2066mkdtempSync(prefix: string): string 2067 2068以同步的方法创建临时目录。 2069 2070**系统能力**：SystemCapability.FileManagement.File.FileIO 2071 2072**参数：** 2073 2074 | 参数名 | 类型 | 必填 | 说明 | 2075 | ------ | ------ | ---- | --------------------------- | 2076 | prefix | string | 是 | 用随机产生的字符串替换以“XXXXXX”结尾目录路径。 | 2077 2078**返回值：** 2079 2080 | 类型 | 说明 | 2081 | ------ | ---------- | 2082 | string | 产生的唯一目录路径。 | 2083 2084**示例：** 2085 2086 ```js 2087 let res = fileio.mkdtempSync(pathDir + "/XXXXXX"); 2088 ``` 2089 2090 2091## fileio.fchmod<sup>7+</sup> 2092 2093fchmod(fd: number, mode: number): Promise<void> 2094 2095基于文件描述符改变文件权限，使用Promise异步回调。 2096 2097**系统能力**：SystemCapability.FileManagement.File.FileIO 2098 2099**参数：** 2100 2101 | 参数名 | 类型 | 必填 | 说明 | 2102 | ---- | ------ | ---- | ---------------------------------------- | 2103 | fd | number | 是 | 待改变文件的文件描述符。 | 2104 | mode | number | 是 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 2105 2106**返回值：** 2107 2108 | 类型 | 说明 | 2109 | ------------------- | ---------------------------- | 2110 | Promise<void> | Promise对象。无返回值。 | 2111 2112**示例：** 2113 2114 ```js 2115 let filePath = pathDir + "/test.txt"; 2116 let fd = fileio.openSync(filePath); 2117 let mode = 0o700; 2118 fileio.fchmod(fd, mode).then(function () { 2119 console.info("chmod succeed"); 2120 }).catch(function (err) { 2121 console.info("chmod failed with error:" + err); 2122 }); 2123 ``` 2124 2125 2126## fileio.fchmod<sup>7+</sup> 2127 2128fchmod(fd: number, mode: number, callback: AsyncCallback<void>): void 2129 2130基于文件描述符改变文件权限，使用callback异步回调。 2131 2132**系统能力**：SystemCapability.FileManagement.File.FileIO 2133 2134**参数：** 2135 2136 | 参数名 | 类型 | 必填 | 说明 | 2137 | -------- | ------------------------------- | ---- | ---------------------------------------- | 2138 | fd | number | 是 | 待改变文件的文件描述符。 | 2139 | mode | number | 是 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 2140 | callback | AsyncCallback<void> | 是 | 异步改变文件权限之后的回调。 | 2141 2142**示例：** 2143 2144 ```js 2145 let filePath = pathDir + "/test.txt"; 2146 let fd = fileio.openSync(filePath); 2147 let mode = 0o700; 2148 fileio.fchmod(fd, mode, function (err) { 2149 // do something 2150 }); 2151 ``` 2152 2153 2154## fileio.fchmodSync<sup>7+</sup> 2155 2156fchmodSync(fd: number, mode: number): void 2157 2158以同步方法基于文件描述符改变文件权限。 2159 2160**系统能力**：SystemCapability.FileManagement.File.FileIO 2161 2162**参数：** 2163 2164 | 参数名 | 类型 | 必填 | 说明 | 2165 | ---- | ------ | ---- | ---------------------------------------- | 2166 | fd | number | 是 | 待改变文件的文件描述符。 | 2167 | mode | number | 是 | 若创建文件，则指定文件的权限，可给定如下权限，以按位或的方式追加权限。<br/>- 0o700：所有者具有读、写及可执行权限。<br/>- 0o400：所有者具有读权限。<br/>- 0o200：所有者具有写权限。<br/>- 0o100：所有者具有可执行权限。<br/>- 0o070：所有用户组具有读、写及可执行权限。<br/>- 0o040：所有用户组具有读权限。<br/>- 0o020：所有用户组具有写权限。<br/>- 0o010：所有用户组具有可执行权限。<br/>- 0o007：其余用户具有读、写及可执行权限。<br/>- 0o004：其余用户具有读权限。<br/>- 0o002：其余用户具有写权限。<br/>- 0o001：其余用户具有可执行权限。 | 2168 2169**示例：** 2170 2171 ```js 2172 let filePath = pathDir + "/test.txt"; 2173 let fd = fileio.openSync(filePath); 2174 let mode = 0o700; 2175 fileio.fchmodSync(fd, mode); 2176 ``` 2177 2178 2179## fileio.createStream<sup>7+</sup> 2180 2181createStream(path: string, mode: string): Promise<Stream> 2182 2183基于文件路径打开文件流，使用Promise异步回调。 2184 2185**系统能力**：SystemCapability.FileManagement.File.FileIO 2186 2187**参数：** 2188 2189| 参数名 | 类型 | 必填 | 说明 | 2190| ------ | ------ | ---- | ------------------------------------------------------------ | 2191| path | string | 是 | 待打开文件的应用沙箱路径。 | 2192| mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2193 2194**返回值：** 2195 2196 | 类型 | 说明 | 2197 | --------------------------------- | --------- | 2198 | Promise<[Stream](#stream)> | Promise对象。返回文件流的结果。 | 2199 2200**示例：** 2201 2202 ```js 2203 let filePath = pathDir + "/test.txt"; 2204 fileio.createStream(filePath, "r+").then(function (stream) { 2205 console.info("createStream succeed"); 2206 }).catch(function (err) { 2207 console.info("createStream failed with error:" + err); 2208 }); 2209 ``` 2210 2211 2212## fileio.createStream<sup>7+</sup> 2213 2214createStream(path: string, mode: string, callback: AsyncCallback<Stream>): void 2215 2216基于文件路径打开文件流，使用callback异步回调。 2217 2218**系统能力**：SystemCapability.FileManagement.File.FileIO 2219 2220**参数：** 2221 2222| 参数名 | 类型 | 必填 | 说明 | 2223| -------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 2224| path | string | 是 | 待打开文件的应用沙箱路径。 | 2225| mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2226| callback | AsyncCallback<[Stream](#stream)> | 是 | 异步打开文件流之后的回调。 | 2227 2228**示例：** 2229 2230 ```js 2231 let filePath = pathDir + "/test.txt"; 2232 fileio.createStream(filePath, "r+", function (err, stream) { 2233 // do something 2234 }); 2235 ``` 2236 2237 2238## fileio.createStreamSync<sup>7+</sup> 2239 2240createStreamSync(path: string, mode: string): Stream 2241 2242以同步方法基于文件路径打开文件流。 2243 2244**系统能力**：SystemCapability.FileManagement.File.FileIO 2245 2246**参数：** 2247 2248| 参数名 | 类型 | 必填 | 说明 | 2249| ------ | ------ | ---- | ------------------------------------------------------------ | 2250| path | string | 是 | 待打开文件的应用沙箱路径。 | 2251| mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2252 2253**返回值：** 2254 2255 | 类型 | 说明 | 2256 | ------------------ | --------- | 2257 | [Stream](#stream) | 返回文件流的结果。 | 2258 2259**示例：** 2260 2261 ```js 2262 let filePath = pathDir + "/test.txt"; 2263 let ss = fileio.createStreamSync(filePath, "r+"); 2264 ``` 2265 2266 2267## fileio.fdopenStream<sup>7+</sup> 2268 2269fdopenStream(fd: number, mode: string): Promise<Stream> 2270 2271基于文件描述符打开文件流，使用Promise异步回调。 2272 2273**系统能力**：SystemCapability.FileManagement.File.FileIO 2274 2275**参数：** 2276 2277 | 参数名 | 类型 | 必填 | 说明 | 2278 | ---- | ------ | ---- | ---------------------------------------- | 2279 | fd | number | 是 | 待打开文件的文件描述符。 | 2280 | mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2281 2282**返回值：** 2283 2284 | 类型 | 说明 | 2285 | --------------------------------- | --------- | 2286 | Promise<[Stream](#stream)> | Promise对象。返回文件流的结果。 | 2287 2288**示例：** 2289 2290 ```js 2291 let filePath = pathDir + "/test.txt"; 2292 let fd = fileio.openSync(filePath); 2293 fileio.fdopenStream(fd, "r+").then(function (stream) { 2294 console.info("openStream succeed"); 2295 }).catch(function (err) { 2296 console.info("openStream failed with error:" + err); 2297 }); 2298 ``` 2299 2300 2301## fileio.fdopenStream<sup>7+</sup> 2302 2303fdopenStream(fd: number, mode: string, callback: AsyncCallback<Stream>): void 2304 2305基于文件描述符打开文件流，使用callback异步回调。 2306 2307**系统能力**：SystemCapability.FileManagement.File.FileIO 2308 2309**参数：** 2310 2311 | 参数名 | 类型 | 必填 | 说明 | 2312 | -------- | ---------------------------------------- | ---- | ---------------------------------------- | 2313 | fd | number | 是 | 待打开文件的文件描述符。 | 2314 | mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2315 | callback | AsyncCallback<[Stream](#stream)> | 是 | 异步打开文件流之后的回调。 | 2316 2317**示例：** 2318 2319 ```js 2320 let filePath = pathDir + "/test.txt"; 2321 let fd = fileio.openSync(filePath); 2322 fileio.fdopenStream(fd, "r+", function (err, stream) { 2323 // do something 2324 }); 2325 ``` 2326 2327 2328## fileio.fdopenStreamSync<sup>7+</sup> 2329 2330fdopenStreamSync(fd: number, mode: string): Stream 2331 2332以同步方法基于文件描述符打开文件流。 2333 2334**系统能力**：SystemCapability.FileManagement.File.FileIO 2335 2336**参数：** 2337 2338 | 参数名 | 类型 | 必填 | 说明 | 2339 | ---- | ------ | ---- | ---------------------------------------- | 2340 | fd | number | 是 | 待打开文件的文件描述符。 | 2341 | mode | string | 是 | - r：打开只读文件，该文件必须存在。<br/>- r+：打开可读写的文件，该文件必须存在。<br/>- w：打开只写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- w+：打开可读写文件，若文件存在则文件长度清0，即该文件内容会消失。若文件不存在则建立该文件。<br/>- a：以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。<br/>- a+：以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 | 2342 2343**返回值：** 2344 2345 | 类型 | 说明 | 2346 | ------------------ | --------- | 2347 | [Stream](#stream) | 返回文件流的结果。 | 2348 2349**示例：** 2350 2351 ```js 2352 let filePath = pathDir + "/test.txt"; 2353 let fd = fileio.openSync(filePath); 2354 let ss = fileio.fdopenStreamSync(fd, "r+"); 2355 ``` 2356 2357 2358## fileio.fchown<sup>7+</sup> 2359 2360fchown(fd: number, uid: number, gid: number): Promise<void> 2361 2362基于文件描述符改变文件所有者，使用Promise异步回调。 2363 2364**系统能力**：SystemCapability.FileManagement.File.FileIO 2365 2366**参数：** 2367 2368 | 参数名 | 类型 | 必填 | 说明 | 2369 | ---- | ------ | ---- | ------------ | 2370 | fd | number | 是 | 待改变文件的文件描述符。 | 2371 | uid | number | 是 | 文件所有者的UID。 | 2372 | gid | number | 是 | 文件所有组的GID。 | 2373 2374**返回值：** 2375 2376 | 类型 | 说明 | 2377 | ------------------- | ---------------------------- | 2378 | Promise<void> | Promise对象。无返回值。 | 2379 2380**示例：** 2381 2382 ```js 2383 let filePath = pathDir + "/test.txt"; 2384 let fd = fileio.openSync(filePath); 2385 let stat = fileio.statSync(filePath); 2386 fileio.fchown(fd, stat.uid, stat.gid).then(function () { 2387 console.info("chown succeed"); 2388 }).catch(function (err) { 2389 console.info("chown failed with error:" + err); 2390 }); 2391 ``` 2392 2393 2394## fileio.fchown<sup>7+</sup> 2395 2396fchown(fd: number, uid: number, gid: number, callback: AsyncCallback<void>): void 2397 2398基于文件描述符改变文件所有者，使用callback异步回调。 2399 2400**系统能力**：SystemCapability.FileManagement.File.FileIO 2401 2402**参数：** 2403 2404 | 参数名 | 类型 | 必填 | 说明 | 2405 | -------- | ------------------------- | ---- | --------------- | 2406 | fd | number | 是 | 待改变文件的文件描述符。 | 2407 | uid | number | 是 | 文件所有者的UID。 | 2408 | gid | number | 是 | 文件所有组的GID。 | 2409 | callback | AsyncCallback<void> | 是 | 异步改变文件所有者之后的回调。 | 2410 2411**示例：** 2412 2413 ```js 2414 let filePath = pathDir + "/test.txt"; 2415 let fd = fileio.openSync(filePath); 2416 let stat = fileio.statSync(filePath); 2417 fileio.fchown(fd, stat.uid, stat.gid, function (err) { 2418 // do something 2419 }); 2420 ``` 2421 2422 2423## fileio.fchownSync<sup>7+</sup> 2424 2425fchownSync(fd: number, uid: number, gid: number): void 2426 2427以同步方法基于文件描述符改变文件所有者。 2428 2429**系统能力**：SystemCapability.FileManagement.File.FileIO 2430 2431**参数：** 2432 2433 | 参数名 | 类型 | 必填 | 说明 | 2434 | ---- | ------ | ---- | ------------ | 2435 | fd | number | 是 | 待改变文件的文件描述符。 | 2436 | uid | number | 是 | 文件所有者的UID。 | 2437 | gid | number | 是 | 文件所有组的GID。 | 2438 2439**示例：** 2440 2441 ```js 2442 let filePath = pathDir + "/test.txt"; 2443 let fd = fileio.openSync(filePath); 2444 let stat = fileio.statSync(filePath); 2445 fileio.fchownSync(fd, stat.uid, stat.gid); 2446 ``` 2447 2448 2449## fileio.lchown<sup>7+</sup> 2450 2451lchown(path: string, uid: number, gid: number): Promise<void> 2452 2453基于文件路径改变文件所有者，更改符号链接本身的所有者，而不是符号链接所指向的实际文件，使用Promise异步回调。 2454 2455**系统能力**：SystemCapability.FileManagement.File.FileIO 2456 2457**参数：** 2458 2459| 参数名 | 类型 | 必填 | 说明 | 2460| ------ | ------ | ---- | -------------------------- | 2461| path | string | 是 | 待打开文件的应用沙箱路径。 | 2462| uid | number | 是 | 新的UID。 | 2463| gid | number | 是 | 新的GID。 | 2464 2465**返回值：** 2466 2467 | 类型 | 说明 | 2468 | ------------------- | ---------------------------- | 2469 | Promise<void> | Promise对象。无返回值。 | 2470 2471**示例：** 2472 2473 ```js 2474 let filePath = pathDir + "/test.txt"; 2475 let stat = fileio.statSync(filePath); 2476 fileio.lchown(filePath, stat.uid, stat.gid).then(function () { 2477 console.info("chown succeed"); 2478 }).catch(function (err) { 2479 console.info("chown failed with error:" + err); 2480 }); 2481 ``` 2482 2483 2484## fileio.lchown<sup>7+</sup> 2485 2486lchown(path: string, uid: number, gid: number, callback: AsyncCallback<void>): void 2487 2488基于文件路径改变文件所有者，更改符号链接本身的所有者，而不是更改符号链接所指向的实际文件，使用callback异步回调。 2489 2490**系统能力**：SystemCapability.FileManagement.File.FileIO 2491 2492**参数：** 2493 2494| 参数名 | 类型 | 必填 | 说明 | 2495| -------- | ------------------------- | ---- | ------------------------------ | 2496| path | string | 是 | 待打开文件的应用沙箱路径。 | 2497| uid | number | 是 | 新的UID。 | 2498| gid | number | 是 | 新的GID。 | 2499| callback | AsyncCallback<void> | 是 | 异步改变文件所有者之后的回调。 | 2500 2501**示例：** 2502 2503 ```js 2504 let filePath = pathDir + "/test.txt"; 2505 let stat = fileio.statSync(filePath); 2506 fileio.lchown(filePath, stat.uid, stat.gid, function (err) { 2507 // do something 2508 }); 2509 ``` 2510 2511 2512## fileio.lchownSync<sup>7+</sup> 2513 2514lchownSync(path: string, uid: number, gid: number): void 2515 2516以同步方法基于文件路径改变文件所有者，更改符号链接本身的所有者，而不是更改符号链接所指向的实际文件。 2517 2518**系统能力**：SystemCapability.FileManagement.File.FileIO 2519 2520**参数：** 2521 2522| 参数名 | 类型 | 必填 | 说明 | 2523| ------ | ------ | ---- | -------------------------- | 2524| path | string | 是 | 待打开文件的应用沙箱路径。 | 2525| uid | number | 是 | 新的UID。 | 2526| gid | number | 是 | 新的GID。 | 2527 2528**示例：** 2529 2530 ```js 2531 let filePath = pathDir + "/test.txt"; 2532 let stat = fileio.statSync(filePath); 2533 fileio.lchownSync(filePath, stat.uid, stat.gid); 2534 ``` 2535 2536 2537## fileio.createWatcher<sup>7+</sup> 2538 2539createWatcher(filename: string, events: number, callback: AsyncCallback<number>): Watcher 2540 2541监听文件或者目录的变化，使用callback异步回调。 2542 2543**系统能力**：SystemCapability.FileManagement.File.FileIO 2544 2545**参数：** 2546 2547| 参数名 | 类型 | 必填 | 说明 | 2548| -------- | --------------------------------- | ---- | ------------------------------------------------------------ | 2549| filePath | string | 是 | 待监视文件的应用沙箱路径。 | 2550| events | number | 是 | - 1: 监听文件或者目录是否发生重命名。<br/>- 2：监听文件或者目录内容的是否修改。<br/>- 3：两者都有。 | 2551| callback | AsyncCallback<number> | 是 | 每发生变化一次，调用一次此函数。 | 2552 2553**返回值：** 2554 2555 | 类型 | 说明 | 2556 | -------------------- | ---------- | 2557 | [Watcher](#watcher7) | Promise对象。返回文件变化监听的实例。 | 2558 2559**示例：** 2560 2561 ```js 2562 let filePath = pathDir +"/test.txt"; 2563 fileio.createWatcher(filePath, 1, function (number) { 2564 console.info("Monitoring times: " +number); 2565 }); 2566 2567 ``` 2568 2569 2570## Readout 2571 2572仅用于read方法，获取文件的读取结果。 2573 2574**系统能力**：以下各项对应的系统能力均为SystemCapability.FileManagement.File.FileIO。 2575 2576| 名称 | 类型 | 可读 | 可写 | 说明 | 2577| --------- | ---------- | ---- | ---- | ----------------- | 2578| bytesRead | number | 是 | 是 | 实际读取长度。 | 2579| offset | number | 是 | 是 | 读取数据相对于缓冲区首地址的偏移。 | 2580| buffer | ArrayBuffer | 是 | 是 | 保存读取数据的缓冲区。 | 2581 2582 2583## Stat 2584 2585文件具体信息，在调用Stat的方法前，需要先通过[stat()](#fileiostat)方法（同步或异步）来构建一个Stat实例。 2586 2587**系统能力**：以下各项对应的系统能力均为SystemCapability.FileManagement.File.FileIO。 2588 2589### 属性 2590 2591| 名称 | 类型 | 可读 | 可写 | 说明 | 2592| ------ | ------ | ---- | ---- | ---------------------------------------- | 2593| dev | number | 是 | 否 | 标识包含该文件的主设备号。 | 2594| ino | number | 是 | 否 | 标识该文件。通常同设备上的不同文件的INO不同。 | 2595| mode | number | 是 | 否 | 表示文件类型及权限，其首 4 位表示文件类型，后 12 位表示权限。各特征位的含义如下：<br/>- 0o170000：可用于获取文件类型的掩码。<br/>- 0o140000：文件是套接字。<br/>- 0o120000：文件是符号链接。<br/>- 0o100000：文件是一般文件。<br/>- 0o060000：文件属于块设备。<br/>- 0o040000：文件是目录。<br/>- 0o020000：文件是字符设备。<br/>- 0o010000：文件是命名管道，即FIFO。<br/>- 0o0700：可用于获取用户权限的掩码。<br/>- 0o0400：用户读，对于普通文件，所有者可读取文件；对于目录，所有者可读取目录项。<br/>- 0o0200：用户写，对于普通文件，所有者可写入文件；对于目录，所有者可创建/删除目录项。<br/>- 0o0100：用户执行，对于普通文件，所有者可执行文件；对于目录，所有者可在目录中搜索给定路径名。<br/>- 0o0070：可用于获取用户组权限的掩码。<br/>- 0o0040：用户组读，对于普通文件，所有用户组可读取文件；对于目录，所有用户组可读取目录项。<br/>- 0o0020：用户组写，对于普通文件，所有用户组可写入文件；对于目录，所有用户组可创建/删除目录项。<br/>- 0o0010：用户组执行，对于普通文件，所有用户组可执行文件；对于目录，所有用户组是否可在目录中搜索给定路径名。<br/>- 0o0007：可用于获取其他用户权限的掩码。<br/>- 0o0004：其他读，对于普通文件，其余用户可读取文件；对于目录，其他用户组可读取目录项。<br/>- 0o0002：其他写，对于普通文件，其余用户可写入文件；对于目录，其他用户组可创建/删除目录项。<br/>- 0o0001：其他执行，对于普通文件，其余用户可执行文件；对于目录，其他用户组可在目录中搜索给定路径名。 | 2596| nlink | number | 是 | 否 | 文件的硬链接数。 | 2597| uid | number | 是 | 否 | 文件所有者的ID。 | 2598| gid | number | 是 | 否 | 文件所有组的ID。 | 2599| rdev | number | 是 | 否 | 标识包含该文件的从设备号。 | 2600| size | number | 是 | 否 | 文件的大小，以字节为单位。仅对普通文件有效。 | 2601| blocks | number | 是 | 否 | 文件占用的块数，计算时块大小按512B计算。 | 2602| atime | number | 是 | 否 | 上次访问该文件的时间，表示距1970年1月1日0时0分0秒的秒数。 | 2603| mtime | number | 是 | 否 | 上次修改该文件的时间，表示距1970年1月1日0时0分0秒的秒数。 | 2604| ctime | number | 是 | 否 | 最近改变文件状态的时间，表示距1970年1月1日0时0分0秒的秒数。 | 2605 2606 2607### isBlockDevice 2608 2609isBlockDevice(): boolean 2610 2611用于判断文件是否是块特殊文件。一个块特殊文件只能以块为粒度进行访问，且访问的时候带缓存。 2612 2613**系统能力**：SystemCapability.FileManagement.File.FileIO 2614 2615**返回值：** 2616 2617 | 类型 | 说明 | 2618 | ------- | ---------------- | 2619 | boolean | 表示文件是否是块特殊设备。 | 2620 2621**示例：** 2622 2623 ```js 2624 let filePath = pathDir + "/test.txt"; 2625 let isBLockDevice = fileio.statSync(filePath).isBlockDevice(); 2626 ``` 2627 2628 2629### isCharacterDevice 2630 2631isCharacterDevice(): boolean 2632 2633用于判断文件是否是字符特殊文件。一个字符特殊设备可进行随机访问，且访问的时候不带缓存。 2634 2635**系统能力**：SystemCapability.FileManagement.File.FileIO 2636 2637**返回值：** 2638 2639 | 类型 | 说明 | 2640 | ------- | ----------------- | 2641 | boolean | 表示文件是否是字符特殊设备。 | 2642 2643**示例：** 2644 2645 ```js 2646 let filePath = pathDir + "/test.txt"; 2647 let isCharacterDevice = fileio.statSync(filePath).isCharacterDevice(); 2648 ``` 2649 2650 2651### isDirectory 2652 2653isDirectory(): boolean 2654 2655用于判断文件是否是目录。 2656 2657**系统能力**：SystemCapability.FileManagement.File.FileIO 2658 2659**返回值：** 2660 2661 | 类型 | 说明 | 2662 | ------- | ------------- | 2663 | boolean | 表示文件是否是目录。 | 2664 2665**示例：** 2666 2667 ```js 2668 let dirPath = pathDir + "/test"; 2669 let isDirectory = fileio.statSync(dirPath).isDirectory(); 2670 ``` 2671 2672 2673### isFIFO 2674 2675isFIFO(): boolean 2676 2677用于判断文件是否是命名管道（有时也称为FIFO）。命名管道通常用于进程间通信。 2678 2679**系统能力**：SystemCapability.FileManagement.File.FileIO 2680 2681**返回值：** 2682 2683 | 类型 | 说明 | 2684 | ------- | --------------------- | 2685 | boolean | 表示文件是否是 FIFO。 | 2686 2687**示例：** 2688 2689 ```js 2690 let filePath = pathDir + "/test.txt"; 2691 let isFIFO = fileio.statSync(filePath).isFIFO(); 2692 ``` 2693 2694 2695### isFile 2696 2697isFile(): boolean 2698 2699用于判断文件是否是普通文件。 2700 2701**系统能力**：SystemCapability.FileManagement.File.FileIO 2702 2703**返回值：** 2704 2705 | 类型 | 说明 | 2706 | ------- | --------------- | 2707 | boolean | 表示文件是否是普通文件。 | 2708 2709**示例：** 2710 2711 ```js 2712 let filePath = pathDir + "/test.txt"; 2713 let isFile = fileio.statSync(filePath).isFile(); 2714 ``` 2715 2716 2717### isSocket 2718 2719isSocket(): boolean 2720 2721用于判断文件是否是套接字。 2722 2723**系统能力**：SystemCapability.FileManagement.File.FileIO 2724 2725**返回值：** 2726 2727 | 类型 | 说明 | 2728 | ------- | -------------- | 2729 | boolean | 表示文件是否是套接字。 | 2730 2731**示例：** 2732 2733 ```js 2734 let filePath = pathDir + "/test.txt"; 2735 let isSocket = fileio.statSync(filePath).isSocket(); 2736 ``` 2737 2738 2739### isSymbolicLink 2740 2741isSymbolicLink(): boolean 2742 2743用于判断文件是否是符号链接。 2744 2745**系统能力**：SystemCapability.FileManagement.File.FileIO 2746 2747**返回值：** 2748 2749 | 类型 | 说明 | 2750 | ------- | --------------- | 2751 | boolean | 表示文件是否是符号链接。 | 2752 2753**示例：** 2754 2755 ```js 2756 let filePath = pathDir + "/test"; 2757 let isSymbolicLink = fileio.statSync(filePath).isSymbolicLink(); 2758 ``` 2759 2760 2761## Watcher<sup>7+</sup> 2762 2763Watcher是文件变化监听的实例，调用Watcher.stop()方法（同步或异步）来停止文件监听。 2764 2765 2766### stop<sup>7+</sup> 2767 2768stop(): Promise<void> 2769 2770关闭watcher监听，使用Promise异步回调。 2771 2772**系统能力**：SystemCapability.FileManagement.File.FileIO 2773 2774**示例：** 2775 2776 ```js 2777 let filePath = path + "/test.txt"; 2778 let watcher = fileio.createWatcher(filePath, 1, function (number) { 2779 console.info("Monitoring times: " +number); 2780 }); 2781 watcher.stop().then(function () { 2782 console.info("close watcher succeed"); 2783 }); 2784 ``` 2785 2786 2787### stop<sup>7+</sup> 2788 2789stop(callback: AsyncCallback<void>): void 2790 2791关闭watcher监听，使用callback异步回调。 2792 2793**系统能力**：SystemCapability.FileManagement.File.FileIO 2794 2795**参数：** 2796 2797 | 参数名 | 类型 | 必填 | 说明 | 2798 | -------- | ------------------------- | ---- | ---------------------- | 2799 | callback | AsyncCallback<void> | 是 | 以异步方法关闭watcher监听之后的回调。 | 2800 2801**示例：** 2802 2803 ```js 2804 let filePath = path +"/test.txt"; 2805 let watcher = fileio.createWatcher(filePath, 1, function (number) { 2806 console.info("Monitoring times: " +number); 2807 }); 2808 watcher.stop(function () { 2809 console.info("close watcher succeed"); 2810 }) 2811 ``` 2812 2813 2814## Stream 2815 2816文件流，在调用Stream的方法前，需要先通过createStream()方法（同步或异步）来构建一个Stream实例。 2817 2818 2819### close<sup>7+</sup> 2820 2821close(): Promise<void> 2822 2823关闭文件流，使用Promise异步回调。 2824 2825**系统能力**：SystemCapability.FileManagement.File.FileIO 2826 2827**返回值：** 2828 2829 | 类型 | 说明 | 2830 | ------------------- | ------------- | 2831 | Promise<void> | Promise对象。返回表示异步关闭文件流的结果。 | 2832 2833**示例：** 2834 2835 ```js 2836 let filePath = pathDir + "/test.txt"; 2837 let ss= fileio.createStreamSync(filePath, "r+"); 2838 ss.close().then(function () { 2839 console.info("close fileStream succeed"); 2840 }).catch(function (err) { 2841 console.info("close fileStream failed with error:" + err); 2842 }); 2843 ``` 2844 2845 2846### close<sup>7+</sup> 2847 2848close(callback: AsyncCallback<void>): void 2849 2850异步关闭文件流，使用callback异步回调。 2851 2852**系统能力**：SystemCapability.FileManagement.File.FileIO 2853 2854**参数：** 2855 2856 | 参数名 | 类型 | 必填 | 说明 | 2857 | -------- | ------------------------- | ---- | ------------- | 2858 | callback | AsyncCallback<void> | 是 | 异步关闭文件流之后的回调。 | 2859 2860**示例：** 2861 2862 ```js 2863 let filePath = pathDir + "/test.txt"; 2864 let ss= fileio.createStreamSync(filePath, "r+"); 2865 ss.close(function (err) { 2866 // do something 2867 }); 2868 ``` 2869 2870 2871### closeSync 2872 2873closeSync(): void 2874 2875同步关闭文件流。 2876 2877**系统能力**：SystemCapability.FileManagement.File.FileIO 2878 2879**示例：** 2880 2881 ```js 2882 let filePath = pathDir + "/test.txt"; 2883 let ss= fileio.createStreamSync(filePath, "r+"); 2884 ss.closeSync(); 2885 ``` 2886 2887 2888### flush<sup>7+</sup> 2889 2890flush(): Promise<void> 2891 2892刷新文件流，使用Promise异步回调。 2893 2894**系统能力**：SystemCapability.FileManagement.File.FileIO 2895 2896**返回值：** 2897 2898 | 类型 | 说明 | 2899 | ------------------- | ------------- | 2900 | Promise<void> | Promise对象。返回表示异步刷新文件流的结果。 | 2901 2902**示例：** 2903 2904 ```js 2905 let filePath = pathDir + "/test.txt"; 2906 let ss= fileio.createStreamSync(filePath, "r+"); 2907 ss.flush().then(function () { 2908 console.info("flush succeed"); 2909 }).catch(function (err) { 2910 console.info("flush failed with error:" + err); 2911 }); 2912 ``` 2913 2914 2915### flush<sup>7+</sup> 2916 2917flush(callback: AsyncCallback<void>): void 2918 2919异步刷新文件流，使用callback异步回调。 2920 2921**系统能力**：SystemCapability.FileManagement.File.FileIO 2922 2923**参数：** 2924 2925 | 参数名 | 类型 | 必填 | 说明 | 2926 | -------- | ------------------------- | ---- | -------------- | 2927 | callback | AsyncCallback<void> | 是 | 异步刷新文件流后的回调函数。 | 2928 2929**示例：** 2930 2931 ```js 2932 let filePath = pathDir + "/test.txt"; 2933 let ss= fileio.createStreamSync(filePath, "r+"); 2934 ss.flush(function (err) { 2935 // do something 2936 }); 2937 ``` 2938 2939 2940### flushSync<sup>7+</sup> 2941 2942flushSync(): void 2943 2944同步刷新文件流。 2945 2946**系统能力**：SystemCapability.FileManagement.File.FileIO 2947 2948**示例：** 2949 2950 ```js 2951 let filePath = pathDir + "/test.txt"; 2952 let ss= fileio.createStreamSync(filePath, "r+"); 2953 ss.flushSync(); 2954 ``` 2955 2956 2957### write<sup>7+</sup> 2958 2959write(buffer: ArrayBuffer|string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): Promise<number> 2960 2961将数据写入流文件，使用Promise异步回调。 2962 2963**系统能力**：SystemCapability.FileManagement.File.FileIO 2964 2965**参数：** 2966 2967 | 参数名 | 类型 | 必填 | 说明 | 2968 | ------- | ------------------------------- | ---- | ---------------------------------------- | 2969 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 2970 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 2971 2972**返回值：** 2973 2974 | 类型 | 说明 | 2975 | --------------------- | -------- | 2976 | Promise<number> | Promise对象。返回实际写入的长度。 | 2977 2978**示例：** 2979 2980 ```js 2981 let filePath = pathDir + "/test.txt"; 2982 let ss= fileio.createStreamSync(filePath, "r+"); 2983 ss.write("hello, world",{offset: 1,length: 5,position: 5,encoding :'utf-8'}).then(function (number) { 2984 console.info("write succeed and size is:" + number); 2985 }).catch(function (err) { 2986 console.info("write failed with error:" + err); 2987 }); 2988 ``` 2989 2990 2991### write<sup>7+</sup> 2992 2993write(buffer: ArrayBuffer|string, options: { offset?: number; length?: number; position?: number; encoding?: string; }, callback: AsyncCallback<number>): void 2994 2995将数据写入流文件，使用callback异步回调。 2996 2997**系统能力**：SystemCapability.FileManagement.File.FileIO 2998 2999**参数：** 3000 3001 | 参数名 | 类型 | 必填 | 说明 | 3002 | -------- | ------------------------------- | ---- | ------------------------------------------------------------ | 3003 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 3004 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 3005 | callback | AsyncCallback<number> | 是 | 异步写入完成后执行的回调函数。 | 3006 3007**示例：** 3008 3009 ```js 3010 let filePath = pathDir + "/test.txt"; 3011 let ss= fileio.createStreamSync(filePath, "r+"); 3012 ss.write("hello, world", {offset: 1, length: 5, position: 5, encoding :'utf-8'}, function (err, bytesWritten) { 3013 if (bytesWritten) { 3014 // do something 3015 console.info("write succeed and size is:" + bytesWritten); 3016 } 3017 }); 3018 ``` 3019 3020 3021### writeSync<sup>7+</sup> 3022 3023writeSync(buffer: ArrayBuffer|string, options?: { offset?: number; length?: number; position?: number; encoding?: string; }): number 3024 3025以同步方法将数据写入流文件。 3026 3027**系统能力**：SystemCapability.FileManagement.File.FileIO 3028 3029**参数：** 3030 3031 | 参数名 | 类型 | 必填 | 说明 | 3032 | ------- | ------------------------------- | ---- | ---------------------------------------- | 3033 | buffer | ArrayBuffer\|string | 是 | 待写入文件的数据，可来自缓冲区或字符串。 | 3034 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示期望写入数据的位置相对于数据首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望写入数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望写入文件的位置。可选，默认从当前位置开始写。<br/>- encoding，string类型，当数据是string类型时有效，表示数据的编码方式，默认 'utf-8'。仅支持 'utf-8'。<br/>约束：offset+length<=buffer.size。 | 3035 3036**返回值：** 3037 3038 | 类型 | 说明 | 3039 | ------ | -------- | 3040 | number | 实际写入的长度。 | 3041 3042**示例：** 3043 3044 ```js 3045 let filePath = pathDir + "/test.txt"; 3046 let ss= fileio.createStreamSync(filePath,"r+"); 3047 let num = ss.writeSync("hello, world", {offset: 1, length: 5, position: 5, encoding :'utf-8'}); 3048 ``` 3049 3050 3051### read<sup>7+</sup> 3052 3053read(buffer: ArrayBuffer, options?: { position?: number; offset?: number; length?: number; }): Promise<ReadOut> 3054 3055从流文件读取数据，使用Promise异步回调。 3056 3057**系统能力**：SystemCapability.FileManagement.File.FileIO 3058 3059**参数：** 3060 3061 | 参数名 | 类型 | 必填 | 说明 | 3062 | ------- | ----------- | ---- | ---------------------------------------- | 3063 | buffer | ArrayBuffer | 是 | 用于读取文件的缓冲区。 | 3064 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 3065 3066**返回值：** 3067 3068 | 类型 | 说明 | 3069 | ---------------------------------- | ------ | 3070 | Promise<[ReadOut](#readout)> | Promise对象。返回读取的结果。 | 3071 3072**示例：** 3073 3074 ```js 3075 let filePath = pathDir + "/test.txt"; 3076 let ss = fileio.createStreamSync(filePath, "r+"); 3077 ss.read(new ArrayBuffer(4096), {offset: 1, length: 5, position: 5}).then(function (readOut) { 3078 console.info("read data succeed"); 3079 console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer))); 3080 }).catch(function (err) { 3081 console.info("read data failed with error:" + err); 3082 }); 3083 ``` 3084 3085 3086### read<sup>7+</sup> 3087 3088read(buffer: ArrayBuffer, options: { position?: number; offset?: number; length?: number; }, callback: AsyncCallback<ReadOut>): void 3089 3090从流文件读取数据，使用callback异步回调。 3091 3092**系统能力**：SystemCapability.FileManagement.File.FileIO 3093 3094**参数：** 3095 3096 | 参数名 | 类型 | 必填 | 说明 | 3097 | -------- | ---------------------------------------- | ---- | ---------------------------------------- | 3098 | buffer | ArrayBuffer | 是 | 用于读取文件的缓冲区。 | 3099 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 3100 | callback | AsyncCallback<[ReadOut](#readout)> | 是 | 异步从流文件读取数据之后的回调。 | 3101 3102**示例：** 3103 3104 ```js 3105 let filePath = pathDir + "/test.txt"; 3106 let ss = fileio.createStreamSync(filePath, "r+"); 3107 ss.read(new ArrayBuffer(4096),{offset: 1, length: 5, position: 5},function (err, readOut) { 3108 if (readOut) { 3109 console.info("read data succeed"); 3110 console.log(String.fromCharCode.apply(null, new Uint8Array(readOut.buffer))); 3111 } 3112 }); 3113 ``` 3114 3115 3116### readSync<sup>7+</sup> 3117 3118readSync(buffer: ArrayBuffer, options?: { position?: number; offset?: number; length?: number; }): number 3119 3120以同步方法从流文件读取数据。 3121 3122**系统能力**：SystemCapability.FileManagement.File.FileIO 3123 3124**参数：** 3125 3126 | 参数名 | 类型 | 必填 | 说明 | 3127 | ------- | ----------- | ---- | ---------------------------------------- | 3128 | buffer | ArrayBuffer | 是 | 用于读取文件的缓冲区。 | 3129 | options | Object | 否 | 支持如下选项：<br/>- offset，number类型，表示将数据读取到缓冲区的位置，即相对于缓冲区首地址的偏移。可选，默认为0。<br/>- length，number类型，表示期望读取数据的长度。可选，默认缓冲区长度减去偏移长度。<br/>- position，number类型，表示期望读取文件的位置。可选，默认从当前位置开始读。<br/>约束：offset+length<=buffer.size。 | 3130 3131**返回值：** 3132 3133 | 类型 | 说明 | 3134 | ------ | -------- | 3135 | number | 实际读取的长度。 | 3136 3137**示例：** 3138 3139 ```js 3140 let filePath = pathDir + "/test.txt"; 3141 let ss = fileio.createStreamSync(filePath, "r+"); 3142 let num = ss.readSync(new ArrayBuffer(4096), {offset: 1, length: 5, position: 5}); 3143 ``` 3144 3145 3146## Dir 3147 3148管理目录，在调用Dir的方法前，需要先通过opendir方法（同步或异步）来构建一个Dir实例。 3149 3150 3151### read 3152 3153read(): Promise<Dirent> 3154 3155读取下一个目录项，使用Promise异步回调。 3156 3157**系统能力**：SystemCapability.FileManagement.File.FileIO 3158 3159**返回值：** 3160 3161 | 类型 | 说明 | 3162 | -------------------------------- | ------------- | 3163 | Promise<[Dirent](#dirent)> | Promise对象。返回表示异步读取目录项的结果。 | 3164 3165**示例：** 3166 3167 ```js 3168 dir.read().then(function (dirent) { 3169 console.log("read succeed, the name of dirent is " + dirent.name); 3170 }).catch(function (err) { 3171 console.info("read failed with error:" + err); 3172 }); 3173 ``` 3174 3175 3176### read 3177 3178read(callback: AsyncCallback<Dirent>): void 3179 3180读取下一个目录项，使用callback异步回调。 3181 3182**系统能力**：SystemCapability.FileManagement.File.FileIO 3183 3184**参数：** 3185 3186 | 参数名 | 类型 | 必填 | 说明 | 3187 | -------- | -------------------------------------- | ---- | ---------------- | 3188 | callback | AsyncCallback<[Dirent](#dirent)> | 是 | 异步读取下一个目录项之后的回调。 | 3189 3190**示例：** 3191 3192 ```js 3193 dir.read(function (err, dirent) { 3194 if (dirent) { 3195 // do something 3196 console.log("read succeed, the name of file is " + dirent.name); 3197 } 3198 }); 3199 ``` 3200 3201 3202### readSync 3203 3204readSync(): Dirent 3205 3206同步读取下一个目录项。 3207 3208**系统能力**：SystemCapability.FileManagement.File.FileIO 3209 3210**返回值：** 3211 3212 | 类型 | 说明 | 3213 | ----------------- | -------- | 3214 | [Dirent](#dirent) | 表示一个目录项。 | 3215 3216**示例：** 3217 3218 ```js 3219 let dirent = dir.readSync(); 3220 ``` 3221 3222 3223### close<sup>7+</sup> 3224 3225close(): Promise<void> 3226 3227异步关闭目录，使用promise形式返回结果。目录被关闭后，Dir中持有的文件描述将被释放，后续将无法从Dir中读取目录项。 3228 3229**系统能力**：SystemCapability.FileManagement.File.FileIO 3230 3231**示例：** 3232 3233 ```js 3234 dir.close().then(function (err) { 3235 console.info("close dir successfully"); 3236 }); 3237 ``` 3238 3239 3240 ### close<sup>7+</sup> 3241 3242close(callback: AsyncCallback<void>): void 3243 3244异步关闭目录，使用callback形式返回结果。目录被关闭后，Dir中持有的文件描述将被释放，后续将无法从Dir中读取目录项。 3245 3246**系统能力**：SystemCapability.FileManagement.File.FileIO 3247 3248**示例：** 3249 3250 ```js 3251 dir.close(function (err) { 3252 console.info("close dir successfully"); 3253 }); 3254 ``` 3255 3256 3257### closeSync 3258 3259closeSync(): void 3260 3261用于关闭目录。目录被关闭后，Dir中持有的文件描述将被释放，后续将无法从Dir中读取目录项。 3262 3263**系统能力**：SystemCapability.FileManagement.File.FileIO 3264 3265**示例：** 3266 3267 ```js 3268 dir.closeSync(); 3269 ``` 3270 3271 3272## Dirent 3273 3274在调用Dirent的方法前，需要先通过[dir.read()](#read)方法（同步或异步）来构建一个Dirent实例。 3275 3276**系统能力**：以下各项对应的系统能力均为SystemCapability.FileManagement.File.FileIO。 3277 3278### 属性 3279 3280| 名称 | 类型 | 可读 | 可写 | 说明 | 3281| ---- | ------ | ---- | ---- | ------- | 3282| name | string | 是 | 否 | 目录项的名称。 | 3283 3284 3285### isBlockDevice 3286 3287isBlockDevice(): boolean 3288 3289用于判断当前目录项是否是块特殊文件。一个块特殊文件只能以块为粒度进行访问，且访问的时候带缓存。 3290 3291**系统能力**：SystemCapability.FileManagement.File.FileIO 3292 3293**返回值：** 3294 3295 | 类型 | 说明 | 3296 | ------- | ---------------- | 3297 | boolean | 表示当前目录项是否是块特殊设备。 | 3298 3299**示例：** 3300 3301 ```js 3302 let dir = fileio.opendirSync(pathDir); 3303 let isBLockDevice = dir.readSync().isBlockDevice(); 3304 ``` 3305 3306 3307### isCharacterDevice 3308 3309isCharacterDevice(): boolean 3310 3311用于判断当前目录项是否是字符特殊设备。一个字符特殊设备可进行随机访问，且访问的时候不带缓存。 3312 3313**系统能力**：SystemCapability.FileManagement.File.FileIO 3314 3315**返回值：** 3316 3317 | 类型 | 说明 | 3318 | ------- | ----------------- | 3319 | boolean | 表示当前目录项是否是字符特殊设备。 | 3320 3321**示例：** 3322 3323 ```js 3324 let dir = fileio.opendirSync(pathDir); 3325 let isCharacterDevice = dir.readSync().isCharacterDevice(); 3326 ``` 3327 3328 3329### isDirectory 3330 3331isDirectory(): boolean 3332 3333用于判断当前目录项是否是目录。 3334 3335**系统能力**：SystemCapability.FileManagement.File.FileIO 3336 3337**返回值：** 3338 3339 | 类型 | 说明 | 3340 | ------- | ------------- | 3341 | boolean | 表示当前目录项是否是目录。 | 3342 3343**示例：** 3344 3345 ```js 3346 let dir = fileio.opendirSync(pathDir); 3347 let isDirectory = dir.readSync().isDirectory(); 3348 ``` 3349 3350 3351### isFIFO 3352 3353isFIFO(): boolean 3354 3355用于判断当前目录项是否是命名管道（有时也称为FIFO）。命名管道通常用于进程间通信。 3356 3357**系统能力**：SystemCapability.FileManagement.File.FileIO 3358 3359**返回值：** 3360 3361 | 类型 | 说明 | 3362 | ------- | --------------- | 3363 | boolean | 表示当前目录项是否是FIFO。 | 3364 3365**示例：** 3366 3367 ```js 3368 let dir = fileio.opendirSync(pathDir); 3369 let isFIFO = dir.readSync().isFIFO(); 3370 ``` 3371 3372 3373### isFile 3374 3375isFile(): boolean 3376 3377用于判断当前目录项是否是普通文件。 3378 3379**系统能力**：SystemCapability.FileManagement.File.FileIO 3380 3381**返回值：** 3382 3383 | 类型 | 说明 | 3384 | ------- | --------------- | 3385 | boolean | 表示当前目录项是否是普通文件。 | 3386 3387**示例：** 3388 3389 ```js 3390 let dir = fileio.opendirSync(pathDir); 3391 let isFile = dir.readSync().isFile(); 3392 ``` 3393 3394 3395### isSocket 3396 3397isSocket(): boolean 3398 3399用于判断当前目录项是否是套接字。 3400 3401**系统能力**：SystemCapability.FileManagement.File.FileIO 3402 3403**返回值：** 3404 3405 | 类型 | 说明 | 3406 | ------- | -------------- | 3407 | boolean | 表示当前目录项是否是套接字。 | 3408 3409**示例：** 3410 3411 ```js 3412 let dir = fileio.opendirSync(pathDir); 3413 let isSocket = dir.readSync().isSocket(); 3414 ``` 3415 3416 3417### isSymbolicLink 3418 3419isSymbolicLink(): boolean 3420 3421用于判断当前目录项是否是符号链接。 3422 3423**系统能力**：SystemCapability.FileManagement.File.FileIO 3424 3425**返回值：** 3426 3427 | 类型 | 说明 | 3428 | ------- | --------------- | 3429 | boolean | 表示当前目录项是否是符号链接。 | 3430 3431**示例：** 3432 3433 ```js 3434 let dir = fileio.opendirSync(pathDir); 3435 let isSymbolicLink = dir.readSync().isSymbolicLink(); 3436 ``` 3437