精华内容
下载资源
问答
  • node.js将buffer对象转换为json对象

    千次阅读 2019-06-11 08:58:01
    d 是buffer对象 let jsstr = JSON.stringify(d); let jsondata = JSON.parse(jsstr); let buf = new Buffer(jsondata); let data = buf.toString(); sx = JSON.par...

    d 是buffer对象

    			let jsstr = JSON.stringify(d);
                let jsondata = JSON.parse(jsstr);
                let buf = new Buffer(jsondata);
                let data = buf.toString();
                sx = JSON.parse(data);
                console.log(sx['peer_count']);
    
    

    详见百度经验:
    https://jingyan.baidu.com/article/8ebacdf079f00549f75cd564.html

    展开全文
  • Node14 Buffer对象

    2019-05-05 09:52:17
    Buffer对象Node处理二进制数据的一个接口,它是Node原生提供的全局对象,可以直接使用,不需要require Buffer对象是一个构造函数,生成的实例代表了V8引擎分配的一段内存,是一个类数组对象,成员是0到255的数值,...

    概述

    Buffer对象是Node处理二进制数据的一个接口,它是Node原生提供的全局对象,可以直接使用,不需要require

    Buffer对象是一个构造函数,生成的实例代表了V8引擎分配的一段内存,是一个类数组对象,成员是0到255的数值,即一个8位的字节

    let btyes = new Buffer(2)
    
    // <Buffer 00 00>
    

    与二进制数组的关系

    TypedArray构造函数可以接受Buffer实例作为参数,生成一个二进制数组,例如new Unit32Array(new Buffer([1, 2, 3, 5]))会生成一个4个成员的二进制数组

    这时二进制数组对应的内存是从Buffer对象拷贝的,而不是共享的,二进制数组的buffer属性,保留指向原Buffer对象的指针。

    Buffer构造函数

    Buffer作为构造函数,可以使用new命令生成一个实例,可以接受多种形式的参数:

    // 参数是整数,指定分配多少个字节内存
    var hello = new Buffer(5);
    
    // 参数是数组,数组成员必须是整数值
    var hello = new Buffer([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
    hello.toString() // 'Hello'
    
    // 参数是字符串(默认为utf8编码)
    var hello = new Buffer('Hello');
    hello.length // 5
    hello.toString() // "Hello"
    
    // 参数是字符串(不省略编码)
    var hello = new Buffer('Hello', 'utf8');
    
    // 参数是另一个Buffer实例,等同于拷贝后者
    var hello1 = new Buffer('Hello');
    var hello2 = new Buffer(hello1);
    

    类的方法

    (1)Buffer.isEncoding(),返回布尔值,表示是否为指定编码

    Buffer.isEncoding('utf8');
    // true
    

    (2)Buffer.isBuffer(),接受一个对象作为参数,返回布尔值,表示该对象是否是Buffer实例:

    Buffer.isBuffer(Date);
    // false
    

    (3)Buffer.byteLength(),返回字符串实际占据的字节长度,默认编码为utf-8

    Buffer.byteLength('Hello', 'utf8') // 5
    

    (4)Buffer.concat(),用来将一组Buffer对象合并为一个Buffer对象

    var i1 = new Buffer('Hello');
    var i2 = new Buffer(' ');
    var i3 = new Buffer('World');
    Buffer.concat([i1, i2, i3]).toString()
    // 'Hello World'
    

    可以接受第二个参数,指定合并后的Buffer对象的总长度

    实例属性/方法

    (1)length,返回Buffer对象所占据的内存涨肚,与Buffer对象内容无关

    buf = new Buffer(1234);
    buf.length // 1234
    
    buf.write("some string", 0, "ascii");
    buf.length // 1234
    

    上面length返回值总是Buffer对象的空间长度,内容的长度通过Buffer.byteLength来获取

    length属性是可写的,但是会导致意外,不建议使用,如果想修改Buffer对象的长度,建议使用slice方法返回新的Buffer对象

    (2)write(),、向指定的Buffer对象写入数据,第一个参数是写入的内容,第二个参数是写入的起始位置(可省略,默认从0开始),第三个参数是编码方式(默认是utf-8,可省略)

    let buf = new Buffer(5)
    buf.write('Hello')
    
    console.log(buf)
    // <Buffer 48 65 6c 6c 6f>
    
    console.log(buf.toString())
    // 'Hello'
    

    (3)slice(),返回一个按照指定位置,所原对象切割的Buffer实例,两个参数是切割的起始位置和终止位置([start, end)

    (4)toString(),将Buffer实例按照指定编码(默认为utf-8)转换为字符串

    (5)toJSON(),将Buffer实例转换为JSON对象

    参考

    展开全文
  • Node体验之process对象Buffer对象 一、process对象 1. process对象是一个全局对象,在哪都可以访问它。 2. 通过这个对象的属性和方法可以对当前运行程序的进程进行访问和控制。

    Node体验之process对象和Buffer对象

    一、process对象

    1. process对象是一个全局对象,在哪都可以访问它。

    2. 通过这个对象的属性和方法可以对当前运行程序的进程进行访问和控制。

    3. 部分属性和方法:

    argv ,一组包含命令行参数的数组。
    
    execPath ,开启当前进程的绝对路径。
    
    env ,返回用户环境信息。
    
    platform ,返回当前操作系统平台。
    
    cwd() ,返回当前进程的工作目录。
    
    chdir(directory),改变当前进程的工作目录。
    
    memoryUsage() ,返回node进程使用的内存情况,单位是byte。
    
    exit(code),退出。
    
    kill(pid),向进程发送信息结束进程。
    
    stdout ,标准输出流。
    
    stdin ,标准输入流。
    
    stderr ,标准错误流。
    

    示例:

    (1)用stdout模仿conso.log

        console.log("Hello");  //Hello
    
        //这行代码可等价于
        function  Log(data) {
            process.stdout.write(data);
        }
        Log("Hello");  //Hello

    (2)使用stdin和stdout实现简单键盘输入的运算

        var a,b;
        process.stdout.write("请输入a的值: ");
        process.stdin.resume() ; //默认情况下,输入流是关闭的,所以要先开启输入流
        process.stdin.on('data',function (chunk) { //监听用户输入的数据
            if(!a){
                a = Number(chunk);
                process.stdout.write("请输入b的值: ");
            }else{
                b = Number(chunk);
                process.stdout.write("求和结果a + b =  "+(a+b));
            }
        });
    

    Buffer类

    1.一个用于更好操作二进制数据的类。

    我们在操作文件或网络数据传输的时候,其实都是在操作二进制数据流,node就提供了这个Buffer类来更好的操作,Buffer是一个全局的类。

    2.创建Buffer类

    方法:

        new Buffer(size);
        new Buffer(array);
        new Buffer(string,[encoding]);
    

    示例:

        //方法一
        var buf = new Buffer(5); //创建长度为10字节的Buffer实例
        console.log(buf); //<Buffer e0 35 26 00 00>
        console.log(buf.length); //5
    
        //方法二
        var buf1 = new Buffer([1,2,3,4,5]); //通过给定的数组创建buffer实例
        console.log(buf1); //<Buffer 01 02 03 04 05>
        console.log(buf1.length); //5
        buf1[6] = 6;
        console.log(buf1); //<Buffer 01 02 03 04 05>,不能再修改数组的长度
    
        //方法三
        var buf2 = new Buffer("www.baidu.com","utf-8"); //通过字符串创建buffer实例,utf-8 是默认的编码方式
        console.log(buf2); //<Buffer 77 77 77 2e 62 61 69 64 75 2e 63 6f 6d>
        console.log(buf2.length); //13
        for(var i=0; i<buf2.length; i++){
        console.log(buf2[i]); //输出十进制:119 119 119 46 98 97 105 100 117 46 99 111 109
        console.log((buf2[i]).toString(16));  //输出十六进制:77 77 77 2e 62 61 69 64 75 2e 63 6f 6d
        console.log(String.fromCharCode(buf2[i])); //输出字符串:www baidu com
        }
    
        //方法三中:中文字符和英文字符长度不一样
        var str = "hello";
        var buf3 = new Buffer(str);
        console.log(str.length); //5
        console.log(buf3.length); //5
        var str1 = "你好";
        var buf4 = new Buffer(str1);
        console.log(str1.length); //2
        console.log(buf4.length); //6

    3.Buffer类的部分属性和方法

    buf.length  ,buffer的字节数大小。
    
    buf[index] ,获取或设置在指定index索引位置的8字节内容。
    
    buf.write(string,[offset],[length],[index]),根据指定的偏移位置和编码方式,将长度为length的数据string插入到buffer中。
    
    buf.toString ([encoding],[start],[end]) ,根据encoding参数返回一个解码的string类型。
    
    buf.toJSON(),返回一个JSON表示的Buffer实例,JSON.stringify将会默认调用来序列化这个Buffer实例。
    
    buf.slice([start],[end]) ,返回一个新的buffer,这个buffer将会和原来的buffer引用相同地址,并且,修改这个新的buffer实例切片也会修改原来的buffer。
    
    buf.copy(tatgetBuffer,[targetStart],[sourceStart],[sourceEnd]) ,拷贝Buffer。
    

    示例:

         //buf.write(要写入的数据,从第几位开始写,写入的数据的长度,写入的数据的编码方法)
         var str3 = "hello world";
         console.log(new Buffer(str3)); //<Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
         var buf5 = new Buffer(5);
         buf5.write(str3);
         console.log(buf5); //<Buffer 68 65 6c 6c 6f>
         buf5.write(str3,2);
         console.log(buf5);//<Buffer 68 65 68 65 6c>
    
        //使用buf.tostring
         var buf6 = new Buffer('hello');
         console.log(buf6.toString()); //hello
         console.log(buf6.toString('utf-8',1,3)); //el
    
         var buf7  = new Buffer('你好');
         console.log(buf7.toString()); //你好
         console.log(buf7.toString('utf-8',1)); //��好(乱码)
    
         console.log(buf7.toJSON()); //{ type: 'Buffer', data: [ 228, 189, 160, 229, 165, 189 ] }
    
        //使用buf.slice()
         var buf8 = new Buffer('hello world');
         console.log(buf8); //<Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
         var buf9 = buf8.slice();
         console.log(buf9); //<Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
         var buf10 = buf8.slice(2,6);
         console.log(buf10); //<Buffer 6c 6c 6f 20>
         //新的buffer将会和原来的buffer引用相同地址,并且,修改这个新的buffer实例切片也会修改原来的buffer。
         buf10[0] = 2;
         console.log(buf10); //<Buffer 02 6c 6f 20>
         console.log(buf9); //<Buffer 68 65 02 6c 6f 20 77 6f 72 6c 64>,改变了原来的Buffer
    
        //使用buf.copy()
        var bf = new Buffer('hello');
        console.log(bf); //<Buffer 68 65 6c 6c 6f>
        var buf11 = new Buffer(10);
        bf.copy(buf11);
        console.log(buf11); //<Buffer 68 65 6c 6c 6f 00 00 00 00 00>
        buf11[3] = 5;
        console.log(buf11); //<Buffer 68 65 6c 05 6f 00 00 00 00 00>
        console.log(bf); //<Buffer 68 65 6c 6c 6f> ,没有改变原来的buffer
    
    
        var bf1 = new Buffer('hello');
        var buf12 = new Buffer(10);
        console.log(bf1);  //<Buffer 68 65 6c 6c 6f>
        console.log(buf12); //<Buffer 10 00 00 00 08 00 00 00 18 79>
        bf1.copy(buf12,2);
        console.log(buf12); //<Buffer 10 00 68 65 6c 6c 6f 00 18 79>
        bf1.copy(buf12,1,2,4);
        console.log(buf12); //<Buffer 10 6c 6c 65 6c 6c 6f 00 18 79>

    4.Buffer静态类方法

    Buffer.isEncoding(encoding) ,如果给定的编码encoding是有效的,返回true,否则返回false。
    
    Buffer.isBuffer(obj) ,  测试obj是否是一个Buffer类。
    
    Buffer.byteLength(string,[encoding]) ,返回string这个字符串真实的byte长度,encoding默认编码是utf-8。
    
    Buffer.concat(list,[totalLength]) ,返回一个保存着将传入Buffer数组中所有buffer对象拼接在一起的buffer对象。
    

    示例:

        //判断是否支持当前编码
         console.log(Buffer.isEncoding('utf-8')); //true
         console.log(Buffer.isEncoding('gbk')); //false
         console.log(Buffer.isEncoding('hex')); //true
    
         //判断是否是一个Buffer类
         var arr = [1,2,3,4,5];
         var buf = new Buffer(5);
         console.log(Buffer.isBuffer(arr)); //false
         console.log(Buffer.isBuffer(buf)); //true
    
    
         //字符串真实长度
         var buf1 = new Buffer('hello');
         console.log(buf1.length); //5
         console.log(Buffer.byteLength(buf1)); //5
    
         var buf2 = new Buffer('你好');
         console.log(buf2.length); //6
         console.log(Buffer.byteLength(buf2)); //6
         console.log(Buffer.byteLength(buf2,'ascii')); //6
    
         //合并缓冲区:concat的使用
         var str1 = 'hello';
         var str2 = 'world';
         var list = [new Buffer(str1),new Buffer(str2)];
         console.log(list); //[ <Buffer 68 65 6c 6c 6f>, <Buffer 77 6f 72 6c 64> ]
         var buf3 = Buffer.concat(list,10);
         //var buf3 = Buffer.concat(list,(str1.length+str2.length));
         console.log(buf3); //<Buffer 68 65 6c 6c 6f 77 6f 72 6c 64>

    5.process对象操作中的buffer

        process.stdout.write("请输入内容: ");
        process.stdin.resume() ; //开启输入流
        process.stdin.on('data',function(chrunk){
        console.log(chrunk); //输入:1, 输出:<Buffer 31 0a>
        console.log(chrunk.toString()); //转成字符串后输出:1
            console.log("输入的内容是: " + chrunk); //此处因为有涉及字符串拼接,会自动调用tostring()方法,所以输出为:输入的内容是:1
         });

    注:如对本文有任何疑问,欢迎留言。

    展开全文
  • Node.js之Buffer对象浅析

    2020-03-05 09:39:12
    Node.js之Buffer对象浅析 前端开发的盲点,Node开发的基础 01 前言 前端的开发人员一般是不会去关注Buffer对象的,在大多数人看来前端就是写页面的程序员,但现在随着Node的发展,越来越多的前端工程师关注...

    Node.js之Buffer对象浅析

    前端开发的盲点,Node开发的基础

    在这里插入图片描述

    01 前言


    前端的开发人员一般是不会去关注Buffer的对象的,在大多数人看来前端就是写页面的程序员,但现在随着Node的发展,越来越多的前端工程师关注一些后端的开发流程。撇开前端的业务开发,我们来了解一下Node的工作都和哪些知识点打交道。

    与应用型的场景不一样,Node中需要处理网络协议、操作数据库、处理图片、接受上传文件等。我们知道在网络当中,数据都是以二进制的形式传播,现有的JavaScript已经不能满足要求了,所以Buffer应运而生。

    02 Buffer


    Buffer是一个像Array的对象,它的元素都是16进制的两位数。是一个典型的JavaScript与C++结合的模块,设计性能的相关部分采用了C++实现,而非性能部分采用了JavaScript实现。Buffer对象可以用来操作二进制数据流

    由于Buffer经常用于字符串以及大文件等操作,我们知道Node有垃圾收集机制,大对象不太可能存放在堆中,不然内存很快就会满了。buffer所占用的内存其实不是堆中的,而是堆外内存。Node在加载的时候就已经加载这个对象,并把它放在了全局对象上面。

    在这里插入图片描述

    03 内存管理模型


    Node程序在运行过程中,此进程占据的所有内存成为常驻内存。它由以下几个部分组成:

    • 代码区
    • 堆外内存

    他们之间的关系如下图:
    在这里插入图片描述

    04 Buffer内存分配


    我们知道,Buffer对象的内存分配不是在V8的堆内存中的,而是由Node的C++层面实现的内存申请的。由于大对象的存储空间是不确定的,不可能向操作系统申请,会对操作系统造成压力。所以Node在内存的使用上面应用的是C++层面申请内存,在JavaScript中分配内存的策略。

    那么它的具体分配策略是怎么样的呢?大对象和小对象的分配方式采用的算法是否是一样的呢?

    首先来介绍一下 slab 内存分配机制。它是一种动态内存管理机制,采用的是**预先申请,事后分配**的方式,简单来说它就是一块申请好的固定大小的内存区域。有如下3种状态:

    • full:完全分配
    • partial:部分分配
    • empty:没有被分配

    这种机制是以 **8KB为界限**来决定当前分配的对象是大对象还是小对象,也就是每一个slab的值。在JavaScript层面以它作为单位单元进行内存的分配。

    ①小对象内存分配

    我们在这里引入一个pool局部对象,Buffer在小对象的分配过程中会使用pool作为中间处理对象。

    在这里插入图片描述

    上图这个是刚申请的slab内存块的状态是 empty 状态,等待被分配,而下图是被两个小对象分配后的状态,为partial状态。值得注意的是,在一个小对象分配之前会判断这个 pool 空间是否还够,如果不够的话就会重新申请一块新的8KB内存来分配。

    所以一块 slab 可以被多个对象占有,加入第一次分配了1KB,但是下一个内存则要8KB,那么就造成了内存的浪费。这个1KB的小对象就占据了一整块内存。而且内存的释放规则是所有的对象释放之后,这块8KB的slab才会回收。

    V8 GC 对其不直接起作用,Buffer 对象被 GC 的时候会触发一个回调(C++ 层面的回调),而 Node.js 源码中定义的那个回调里面做的事就是释放那块内存。

    在这里插入图片描述

    ②大对象内存分配

    如果这个对象是超过了 slab 的大小,那么就不会占用slab块,直接使用C++层面分配你所需要的大小,这块空间就会被你一直占有。举个简单的例子就是:

    就像银行办理普通业务的客人一样,都规矩地在前台办理,但是VIP客户可以直接找银行行长。这里每一位银行业务员都是一个个slab,都是预先分配好的,然后VIP客人的需求可能更大,那么就直接找行长办理,无需繁杂的手续。
    在这里插入图片描述

    这里我们总结一下,Buffer对象都是在JavaScript层面的,能够被V8的垃圾回收机制标记回收的。但是Buffer操作的字节真正的内存是在Node的C++层面提供的,JavaScript层面只是使用它。不论是小 Buffer 对象还是大 Buffer 对象,内存分配是在 C++ 层面完成,内存管理在 JavaScript 层面。如果解除两者的引用,Buffer对象最终还是可以被 V8 的垃圾回收标记所回收。

    在这里插入图片描述

    05 小结

    Buffer对象是Node服务端的一个重要的概念,占据着很重要的位置。不论我们读写文件还是网络请求都会用到这个对象,可能前端的开发人员不会过多关注这个东西。

    通过对buffer对象的内存分配,我们在以后的编程当中应该时刻关注着变量的分配,因为如果内存一旦泄露,1G的服务器内存也会很快地被占用完,严重的话会造成服务器的崩溃。

    参考文章

    • 深入浅出Node.js
    • 探究不在V8堆内存中存储得Buffer对象

    欢迎大家关注我的公众号《前端小时
    个人博客:blog.alanwu.site

    在这里插入图片描述

    展开全文
  • 主要介绍了Node.js实用代码段之获取Buffer对象字节长度,需要的朋友可以参考下
  • Node中,应用需要处理网络协议、操作数据库、处理图片、接收上传文件等,在网络流和文件的操作中,还要处理大量二进制数据,JavaScript自有的字符串远远不能满足这些需求,于是Buffer对象应运而生 Buffer
  • Buffer对象与JSON对象相互转换

    万次阅读 2016-06-28 22:19:05
    Buffer对象与JSON对象相互转换> buffer=new Buffer('我爱你,物理'); > json=JSON.stringify(buffer); '{"type":"Buffer","data":[230,136,145,231,136,177,228,189,160,239,188,140,231,13 7,169,231,144,134]}' >...
  • const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]); const json = JSON.stringify(buf); // 输出: {"type":"Buffer","data":[1,2,3,4,5]} console.log(json); const copy = JSON.parse(json, (key, value) =>...
  • Node.js中的Buffer对象

    2017-02-27 12:46:50
    因此在Node.js中,定义了一个Buffer类,该类用来创建一个专门存放二进制数据的缓存区创建Buffer对象Node.js中,Buffer类是一个可以在人员和模块中被利用的全局类,不需要另外加载任何模块。Buffer类拥有三种形式的...
  • Node.js8 Buffer对象

    2015-09-21 11:13:15
    Buffer对象Node.js用来处理二进制数据的一个接口。JavaScript比较擅长处理Unicode数据,对于处理二进制格式的数据(比如TCP数据流),就不太擅长。Buffer对象就是为了解决这个问题而提供的。该对象也是一个构造...
  • “ 前端开发的盲点,Node开发的基础”01 前言前端的开发人员一般是不会去关注Buffer对象的,在大多数人看来前端就是写页面的程序员,但现在随着Node的发展,越来越多的前端工程师关注一些后端的开发流程。...
  • Buffer对象  存放二进制数据的缓存区对象,常用于处理文件流和TCP流  默认utf-8编码,new Buffer('123', 'base64'), 第二个参数为指定编码类型  创建buf对象:  var buf = new Buffer()  var buf = new Buffer...
  • 从缓冲区转换为对象。 解析缓冲区 安装 npm install parse-buffer 例子 var parser = require ( 'parse-buffer' ) ; var def = parser ( p => p . object ( { version : p . string ( ':' ) } , { message1 : p ....
  • * buffer:缓存器区,就是 "临时存贮区" 的意思,是暂时存放在内存里的一段输入输出数据 * js语言自身只有字符串数据类型,没有二进制类型 ...[创建buffer对象方法] 1.直接构造 var buf=new Buf
  • 不像其它编程语言存在整数(int)、浮点数(float与double)这种明显的数值类型区别,在JavaScript中所有数值都是一个Number对象,,Node.js中为了区分不同数据的精确类型,为Buffer对象提供了二进制数据与JavaScript中...
  • Buffer 是一个 Javascript 与 C++ 结合的模块,它将性能...由于 Buffer 太过常见,Node 进程在启动时就已经加载了它,并将其放在全局对象(global)上。所以在使用 Buffer 时,无须通过 require() 即可直接使用。 ...
  • 先看测试结果: 如上图,变量buf是Buffer类型,但用typeof()函数判定时为object类型,而用Buffer.isBuffer()判定时则为true,这一点并不冲突,在...在对Buffer对象buf进行‘+’运算符操作后整个表达式的结果为str
  • nodeJS 把buffer对象转成图片

    千次阅读 2021-01-09 15:48:38
    // 生成图片把buffer写入到文件 fs.writeFile('', originBuffer, function(err){ if(err) { console.log(err) } }) let base64Img = originBuffer.toString('base64') let decodeImg = new Buffer (base6
  • 先将buffer 对象转换为 十进制 整数对象 用buff.readUInt32BE(0) 整数对象就可以进行位移或者与或运算了
  • buffer在使用的时候,就跟数组是一样,是new Buffer(size)的形式。  global全局对象下的buffer类,... //创建一个buffer对象,并为该对象分配一个大小,这个长度是固定的不能更改。 new Buffer(Array); //这种方
  • node Buffer

    2018-03-21 17:37:58
    在说Buffer这个模块之前,先来讨论一下node内存的问题。 我们在代码中声明变量并且赋值时,所使用的对象的内存分配在堆中。如果已申请的对空闲内存不够分配新的对象,将继续申请堆内存,直到堆的大小超过v8限制为止...
  • 在js中对于二进制数据没有进行很好的支持(前端中二进制数据用的较少)。...Buffer类和其他类的创建并无区别,只需要new其对象即可。 注:Buffer类有一个length属性,用来规定Buffer类的长度。 第一种:var buf=new Bu

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,555
精华内容 13,822
关键字:

buffernode对象转