1# 压缩与解压 2 3本文针对常见的几种压缩、解压场景，介绍相关函数的使用方法。 4 5## 接口说明 6 7以下是示例中使用的主要接口，更多接口及使用方式请见[接口文档](../../reference/apis-basic-services-kit/js-apis-zlib.md)。 8 9| 接口名 | 接口描述 | 10| ------------------------------------------------------------ | ---------------------------- | 11| compressFile(inFile: string, outFile: string, options: Options): Promise<void> | 压缩文件。 | 12| decompressFile(inFile: string, outFile: string, options?: Options): Promise<void> | 解压文件。 | 13| compress(dest: ArrayBuffer, source: ArrayBuffer, sourceLen?: number): Promise<ZipOutputInfo> | 将源缓冲区压缩到目标缓冲区。 | 14| compressBound(sourceLen: number): Promise<number> | 计算返回压缩大小的上限。 | 15| uncompress(dest:ArrayBuffer, source: ArrayBuffer, sourceLen?: number): Promise<ZipOutputInfo> | 将压缩后的数据解压缩为原始的未压缩形式。 | 16| deflate(strm: ZStream, flush: CompressFlushMode): Promise<ReturnStatus> | 压缩数据。 | 17| inflate(strm: ZStream, flush: CompressFlushMode): Promise<ReturnStatus> | 解压数据。| 18 19## 开发步骤 20 21### 环境准备 22 23在应用沙箱目录下创建一个测试文件data.txt，并写入测试数据。示例代码如下。 24 25 ```ts 26 import { fileIo as fs} from '@kit.CoreFileKit' 27 import { BusinessError, zlib } from '@kit.BasicServicesKit' 28 29 @Entry 30 @Component 31 struct Index { 32 @State dataSize: number = 0; 33 34 build() { 35 Row() { 36 Column() { 37 // 在应用沙箱目录下创建文件data.txt，并写入测试数据 38 Button('创建测试文件data.txt').onClick(() => { 39 let path = this.getUIContext()?.getHostContext()?.filesDir; 40 // 创建文件data.txt 41 let inFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 42 // 写入测试数据 43 for (let index = 0; index < 100; index++) { 44 fs.writeSync(inFile.fd, index + ': hello world, hello world, hello world, hello world, hello world.\n'); 45 } 46 // 获取测试数据原始大小，并保存到dataSize中 47 let stat = fs.statSync(inFile.path); 48 this.dataSize = stat.size; 49 console.info('dataSize: ' + this.dataSize); 50 // 关闭文件 51 fs.closeSync(inFile); 52 }) 53 } 54 } 55 .height('100%') 56 .width('100%') 57 } 58 } 59 ``` 60 61### Zip文件的压缩与解压 62 63采用接口[zlib.compressFile()](../../reference/apis-basic-services-kit/js-apis-zlib.md#zlibcompressfile9-1)将文件data.txt压缩并归档到data.zip中，采用接口[zlib.decompressFile()](../../reference/apis-basic-services-kit/js-apis-zlib.md#zlibdecompressfile9-1)将data.zip解压到应用沙箱目录下，示例代码如下。 64 65 ```ts 66 import { fileIo as fs} from '@kit.CoreFileKit' 67 import { BusinessError, zlib } from '@kit.BasicServicesKit' 68 69 @Entry 70 @Component 71 struct Index { 72 build() { 73 Row() { 74 // 示例一：将测试文件data.txt压缩并归档到data.zip中。 75 Button('compressFile').onClick(() => { 76 let path = this.getUIContext()?.getHostContext()?.filesDir; 77 let inFile = path + '/data.txt'; 78 let outFile = path + '/data.zip'; 79 let options: zlib.Options = {}; 80 zlib.compressFile(inFile, outFile, options).then((data: void) => { 81 console.info('compressFile success, data: ' + JSON.stringify(data)); 82 }).catch((errData: BusinessError) => { 83 console.error(`compressFile errCode: ${errData.code}, message: ${errData.message}`); 84 }) 85 }) 86 87 // 示例二：将data.zip文件解压到应用沙箱目录下。 88 Button('decompressFile').onClick(() => { 89 let path = this.getUIContext()?.getHostContext()?.filesDir; 90 let inFile = path + '/data.zip'; 91 let outFile = path; 92 let options: zlib.Options = {}; 93 zlib.decompressFile(inFile, outFile, options).then((data: void) => { 94 console.info('decompressFile success, data: ' + JSON.stringify(data)); 95 }).catch((errData: BusinessError) => { 96 console.error(`decompressFile errCode: ${errData.code}, message: ${errData.message}`); 97 }) 98 }) 99 } 100 .height('100%') 101 .width('100%') 102 } 103 } 104 ``` 105 106### 已知大小缓冲区的压缩与解压 107 108针对一个已知大小的缓冲区中的数据，使用接口[compress()](../../reference/apis-basic-services-kit/js-apis-zlib.md#compress12)将其压缩到一个目的缓冲区中，使用接口[compressBound()](../../reference/apis-basic-services-kit/js-apis-zlib.md#compressbound12)计算压缩目的缓冲区大小的上限值，使用接口[uncompress()](../../reference/apis-basic-services-kit/js-apis-zlib.md#uncompress12)对存储压缩数据的缓冲区进行解压。由于解压时无法获取解压后原始数据的大小，为了确认解压后目的缓冲区的大小，需要在压缩前获取原始数据的大小并保存，示例代码如下。 109 110 ```ts 111 import { fileIo as fs} from '@kit.CoreFileKit' 112 import { BusinessError, zlib } from '@kit.BasicServicesKit' 113 114 @Entry 115 @Component 116 struct Index { 117 @State dataSize: number = 0; //用于保存原始数据的大小 118 119 build() { 120 Row() { 121 // 示例一：读取data.txt文件内容并存入一个缓冲区，调用compress接口压缩缓冲区中的数据到目标缓冲区，并将目标缓冲区的内容写入文件data.bin 122 Button('compress buffer').onClick(() => { 123 let path = this.getUIContext()?.getHostContext()?.filesDir; 124 let inFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 125 let outFile = fs.openSync(path + '/data.bin', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 126 // 读取data.txt文件的内容，并存入缓冲区inBuf 127 let stat = fs.statSync(inFile.path); 128 let inBuf = new ArrayBuffer(stat.size); 129 let readLen = fs.readSync(inFile.fd, inBuf); 130 console.info(`original size: ${stat.size}, read len: ${readLen}`); 131 // 获取原始数据的大小，并保存 132 this.dataSize = stat.size; 133 // 创建一个压缩对象实例 134 let zip = zlib.createZipSync(); 135 // 获取一个目标缓冲区的上限 136 zip.compressBound(stat.size).then((data) => { 137 console.info(`the max dest buf len is ${data}`); 138 // 目标缓冲区outBuf 139 let outBuf = new ArrayBuffer(data); 140 // 将inBuf中的数据压缩到outBuf中 141 zip.compress(outBuf, inBuf, readLen).then((zipOutInfo) => { 142 console.info(`compress success, status ${zipOutInfo.status}, destLen ${zipOutInfo.destLen}`); 143 // 将outBuf中的数据写入到data.bin文件 144 let writeLen = fs.writeSync(outFile.fd, outBuf, { length: zipOutInfo.destLen }); 145 console.info(`write destBuf to data.bin, writeLen ${writeLen}`); 146 // 关闭文件 147 fs.closeSync(inFile.fd); 148 fs.closeSync(outFile.fd); 149 }).catch((errData: BusinessError) => { 150 console.error(`errData is errCode:${errData.code} message:${errData.message}`); 151 }) 152 }).catch((errData: BusinessError) => { 153 console.error(`errData is errCode:${errData.code} message:${errData.message}`); 154 }) 155 }) 156 157 // 示例二：读取data.bin文件中的压缩数据并存入一个缓冲区，调用uncompress接口将缓冲区中的数据解压到目标缓冲区，并将目标缓冲区的内容写入文件data.txt 158 Button('uncompress buffer').onClick(() => { 159 let path = this.getUIContext()?.getHostContext()?.filesDir; 160 let inFile = fs.openSync(path + '/data.bin', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 161 let outFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 162 // 读取data.bin文件中的压缩数据，并存入缓冲区inBuf 163 let stat = fs.statSync(inFile.path); 164 let inBuf = new ArrayBuffer(stat.size); 165 let readLen = fs.readSync(inFile.fd, inBuf); 166 console.info(`compressed data size: ${stat.size}, read len: ${readLen}`); 167 // 创建一个目标缓冲区，此处的dataSize是我们进行数据压缩前保存的数据的原始大小 168 let outBuf = new ArrayBuffer(this.dataSize); 169 console.info(`the dest buf size is ${this.dataSize}`); 170 // 创建一个压缩对象实例 171 let zip = zlib.createZipSync(); 172 // 将inBuf中的数据解压缩outBuf中 173 zip.uncompress(outBuf, inBuf, readLen).then((zipOutInfo) => { 174 console.info(`uncompress success, status ${zipOutInfo.status}, destLen ${zipOutInfo.destLen}`); 175 // 将outBuf中的数据写入到data.txt文件 176 let writeLen = fs.writeSync(outFile.fd, outBuf, { length: zipOutInfo.destLen }); 177 console.info(`write destBuf to data.txt, writeLen ${writeLen}`); 178 // 关闭文件 179 fs.closeSync(inFile.fd); 180 fs.closeSync(outFile.fd); 181 }).catch((errData: BusinessError) => { 182 console.error(`errData is errCode:${errData.code} message:${errData.message}`); 183 }) 184 }) 185 } 186 .height('100%') 187 .width('100%') 188 } 189 } 190 ``` 191 192### 未知大小缓冲区的压缩与解压（zlib格式） 193 194针对一个未知大小的缓冲区中的数据，使用接口[deflate()](../../reference/apis-basic-services-kit/js-apis-zlib.md#deflate12)将从一个原始输入流中读取的数据进行压缩，使用接口[inflate()](../../reference/apis-basic-services-kit/js-apis-zlib.md#inflate12)将从一个压缩输入流中读取的数据进行解压，示例代码如下。 195 196 ```ts 197 import { fileIo as fs} from '@kit.CoreFileKit' 198 import { BusinessError, zlib } from '@kit.BasicServicesKit' 199 200 @Entry 201 @Component 202 struct Index { 203 build() { 204 Row() { 205 // 示例一：从文件中不断读取数据进行压缩 206 Button('deflateFile').onClick(() => { 207 let path = this.getUIContext()?.getHostContext()?.filesDir; 208 let inFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 209 let outFile = fs.openSync(path + '/data.bin', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 210 deflateFile(inFile, outFile).then(() => { 211 console.info('deflateFile success'); 212 fs.closeSync(inFile.fd); 213 fs.closeSync(outFile.fd); 214 }) 215 }) 216 217 // 示例二：从文件中不断读取压缩数据进行解压 218 Button('inflateFile').onClick(() => { 219 let path = this.getUIContext()?.getHostContext()?.filesDir; 220 let inFile = fs.openSync(path + '/data.bin', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 221 let outFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 222 inflateFile(inFile, outFile).then(() => { 223 console.info('deflateFile success'); 224 fs.closeSync(inFile.fd); 225 fs.closeSync(outFile.fd); 226 }) 227 }) 228 } 229 .height('100%') 230 .width('100%') 231 } 232 } 233 234 // 从一个文件中，不断的读入数据，进行压缩，并写入到另一个文件中 235 async function deflateFile(src: fs.File, dest: fs.File) { 236 let flush = zlib.CompressFlushMode.NO_FLUSH; 237 let strm: zlib.ZStream = {}; //初始化一个压缩流 238 const BUFLEN = 4096; 239 let inBuf = new ArrayBuffer(BUFLEN); // 初始化一个输入缓冲区 240 let outBuf = new ArrayBuffer(BUFLEN); // 初始化一个输出缓冲区 241 // 创建一个压缩对象实例 242 let zip = zlib.createZipSync(); 243 // 初始化流的状态 244 let initStatus = zip.deflateInit(strm, zlib.CompressLevel.COMPRESS_LEVEL_BEST_SPEED); 245 console.info('deflateInit ret: ' + (await initStatus).valueOf()); 246 do { 247 // 从文件中读取数据到缓冲区 248 let readLen = fs.readSync(src.fd, inBuf); 249 console.info("readSync readLen: " + readLen); 250 flush = readLen == 0 ? zlib.CompressFlushMode.FINISH : zlib.CompressFlushMode.NO_FLUSH; 251 // 设置输入缓冲区 252 strm.availableIn = readLen; 253 strm.nextIn = inBuf; 254 do { 255 // 设置输出缓冲区 256 strm.availableOut = BUFLEN; 257 strm.nextOut = outBuf; 258 try { 259 // 压缩输入缓冲区中数据到输出缓冲区 260 let deflateStatus = zip.deflate(strm, flush); 261 console.info('deflate ret: ' + (await deflateStatus).valueOf()); 262 // 更新流的状态 263 let innerStrm = zip.getZStream(); 264 strm.availableIn = (await innerStrm).availableIn; 265 strm.nextIn = (await innerStrm).nextIn; 266 strm.availableOut = (await innerStrm).availableOut; 267 strm.nextOut = (await innerStrm).nextOut; 268 strm.totalIn = (await innerStrm).totalIn; 269 strm.totalOut = (await innerStrm).totalOut; 270 271 if (strm.availableOut != undefined) { 272 // 将已完成压缩的数据，写入到输出文件中 273 let have = BUFLEN - strm.availableOut; 274 let writeLen = fs.writeSync(dest.fd, outBuf, { length: have }); 275 console.info(`writeSync writeLen: ${writeLen}`); 276 } 277 } catch (err) { 278 console.error('deflate err: ' + JSON.stringify(err)); 279 } 280 } while (strm.availableOut == 0); // 循环压缩输入缓冲区中剩余的数据，直到全部完成压缩 281 } while (flush != zlib.CompressFlushMode.FINISH); // 循环从文件中读取数据，直到数据全部读取 282 // 释放资源 283 zip.deflateEnd(strm); 284 } 285 286 // 从一个文件中，不断的读入已压缩的数据，进行解压，并写入到另一个文件中 287 async function inflateFile(src: fs.File, dest: fs.File) { 288 let status: zlib.ReturnStatus = zlib.ReturnStatus.OK; 289 let strm: zlib.ZStream = {}; //初始化一个压缩流 290 const BUFLEN = 4096; 291 let inBuf = new ArrayBuffer(BUFLEN); // 初始化一个输入缓冲区 292 let outBuf = new ArrayBuffer(BUFLEN); // 初始化一个输出缓冲区 293 // 创建一个压缩对象实例 294 let zip = zlib.createZipSync(); 295 // 初始化流的状态 296 let initStatus = zip.inflateInit(strm); 297 console.info('inflateInit ret: ' + (await initStatus).valueOf()); 298 do { 299 // 从文件中读取已压缩的数据到缓冲区 300 let readLen = fs.readSync(src.fd, inBuf); 301 console.info("readSync readLen: " + readLen); 302 if (readLen == 0) { 303 break; 304 } 305 // 设置输入缓冲区 306 strm.availableIn = readLen; 307 strm.nextIn = inBuf; 308 do { 309 // 设置输出缓冲区 310 strm.availableOut = BUFLEN; 311 strm.nextOut = outBuf; 312 try { 313 // 解压输入缓冲区中数据到输出缓冲区 314 let inflateStatus = zip.inflate(strm, zlib.CompressFlushMode.NO_FLUSH); 315 console.info('inflate ret: ' + (await inflateStatus).valueOf()); 316 // 更新流的状态 317 let innerStrm = zip.getZStream(); 318 strm.availableIn = (await innerStrm).availableIn; 319 strm.nextIn = (await innerStrm).nextIn; 320 strm.availableOut = (await innerStrm).availableOut; 321 strm.nextOut = (await innerStrm).nextOut; 322 strm.totalIn = (await innerStrm).totalIn; 323 strm.totalOut = (await innerStrm).totalOut; 324 325 if (strm.availableOut != undefined) { 326 // 将已完成解压的数据，写入到输出文件中 327 let have = BUFLEN - strm.availableOut; 328 let writeLen = fs.writeSync(dest.fd, outBuf, { length: have }); 329 console.info(`writeSync writeLen: ${writeLen}`); 330 } 331 } catch (err) { 332 console.error('inflate err: ' + JSON.stringify(err)); 333 } 334 } while (strm.availableOut == 0) // 循环解压输入缓冲区中剩余的数据，直到全部完成解压 335 } while (status != zlib.ReturnStatus.STREAM_END.valueOf()) // 循环从文件中读取数据，直到数据全部读取 336 // 释放资源 337 zip.inflateEnd(strm); 338 } 339 ``` 340 341### 未知大小缓冲区的压缩与解压（gzip格式） 342 343采用gzip格式，针对一个未知大小的缓冲区中的数据，使用接口[deflate()](../../reference/apis-basic-services-kit/js-apis-zlib.md#deflate12)将从一个原始输入流中读取的数据进行压缩，使用接口[inflate()](../../reference/apis-basic-services-kit/js-apis-zlib.md#inflate12)将从一个压缩输入流中读取的数据进行解压，示例代码如下。 344 345 ```ts 346 import { fileIo as fs} from '@kit.CoreFileKit' 347 import { BusinessError, zlib } from '@kit.BasicServicesKit' 348 349 @Entry 350 @Component 351 struct Index { 352 build() { 353 Row() { 354 // 示例一：从文件中不断读取数据进行压缩 355 Button('deflateGzipFile').onClick(() => { 356 let path = this.getUIContext()?.getHostContext()?.filesDir; 357 let inFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 358 let outFile = fs.openSync(path + '/data.gz', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 359 deflateGzipFile(inFile, outFile).then(() => { 360 console.info('deflateGzipFile success'); 361 fs.closeSync(inFile.fd); 362 fs.closeSync(outFile.fd); 363 }) 364 }) 365 366 // 示例二：从文件中不断读取压缩数据进行解压 367 Button('inflateGzipFile').onClick(() => { 368 let path = this.getUIContext()?.getHostContext()?.filesDir; 369 let inFile = fs.openSync(path + '/data.gz', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 370 let outFile = fs.openSync(path + '/data.txt', fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 371 inflateGzipFile(inFile, outFile).then(() => { 372 console.info('deflateGzipFile success'); 373 fs.closeSync(inFile.fd); 374 fs.closeSync(outFile.fd); 375 }) 376 }) 377 } 378 .height('100%') 379 .width('100%') 380 } 381 } 382 383 // 从一个文件中，不断的读入数据，进行压缩，并写入到另一个文件中 384 async function deflateGzipFile(src: fs.File, dest: fs.File) { 385 let flush = zlib.CompressFlushMode.NO_FLUSH; 386 let strm: zlib.ZStream = {}; //初始化一个压缩流 387 const BUFLEN = 4096; 388 let inBuf = new ArrayBuffer(BUFLEN); // 初始化一个输入缓冲区 389 let outBuf = new ArrayBuffer(BUFLEN); // 初始化一个输出缓冲区 390 // 创建一个压缩对象实例 391 let zip = zlib.createZipSync(); 392 // 初始化流的状态，windowBits > 15时，启用gzip格式 393 let windowBits = 15 + 16; 394 let initStatus = zip.deflateInit2(strm, zlib.CompressLevel.COMPRESS_LEVEL_BEST_SPEED, 395 zlib.CompressMethod.DEFLATED, windowBits, zlib.MemLevel.MEM_LEVEL_DEFAULT, 396 zlib.CompressStrategy.COMPRESS_STRATEGY_DEFAULT_STRATEGY); 397 console.info('deflateInit2 ret: ' + (await initStatus).valueOf()); 398 do { 399 // 从文件中读取数据到缓冲区 400 let readLen = fs.readSync(src.fd, inBuf); 401 console.info("readSync readLen: " + readLen); 402 flush = readLen == 0 ? zlib.CompressFlushMode.FINISH : zlib.CompressFlushMode.NO_FLUSH; 403 // 设置输入缓冲区 404 strm.availableIn = readLen; 405 strm.nextIn = inBuf; 406 do { 407 // 设置输出缓冲区 408 strm.availableOut = BUFLEN; 409 strm.nextOut = outBuf; 410 try { 411 // 压缩输入缓冲区中数据到输出缓冲区 412 let deflateStatus = zip.deflate(strm, flush); 413 console.info('deflate ret: ' + (await deflateStatus).valueOf()); 414 // 更新流的状态 415 let innerStrm = zip.getZStream(); 416 strm.availableIn = (await innerStrm).availableIn; 417 strm.nextIn = (await innerStrm).nextIn; 418 strm.availableOut = (await innerStrm).availableOut; 419 strm.nextOut = (await innerStrm).nextOut; 420 strm.totalIn = (await innerStrm).totalIn; 421 strm.totalOut = (await innerStrm).totalOut; 422 423 if (strm.availableOut != undefined) { 424 // 将已完成压缩的数据，写入到输出文件中 425 let have = BUFLEN - strm.availableOut; 426 let writeLen = fs.writeSync(dest.fd, outBuf, { length: have }); 427 console.info(`writeSync writeLen: ${writeLen}`); 428 } 429 } catch (err) { 430 console.error('deflate err: ' + JSON.stringify(err)); 431 } 432 } while (strm.availableOut == 0); // 循环压缩输入缓冲区中剩余的数据，直到全部完成压缩 433 } while (flush != zlib.CompressFlushMode.FINISH); // 循环从文件中读取数据，直到数据全部读取 434 // 释放资源 435 zip.deflateEnd(strm); 436 } 437 438 // 从一个文件中，不断的读入已压缩的数据，进行解压，并写入到另一个文件中 439 async function inflateGzipFile(src: fs.File, dest: fs.File) { 440 let status: zlib.ReturnStatus = zlib.ReturnStatus.OK; 441 let strm: zlib.ZStream = {}; //初始化一个压缩流 442 const BUFLEN = 4096; 443 let inBuf = new ArrayBuffer(BUFLEN); // 初始化一个输入缓冲区 444 let outBuf = new ArrayBuffer(BUFLEN); // 初始化一个输出缓冲区 445 // 创建一个压缩对象实例 446 let zip = zlib.createZipSync(); 447 // 初始化流的状态，windowBits > 15时，启用gzip格式 448 let windowBits = 15 + 16; 449 let initStatus = zip.inflateInit2(strm, windowBits); 450 console.info('inflateInit2 ret: ' + (await initStatus).valueOf()); 451 do { 452 // 从文件中读取已压缩的数据到缓冲区 453 let readLen = fs.readSync(src.fd, inBuf); 454 console.info("readSync readLen: " + readLen); 455 if (readLen == 0) { 456 break; 457 } 458 // 设置输入缓冲区 459 strm.availableIn = readLen; 460 strm.nextIn = inBuf; 461 do { 462 // 设置输出缓冲区 463 strm.availableOut = BUFLEN; 464 strm.nextOut = outBuf; 465 try { 466 // 解压输入缓冲区中数据到输出缓冲区 467 let inflateStatus = zip.inflate(strm, zlib.CompressFlushMode.NO_FLUSH); 468 console.info('inflate ret: ' + (await inflateStatus).valueOf()); 469 // 更新流的状态 470 let innerStrm = zip.getZStream(); 471 strm.availableIn = (await innerStrm).availableIn; 472 strm.nextIn = (await innerStrm).nextIn; 473 strm.availableOut = (await innerStrm).availableOut; 474 strm.nextOut = (await innerStrm).nextOut; 475 strm.totalIn = (await innerStrm).totalIn; 476 strm.totalOut = (await innerStrm).totalOut; 477 478 if (strm.availableOut != undefined) { 479 // 将已完成解压的数据，写入到输出文件中 480 let have = BUFLEN - strm.availableOut; 481 let writeLen = fs.writeSync(dest.fd, outBuf, { length: have }); 482 console.info(`writeSync writeLen: ${writeLen}`); 483 } 484 } catch (err) { 485 console.error('inflate err: ' + JSON.stringify(err)); 486 } 487 } while (strm.availableOut == 0) // 循环解压输入缓冲区中剩余的数据，直到全部完成解压 488 } while (status != zlib.ReturnStatus.STREAM_END.valueOf()) // 循环从文件中读取数据，直到数据全部读取 489 // 释放资源 490 zip.inflateEnd(strm); 491 } 492 ``` 493 494## 常见问题 495 4961. 17800005 传入的数据错误 497 498 可能原因和处理步骤，请参见[错误码17800005](../../reference/apis-basic-services-kit/errorcode-zlib.md#17800005-传入的数据错误)。 499 5002. 17800007 传入的缓冲区错误 501 502 可能原因和处理步骤，请参见[错误码17800007](../../reference/apis-basic-services-kit/errorcode-zlib.md#17800007-传入的缓冲区错误)。