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