Node.js v16.18.1 文档


目录

buffer 缓冲区#

中英对照

Buffer 对象用于表示固定长度的字节序列。 许多 Node.js API 都支持 Buffer


缓冲区与字符编码#

中英对照

当在 Buffer 和字符串之间进行转换时,可以指定字符编码。 如果未指定字符编码,则默认使用 UTF-8。


        
        

        缓冲区与 TypedArray#

        中英对照

        Buffer 实例也是 JavaScript Uint8ArrayTypedArray 实例。 所有 TypedArray 方法都可在 Buffer 上使用。 但是,Buffer API 和 TypedArray API 之间存在细微的不兼容。

            
            
              
              

              
              

              
              

                  缓冲区与迭代器#

                  中英对照

                  可以使用 for..of 语法迭代 Buffer 实例:

                  
                  

                  Blob#

                  中英对照

                  Blob 封装了不可变的原始数据,可以在多个工作线程之间安全地共享。

                  new buffer.Blob([sources[, options]])#

                  中英对照

                    创建新的 Blob 对象,其中包含给定源的串接。

                    blob.arrayBuffer()#

                    中英对照

                      返回使用包含 Blob 数据副本的 <ArrayBuffer> 履行的 promise。

                      blob.size#

                      中英对照

                      Blob 的总大小(以字节为单位)。

                      blob.slice([start[, end[, type]]])#

                      中英对照

                        创建并返回包含此 Blob 对象数据子集的新 Blob。 原 Blob 没有改动。

                        blob.stream()#

                        中英对照

                          返回允许读取 Blob 内容的新 ReadableStream

                          blob.text()#

                          中英对照

                            返回使用解码为 UTF-8 字符串的 Blob 的内容履行的 promise。

                            blob.type#

                            中英对照

                              Blob 的内容类型。

                              Blob 对象和 MessageChannel#

                              中英对照

                              一旦创建了 <Blob> 对象,就可以通过 MessagePort 将其发送到多个目的地,而无需传输或立即复制数据。 只有在调用 arrayBuffer()text() 方法时才会复制 Blob 包含的数据。

                              
                              

                              Buffer#

                              中英对照

                              Buffer 类是直接处理二进制数据的全局类型。 它可以使用多种方式构建。

                              Buffer.alloc(size[, fill[, encoding]])#

                              中英对照

                                分配 size 个字节的新 Buffer。 如果 fillundefined,则 Buffer 将以零填充。

                                
                                

                                
                                

                                
                                

                                Buffer.allocUnsafe(size)#

                                中英对照

                                  分配 size 个字节的新 Buffer。 如果 size 大于 buffer.constants.MAX_LENGTH 或小于 0,则抛出 ERR_INVALID_ARG_VALUE

                                  
                                  

                                  Buffer.allocUnsafeSlow(size)#

                                  中英对照

                                    分配 size 个字节的新 Buffer。 如果 size 大于 buffer.constants.MAX_LENGTH 或小于 0,则抛出 ERR_INVALID_ARG_VALUE。 如果 size 为 0,则创建零长度 Buffer

                                    
                                    

                                    Buffer.byteLength(string[, encoding])#

                                    中英对照

                                      使用 encoding 编码时返回字符串的字节长度。 这与 String.prototype.length 不同,String.prototype.length 不考虑用于将字符串转换为字节的编码。

                                      
                                      

                                      Buffer.compare(buf1, buf2)#

                                      中英对照

                                        比较 buf1buf2,通常用于对 Buffer 实例的数组进行排序。 这相当于调用 buf1.compare(buf2)

                                        
                                        

                                        Buffer.concat(list[, totalLength])#

                                        中英对照

                                          返回新的 Buffer,它是将 list 中的所有 Buffer 实例连接在一起的结果。

                                          
                                          

                                          Buffer.from(array)#

                                          中英对照

                                            使用 0255 范围内的字节 array 分配新的 Buffer。 该范围之外的数组条目将被截断以符合它。

                                            
                                            

                                            Buffer.from(arrayBuffer[, byteOffset[, length]])#

                                            中英对照

                                              这将创建 ArrayBuffer 的视图,而无需复制底层内存。 例如,当传入对 TypedArray 实例的 .buffer 属性的引用时,新创建的 Buffer 将与 TypedArray 的底层 ArrayBuffer 共享相同的分配内存。

                                              
                                              

                                              
                                              

                                              
                                              

                                              Buffer.from(buffer)#

                                              中英对照

                                                将传入的 buffer 数据复制到新的 Buffer 实例上。

                                                
                                                

                                                Buffer.from(object[, offsetOrEncoding[, length]])#

                                                中英对照

                                                  对于 valueOf() 函数返回的值不严格等于 object 的对象,则返回 Buffer.from(object.valueOf(), offsetOrEncoding, length)

                                                  
                                                  

                                                  
                                                  

                                                  Buffer.from(string[, encoding])#

                                                  中英对照

                                                    创建包含 string 的新 Bufferencoding 参数标识将 string 转换为字节时要使用的字符编码。

                                                    
                                                    

                                                    Buffer.isBuffer(obj)#

                                                    中英对照

                                                      如果 objBuffer,则返回 true,否则返回 false

                                                      
                                                      

                                                      Buffer.isEncoding(encoding)#

                                                      中英对照

                                                        如果 encoding 是支持的字符编码的名称,则返回 true,否则返回 false

                                                        
                                                        

                                                        Buffer.poolSize#

                                                        中英对照

                                                          这是用于池的预分配内部 Buffer 实例的大小(以字节为单位)。 该值可以修改。

                                                          buf[index]#

                                                          中英对照

                                                            索引运算符 [index] 可用于获取和设置 buf 中位置 index 处的八位字节。 这些值是指单个字节,因此合法值范围介于 0x000xFF(十六进制)或 0255(十进制)之间。

                                                            
                                                            

                                                            buf.buffer#

                                                            中英对照

                                                              不保证此 ArrayBuffer 与原始 Buffer 完全对应。 有关详细信息,请参阅 buf.byteOffset 上的说明。

                                                              
                                                              

                                                              buf.byteOffset#

                                                              中英对照

                                                                当在 Buffer.from(ArrayBuffer, byteOffset, length) 中设置 byteOffset 时,或者有时在分配小于 Buffer.poolSizeBuffer 时,缓冲区不会从底层 ArrayBuffer 上的零偏移量开始。

                                                                
                                                                

                                                                buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])#

                                                                中英对照

                                                                  buftarget 进行比较并返回数字,该数字指示 buf 在排序顺序中是在 target 之前、之后还是与 target 相同。 比较基于每个 Buffer 中的实际字节序列。

                                                                    
                                                                    

                                                                    
                                                                    

                                                                    buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])#

                                                                    中英对照

                                                                      将数据从 buf 的区域复制到 target 的区域,即使 target 内存区域与 buf 重叠。

                                                                      
                                                                      
                                                                      
                                                                      
                                                                      

                                                                      buf.entries()#

                                                                      中英对照

                                                                        buf 的内容创建并返回 [index, byte] 对的迭代器

                                                                        
                                                                        

                                                                        buf.equals(otherBuffer)#

                                                                        中英对照

                                                                          如果 bufotherBuffer 具有完全相同的字节,则返回 true,否则返回 false。 相当于 buf.compare(otherBuffer) === 0

                                                                          
                                                                          

                                                                          buf.fill(value[, offset[, end]][, encoding])#

                                                                          中英对照

                                                                            用指定的 value 填充 buf。 如果没有给定 offsetend,则整个 buf 都会被填满:

                                                                            
                                                                            

                                                                            
                                                                            

                                                                            
                                                                            

                                                                            buf.includes(value[, byteOffset][, encoding])#

                                                                            中英对照

                                                                              相当于 buf.indexOf() !== -1

                                                                              
                                                                              

                                                                              buf.indexOf(value[, byteOffset][, encoding])#

                                                                              中英对照

                                                                                如果 value 是:

                                                                                  
                                                                                  

                                                                                  
                                                                                  

                                                                                  buf.keys()#

                                                                                  中英对照

                                                                                    创建并返回 buf 个键(索引)的迭代器

                                                                                    
                                                                                    

                                                                                    buf.lastIndexOf(value[, byteOffset][, encoding])#

                                                                                    中英对照

                                                                                      buf.indexOf() 相同,除了找到最后一次出现的 value 而不是第一次出现。

                                                                                      
                                                                                      

                                                                                      
                                                                                      

                                                                                      buf.length#

                                                                                      中英对照

                                                                                        返回 buf 中的字节数。

                                                                                        
                                                                                        

                                                                                        buf.parent#

                                                                                        中英对照

                                                                                        buf.parent 属性是 buf.buffer 的弃用别名。

                                                                                        buf.readBigInt64BE([offset])#

                                                                                        中英对照

                                                                                          从指定的 offset 处的 buf 读取有符号的大端序 64 位整数。

                                                                                          buf.readBigInt64LE([offset])#

                                                                                          中英对照

                                                                                            从指定的 offset 处的 buf 读取有符号的小端序 64 位整数。

                                                                                            buf.readBigUInt64BE([offset])#

                                                                                            中英对照

                                                                                              从指定的 offset 处的 buf 读取无符号的大端序 64 位整数。

                                                                                              
                                                                                              

                                                                                              buf.readBigUInt64LE([offset])#

                                                                                              中英对照

                                                                                                从指定的 offset 处的 buf 读取无符号的小端序 64 位整数。

                                                                                                
                                                                                                

                                                                                                buf.readDoubleBE([offset])#

                                                                                                中英对照

                                                                                                  从指定 offset 处的 buf 读取 64 位大端序双精度值。

                                                                                                  
                                                                                                  

                                                                                                  buf.readDoubleLE([offset])#

                                                                                                  中英对照

                                                                                                    从指定 offset 处的 buf 读取 64 位小端序双精度值。

                                                                                                    
                                                                                                    

                                                                                                    buf.readFloatBE([offset])#

                                                                                                    中英对照

                                                                                                      从指定 offset 处的 buf 读取 32 位大端序浮点数。

                                                                                                      
                                                                                                      

                                                                                                      buf.readFloatLE([offset])#

                                                                                                      中英对照

                                                                                                        从指定 offset 处的 buf 读取 32 位小端序浮点数。

                                                                                                        
                                                                                                        

                                                                                                        buf.readInt8([offset])#

                                                                                                        中英对照

                                                                                                          从指定的 offset 处的 buf 读取有符号的 8 位整数。

                                                                                                          
                                                                                                          

                                                                                                          buf.readInt16BE([offset])#

                                                                                                          中英对照

                                                                                                            从指定的 offset 处的 buf 读取有符号的大端序 16 位整数。

                                                                                                            
                                                                                                            

                                                                                                            buf.readInt16LE([offset])#

                                                                                                            中英对照

                                                                                                              从指定的 offset 处的 buf 读取有符号的小端序 16 位整数。

                                                                                                              
                                                                                                              

                                                                                                              buf.readInt32BE([offset])#

                                                                                                              中英对照

                                                                                                                从指定的 offset 处的 buf 读取有符号的大端序 32 位整数。

                                                                                                                
                                                                                                                

                                                                                                                buf.readInt32LE([offset])#

                                                                                                                中英对照

                                                                                                                  从指定的 offset 处的 buf 读取有符号的小端序 32 位整数。

                                                                                                                  
                                                                                                                  

                                                                                                                  buf.readIntBE(offset, byteLength)#

                                                                                                                  中英对照

                                                                                                                    从指定的 offset 处的 buf 读取 byteLength 个字节,并将结果解释为支持最高 48 位精度的大端序、二进制补码有符号值。

                                                                                                                    
                                                                                                                    

                                                                                                                    buf.readIntLE(offset, byteLength)#

                                                                                                                    中英对照

                                                                                                                      从指定的 offset 处的 buf 读取 byteLength 个字节,并将结果解释为支持最高 48 位精度的小端序、二进制补码有符号值。

                                                                                                                      
                                                                                                                      

                                                                                                                      buf.readUInt8([offset])#

                                                                                                                      中英对照

                                                                                                                        从指定 offset 处的 buf 读取无符号 8 位整数。

                                                                                                                        
                                                                                                                        

                                                                                                                        buf.readUInt16BE([offset])#

                                                                                                                        中英对照

                                                                                                                          从指定的 offset 处的 buf 读取无符号的大端序 16 位整数。

                                                                                                                          
                                                                                                                          

                                                                                                                          buf.readUInt16LE([offset])#

                                                                                                                          中英对照

                                                                                                                            从指定的 offset 处的 buf 读取无符号的小端序 16 位整数。

                                                                                                                            
                                                                                                                            

                                                                                                                            buf.readUInt32BE([offset])#

                                                                                                                            中英对照

                                                                                                                              从指定的 offset 处的 buf 读取无符号的大端序 32 位整数。

                                                                                                                              
                                                                                                                              

                                                                                                                              buf.readUInt32LE([offset])#

                                                                                                                              中英对照

                                                                                                                                从指定的 offset 处的 buf 读取无符号的小端序 32 位整数。

                                                                                                                                
                                                                                                                                

                                                                                                                                buf.readUIntBE(offset, byteLength)#

                                                                                                                                中英对照

                                                                                                                                  从指定的 offset 处的 buf 读取 byteLength 个字节,并将结果解释为支持最高 48 位精度的无符号大端序整数。

                                                                                                                                  
                                                                                                                                  

                                                                                                                                  buf.readUIntLE(offset, byteLength)#

                                                                                                                                  中英对照

                                                                                                                                    从指定的 offset 处的 buf 读取 byteLength 个字节,并将结果解释为支持最高 48 位精度的无符号小端序整数。

                                                                                                                                    
                                                                                                                                    

                                                                                                                                    buf.subarray([start[, end]])#

                                                                                                                                    中英对照

                                                                                                                                      返回新的 Buffer,其引用与原始缓冲区相同的内存,但由 startend 索引进行偏移和裁剪。

                                                                                                                                      
                                                                                                                                      

                                                                                                                                      
                                                                                                                                      

                                                                                                                                      buf.slice([start[, end]])#

                                                                                                                                      中英对照

                                                                                                                                        返回新的 Buffer,其引用与原始缓冲区相同的内存,但由 startend 索引进行偏移和裁剪。

                                                                                                                                        
                                                                                                                                        

                                                                                                                                        buf.swap16()#

                                                                                                                                        中英对照

                                                                                                                                          buf 解释为无符号的 16 位整数数组,并就地交换字节顺序。 如果 buf.length 不是 2 的倍数,则抛出 ERR_INVALID_BUFFER_SIZE

                                                                                                                                          
                                                                                                                                          

                                                                                                                                          
                                                                                                                                          

                                                                                                                                          buf.swap32()#

                                                                                                                                          中英对照

                                                                                                                                            buf 解释为无符号的 32 位整数数组,并就地交换字节顺序。 如果 buf.length 不是 4 的倍数,则抛出 ERR_INVALID_BUFFER_SIZE

                                                                                                                                            
                                                                                                                                            

                                                                                                                                            buf.swap64()#

                                                                                                                                            中英对照

                                                                                                                                              buf 解释为 64 位数字数组,并就地交换字节顺序。 如果 buf.length 不是 8 的倍数,则抛出 ERR_INVALID_BUFFER_SIZE

                                                                                                                                              
                                                                                                                                              

                                                                                                                                              buf.toJSON()#

                                                                                                                                              中英对照

                                                                                                                                                返回 buf 的 JSON 表示。 JSON.stringify() 在字符串化 Buffer 实例时隐式调用此函数。

                                                                                                                                                
                                                                                                                                                

                                                                                                                                                buf.toString([encoding[, start[, end]]])#

                                                                                                                                                中英对照

                                                                                                                                                  根据 encoding 中指定的字符编码将 buf 解码为字符串。 startend 可以传入仅解码 buf 的子集。

                                                                                                                                                  
                                                                                                                                                  

                                                                                                                                                  buf.values()#

                                                                                                                                                  中英对照

                                                                                                                                                    buf 值(字节)创建并返回迭代器。 当在 for..of 语句中使用 Buffer 时,会自动调用此函数。

                                                                                                                                                    
                                                                                                                                                    

                                                                                                                                                    buf.write(string[, offset[, length]][, encoding])#

                                                                                                                                                    中英对照

                                                                                                                                                      根据 encoding 中的字符编码将 string 写入 bufoffset 处。 length 参数是要写入的字节数。 如果 buf 没有足够的空间来容纳整个字符串,则只会写入 string 的一部分。 但是,不会写入部分编码的字符。

                                                                                                                                                      
                                                                                                                                                      

                                                                                                                                                      buf.writeBigInt64BE(value[, offset])#

                                                                                                                                                      中英对照

                                                                                                                                                        value 作为大端序写入 buf 中指定的 offset

                                                                                                                                                        
                                                                                                                                                        

                                                                                                                                                        buf.writeBigInt64LE(value[, offset])#

                                                                                                                                                        中英对照

                                                                                                                                                          value 作为小端序写入 buf 中指定的 offset

                                                                                                                                                          
                                                                                                                                                          

                                                                                                                                                          buf.writeBigUInt64BE(value[, offset])#

                                                                                                                                                          中英对照

                                                                                                                                                            value 作为大端序写入 buf 中指定的 offset

                                                                                                                                                            
                                                                                                                                                            

                                                                                                                                                            buf.writeBigUInt64LE(value[, offset])#

                                                                                                                                                            中英对照

                                                                                                                                                              value 作为小端序写入 buf 中指定的 offset

                                                                                                                                                              
                                                                                                                                                              

                                                                                                                                                              buf.writeDoubleBE(value[, offset])#

                                                                                                                                                              中英对照

                                                                                                                                                                value 作为大端序写入 buf 中指定的 offsetvalue 必须是 JavaScript 数字 当 value 不是 JavaScript 数字时,则行为未定义。

                                                                                                                                                                
                                                                                                                                                                

                                                                                                                                                                buf.writeDoubleLE(value[, offset])#

                                                                                                                                                                中英对照

                                                                                                                                                                  value 作为小端序写入 buf 中指定的 offsetvalue 必须是 JavaScript 数字 当 value 不是 JavaScript 数字时,则行为未定义。

                                                                                                                                                                  
                                                                                                                                                                  

                                                                                                                                                                  buf.writeFloatBE(value[, offset])#

                                                                                                                                                                  中英对照

                                                                                                                                                                    value 作为大端序写入 buf 中指定的 offset。 当 value 不是 JavaScript 数字时,则行为未定义。

                                                                                                                                                                    
                                                                                                                                                                    

                                                                                                                                                                    buf.writeFloatLE(value[, offset])#

                                                                                                                                                                    中英对照

                                                                                                                                                                      value 作为小端序写入 buf 中指定的 offset。 当 value 不是 JavaScript 数字时,则行为未定义。

                                                                                                                                                                      
                                                                                                                                                                      

                                                                                                                                                                      buf.writeInt8(value[, offset])#

                                                                                                                                                                      中英对照

                                                                                                                                                                        value 写入 buf 中指定的 offsetvalue 必须是有效的有符号 8 位整数。 当 value 不是有符号的 8 位整数时,则行为未定义。

                                                                                                                                                                        
                                                                                                                                                                        

                                                                                                                                                                        buf.writeInt16BE(value[, offset])#

                                                                                                                                                                        中英对照

                                                                                                                                                                          value 作为大端序写入 buf 中指定的 offsetvalue 必须是有效的有符号 16 位整数。 当 value 不是有符号的 16 位整数时,则行为未定义。

                                                                                                                                                                          
                                                                                                                                                                          

                                                                                                                                                                          buf.writeInt16LE(value[, offset])#

                                                                                                                                                                          中英对照

                                                                                                                                                                            value 作为小端序写入 buf 中指定的 offsetvalue 必须是有效的有符号 16 位整数。 当 value 不是有符号的 16 位整数时,则行为未定义。

                                                                                                                                                                            
                                                                                                                                                                            

                                                                                                                                                                            buf.writeInt32BE(value[, offset])#

                                                                                                                                                                            中英对照

                                                                                                                                                                              value 作为大端序写入 buf 中指定的 offsetvalue 必须是有效的有符号 32 位整数。 当 value 不是有符号的 32 位整数时,则行为未定义。

                                                                                                                                                                              
                                                                                                                                                                              

                                                                                                                                                                              buf.writeInt32LE(value[, offset])#

                                                                                                                                                                              中英对照

                                                                                                                                                                                value 作为小端序写入 buf 中指定的 offsetvalue 必须是有效的有符号 32 位整数。 当 value 不是有符号的 32 位整数时,则行为未定义。

                                                                                                                                                                                
                                                                                                                                                                                

                                                                                                                                                                                buf.writeIntBE(value, offset, byteLength)#

                                                                                                                                                                                中英对照

                                                                                                                                                                                  valuebyteLength 个字节作为大端序写入 buf 中指定的 offset。 支持最高 48 位的精度。 当 value 不是有符号整数时,则行为未定义。

                                                                                                                                                                                  
                                                                                                                                                                                  

                                                                                                                                                                                  buf.writeIntLE(value, offset, byteLength)#

                                                                                                                                                                                  中英对照

                                                                                                                                                                                    valuebyteLength 个字节作为小端序写入 buf 中指定的 offset。 支持最高 48 位的精度。 当 value 不是有符号整数时,则行为未定义。

                                                                                                                                                                                    
                                                                                                                                                                                    

                                                                                                                                                                                    buf.writeUInt8(value[, offset])#

                                                                                                                                                                                    中英对照

                                                                                                                                                                                      value 写入 buf 中指定的 offsetvalue 必须是有效的无符号 8 位整数。 当 value 不是无符号 8 位整数时,则行为未定义。

                                                                                                                                                                                      
                                                                                                                                                                                      

                                                                                                                                                                                      buf.writeUInt16BE(value[, offset])#

                                                                                                                                                                                      中英对照

                                                                                                                                                                                        value 作为大端序写入 buf 中指定的 offsetvalue 必须是有效的无符号 16 位整数。 当 value 不是无符号 16 位整数时,则行为未定义。

                                                                                                                                                                                        
                                                                                                                                                                                        

                                                                                                                                                                                        buf.writeUInt16LE(value[, offset])#

                                                                                                                                                                                        中英对照

                                                                                                                                                                                          value 作为小端序写入 buf 中指定的 offsetvalue 必须是有效的无符号 16 位整数。 当 value 不是无符号 16 位整数时,则行为未定义。

                                                                                                                                                                                          
                                                                                                                                                                                          

                                                                                                                                                                                          buf.writeUInt32BE(value[, offset])#

                                                                                                                                                                                          中英对照

                                                                                                                                                                                            value 作为大端序写入 buf 中指定的 offsetvalue 必须是有效的无符号 32 位整数。 当 value 不是无符号 32 位整数时,则行为未定义。

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            buf.writeUInt32LE(value[, offset])#

                                                                                                                                                                                            中英对照

                                                                                                                                                                                              value 作为小端序写入 buf 中指定的 offsetvalue 必须是有效的无符号 32 位整数。 当 value 不是无符号 32 位整数时,则行为未定义。

                                                                                                                                                                                              
                                                                                                                                                                                              

                                                                                                                                                                                              buf.writeUIntBE(value, offset, byteLength)#

                                                                                                                                                                                              中英对照

                                                                                                                                                                                                valuebyteLength 个字节作为大端序写入 buf 中指定的 offset。 支持最高 48 位的精度。 当 value 不是无符号整数时,则行为未定义。

                                                                                                                                                                                                
                                                                                                                                                                                                

                                                                                                                                                                                                buf.writeUIntLE(value, offset, byteLength)#

                                                                                                                                                                                                中英对照

                                                                                                                                                                                                  valuebyteLength 个字节作为小端序写入 buf 中指定的 offset。 支持最高 48 位的精度。 当 value 不是无符号整数时,则行为未定义。

                                                                                                                                                                                                  
                                                                                                                                                                                                  

                                                                                                                                                                                                  new Buffer(array)#

                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                    参见 Buffer.from(array)

                                                                                                                                                                                                    new Buffer(arrayBuffer[, byteOffset[, length]])#

                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                      参见 Buffer.from(arrayBuffer[, byteOffset[, length]])

                                                                                                                                                                                                      new Buffer(buffer)#

                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                        参见 Buffer.from(buffer)

                                                                                                                                                                                                        new Buffer(size)#

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                          参见 Buffer.alloc()Buffer.allocUnsafe()。 构造函数的此变体等效于 Buffer.alloc()

                                                                                                                                                                                                          new Buffer(string[, encoding])#

                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                            参见 Buffer.from(string[, encoding])

                                                                                                                                                                                                            node:buffer 模块 API#

                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                            虽然 Buffer 对象可作为全局对象使用,但还有其他与 Buffer 相关的 API 仅可通过使用 require('node:buffer') 访问的 node:buffer 模块使用。

                                                                                                                                                                                                            buffer.atob(data)#

                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                              将 Base64 编码的数据字符串解码为字节,并使用 Latin-1 (ISO-8859-1) 将这些字节编码为字符串。

                                                                                                                                                                                                              buffer.btoa(data)#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                使用 Latin-1 (ISO-8859) 将字符串解码为字节,并使用 Base64 将这些字节编码为字符串。

                                                                                                                                                                                                                buffer.INSPECT_MAX_BYTES#

                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                  返回调用 buf.inspect() 时将返回的最大字节数。 这可以被用户模块覆盖。 有关 buf.inspect() 行为的更多详细信息,请参阅 util.inspect()

                                                                                                                                                                                                                  buffer.kMaxLength#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                    buffer.constants.MAX_LENGTH 的别名。

                                                                                                                                                                                                                    buffer.kStringMaxLength#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                      buffer.constants.MAX_STRING_LENGTH 的别名。

                                                                                                                                                                                                                      buffer.resolveObjectURL(id)#

                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                        解析 'blob:nodedata:...',关联的使用先前调用 URL.createObjectURL() 注册的 <Blob> 对象。

                                                                                                                                                                                                                        buffer.transcode(source, fromEnc, toEnc)#

                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                          将给定的 BufferUint8Array 实例从一种字符编码重新编码为另一种。 返回新的 Buffer 实例。

                                                                                                                                                                                                                          
                                                                                                                                                                                                                          

                                                                                                                                                                                                                          SlowBuffer#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                          参见 Buffer.allocUnsafeSlow()。 从构造函数总是返回 Buffer 实例而不是 SlowBuffer 实例的意义上来说,这从来都不是一个类。

                                                                                                                                                                                                                          new SlowBuffer(size)#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                            参见 Buffer.allocUnsafeSlow()

                                                                                                                                                                                                                            缓冲区常量#

                                                                                                                                                                                                                            buffer.constants.MAX_LENGTH#

                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                              在 32 位架构上,该值当前为 230 - 1(约 1 GiB)。

                                                                                                                                                                                                                              buffer.constants.MAX_STRING_LENGTH#

                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                表示 string 原语可以拥有的最大 length,以 UTF-16 代码单元计算。

                                                                                                                                                                                                                                Buffer.from()、Buffer.alloc() 与 Buffer.allocUnsafe()#

                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                在 Node.js 6.0.0 之前的版本中,Buffer 实例是使用 Buffer 构造函数创建的,它根据提供的参数以不同的方式分配返回的 Buffer

                                                                                                                                                                                                                                    --zero-fill-buffers 命令行选项#

                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                    默认情况下,可以使用 --zero-fill-buffers 命令行选项启动 Node.js 以导致所有新分配的 Buffer 实例在创建时被零填充。 如果没有该选项,则使用 Buffer.allocUnsafe()Buffer.allocUnsafeSlow()new SlowBuffer(size) 创建的缓冲区不会填零。 使用此标志会对性能产生可衡量的负面影响。 仅在必要时使用 --zero-fill-buffers 选项以强制新分配的 Buffer 实例不能包含可能敏感的旧数据。

                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                    Buffer.allocUnsafe() 与 Buffer.allocUnsafeSlow() 不安全的原因#

                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                    当调用 Buffer.allocUnsafe()Buffer.allocUnsafeSlow() 时,分配的内存段未初始化(未清零)。 虽然这种设计使内存分配非常快,但分配的内存段可能包含潜在敏感的旧数据。 使用 Buffer.allocUnsafe() 创建的 Buffer 而不完全覆盖内存可以使此旧数据在读取 Buffer 内存时泄露。

                                                                                                                                                                                                                                    返回顶部