nodejs学习笔记

安装

---

先从从官网下载安装node，然后webstrom里面配置nodejs的提示。

win8安装nodejs需要取得管理者权限

1.把安装文件放到C:windowsinstaller这个路径下
2.用管理员权限打开cmd，在里面输入C:windowsinstaller这个路径下的msi安 装程序，回车即可解决
3.在webstrom里面配置nodejs的提示，需要下载包，在setting里node设置，在线下载nodejs.tar.gz完毕后进行项目勾选。

---

模块

模块的使用

什么是模块

• 一个文件就是一个模块

• 每个模块都有自己的作用域

• 我们用var声明的一个变量并不是全局的，是属于当前模块下的，所以如果用 global访问会出现undefined

__filename : 当前文件被解析过后的绝对路径
也是当前模块的

模块加载系统require('模块');

**注意路径问题

例如：定义一个node2.js的文件

console.log("这是node2.js");

要想在node1.js里面引用可以用

require('./node2.js')//这是node2.js

模块加载机制的两个问题

1.加载路径

require('模块加载的路径')

路径可以写相对路径或者绝对路径

2.文件查找特点：

• 首先按照加载的模块的文件名称进行查找

• 如果没有找到，则会在模块文件名称后加上.js的后缀，进行查找

• 如果还没有找到，则会在文件名称后加上.json的后缀，进行查找

• 如果还没有，则会在文件名称后加上.node的后缀，进行查找

• 如果还没有，会抛出错误 文件名称> .js >.json>.node >错误

模块-module和exports

在一个模块中通过var定义的变量，其作用域范围是当前模块，外部不能够直接的访问。
如果我们想一个模块能够访问另外一个模块中定义的变量，可以：

• 1.把变量作为global对象的一个属性，但是这样的做法是推荐

• 2.使用模块对象 module

module:保存提供和当前模块有关的一些信息，可以通过

console.log(module)

来查看都有哪些属性。
在这个module对象，又一个子对象exports对象，我们可以通过这个对象对一个模块中的局部变量对象进行提供访问。

在node5.js中写入

var a=100;
module.exports.a=a;

在node4.js中引入

var m5=require('./node5');//这个方法的返回值，其实就是被加载模块中的module.export
console.log(m5);//{ a: 100 }

在模块作用域内，除了module.exports还有一个内置模块对象，exports, 他其实就是module.exports
例如：以下对象和对象的比较

console.log(module.exports==exports)//true

返回值是true
所以上面node5.js里面也可以写为

exports.a=a;

node4模块输入结果一样。
另在定义的一些细节时要尽量不去破坏它们的引用关系，也就是说如果不是赋值，而是重新定义，exports和module.exports的指向关系已经断开了

module.exports=[1,2,3]
//如果不是赋值，而是重新定义，exports和module.exports的指向关系已经断开了
exports.a = 200;
exports=[1,2,3]//这种定义也会断开

所以要尽量添加属性，而不是修改指向关系

全局对象

以下开始介绍一些内置API里面的属性，可以对照中文文档学习。

global

全局命名空间对象

__filename 和 __dirname

• __filename : 返回当前模块文件解析后的绝对路径，该属性其实并非全局的，而是模块作用域下的

• __dirname : 返回当前模块文件所在目录解析后的绝对路径，该属性也不是全局的，而是模块作用域下的。

也就是说要如下写法输出

console.log(__dirname);
console.log(__filename);

而不能加global.__filename

除了这两个属性还有全局对象下很多其它的属性和方法。
如：数组arrayvar d = new Date();，日期datevar arr = new Array(1,2,3);
全局下还有setTimeout等属性，具体参看全局对象API
例如：做一个命令行形式的时钟

 setInterval(function() {
    var d = new Date();
    console.log( '现在是：' + d.getFullYear() + '年' + (d.getMonth() + 1) + '月' + d.getDate() + '日 ' + d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds() );
}, 1000); 

process进程对象

process是一个全局对象，可以在任何地方访问到它，通过这个对象提供的属性和方法，可以让我们对当前运行的程序的进程进行访问和控制。

包含很多参数：

• argv

process.argv 包含命令行参数的数组。第一个元素是'node'，第二个参数是 JavaScript 文件的名字，第三个参数是任意的命令行参数。

console.log(process.argv); //[ 'C:\\Program Files\\nodejs\\node.exe','d:\\wamp\\www\\nodejs\\node6.js' ]

process.execPath 开启当前进程的执行文件的绝对路径。

process.env 返回用户环境信息

process.version 返回node版本信息

process.versions 返回node及其依赖包的版本信息

process.pid 当前进程的 PID 任务管理器里面的详细信息pid

process.title 当前进程的显示名称 (Getter/setter) 获取/设置

process.arch 返回当前 CPU 的架构：'arm'、'ia32' 或者 'x64'

process.platform 返回当前操作系统平台

process.cwd() 返回当前进程的工作目录

process.chdir(directory) 改变当前进程的工作目录

process.kill(pid)向进程发出信息

exit(code) 退出

 setInterval(function(){
        var d=new Date();
       console.log('现在的日期是：'+ d.getFullYear()+'年'+ (d.getMonth()+1)+'月'+ d.getDay()+'日 '+ d.getHours()+':'+ d.getMinutes()+':'+ d.getSeconds())
    
    },1000)
    
    setTimeout(function(){
        process.exit()
    },5000)

process.memoryUsage() 返回 Node 进程的内存使用情况，单位为byte

还有很多方法具体查看文档

stdin、stdout 标准输入输出流（IO）

概念理解

• 标准输入设备 具体概念请百度

• 标准输出设备 具体概念请百度

• stdin和stdout提供了操作输入数据和输出数据的方法，我们也通常称为IO操作

stdin 标准输入流
stdout 标准输出流

//process.stdout.write('hello');
function Log(data){
    process.stdout.write(data);
}
Log('你好')

老的流模式默认情况下输入流是关闭的,要监听处理输入流数据，首先要先开启

process.stdin.resume();//开启
//用于监听用户的输入数据
process.stdin.on('data',function(chunk){
console.log('用户输入了'+chunk);//用户回车了才会触发
});

案例：计算加减乘数

var a,b;
process.stdout.write('请输入a的值：');
process.stdin.on('data',function(chunk){
    //判断如果a不存在执行
    if(!a){
        a=Number(chunk);
        process.stdout.write('请输入b的值：');
    }
    else{
        b=Number(chunk);
        process.stdout.write('结果是：'+(a+b));
    }
});

Buffer类

作用：一个用于更好的操作二进制数据的类
我们在操作文件或者网络数据的时候，其实操作的就是二进制数据流，node为我们提供了一个更加方便的去操作，这种数据流的类Buffer，它是一个全局的类
三种构造方式

new Buffer(size) 分配一个长度
new Buffer(array)
new Buffer(str[, encoding])

new Buffer(size) size[number]创建一个Buffer对象，并为这个对象分配一个大小。
当我们为一个Buffer对象分配空间大小以后，其长度是固定的，不能更改

    var bf=new Buffer(5);//5个长度的大小`
    console.log(bf);//<Buffer 00 00 00 00 00>
    bf[1]=20;//增加内容
    console.log(bf);//<Buffer 00 14 00 00 00>  这是以十六进制的方式显示
    var bf=new Buffer([1,2,3,4]);
    console.log(bf);//<Buffer 01 02 03 04>
    bf[10]=10;//增加内容
    console.log(bf);//<Buffer 01 02 03 04> 其长度是固定的，不能更改
    
    var bf=new Buffer('cmdmarkd','utf-8');
    console.log(bf);//<Buffer 63 6d 64 6d 61 72 6b 64>把字符串转化编码

另检测字符串的 bf.length 指的是当前内容的字节长度并不是字符串的长度

var bf = new Buffer('markdown', 'utf-8');
console.log(bf);//<Buffer 6d 61 72 6b 64 6f 77 6e>

for (var i=0; i<bf.length; i++) {
    console.log( String.fromCharCode( bf[i] ) );
}
/*
打印结果：
<Buffer 6d 61 72 6b 64 6f 77 6e>
m
a
r
k
d
o
w
n
7
7
3
9*/

比较字节和字符串长度

var str1 = 'cdmarkd';
var bf1 = new Buffer(str1);
console.log(str1.length);//7
console.log(bf1.length);//7

var str2 = '学习中';
var bf2 = new Buffer(str2);
console.log(str2.length);//3
console.log(bf2.length);//9

buf.length 返回这个 buffer 的 bytes 数

buf[index] 获取或设置指定 index 位置的 8 位字节

buf.write(string, offset[, encoding])
根据参数 offset 偏移量和指定的 encoding 编码方式，将参数 、string数据写入buffer。
buf.write(要写入的字符串, 从Buffer对象中的几位开始写入, 写入的字符串的长度, 写入的字符串的编码)

var str = 'down';
console.log( new Buffer(str) );//<Buffer 64 6f 77 6e>
var bf = new Buffer(2);//规定2个字节
bf.write( str );
console.log(bf);//<Buffer 64 6f> 

以上代码可以看出，多余的部分被buffer截断了，所以写入的时候注意字符截取的问题。

var str = 'down';
console.log( new Buffer(str) );//<Buffer 64 6f 77 6e>
var bf = new Buffer(3);
bf.write(str,1);//偏移量指的是buffer的，就是从buffer的那一位算起，把字符串写入到字符串中的第一位
console.log(bf);//<Buffer 00 64>
bf.write(str, 1,3);//写入三个字符到str中
console.log(bf); //<Buffer 00 64 6f>

var bf = new Buffer('markdwon');
console.log( bf.toString() );//markdwon
console.log( bf.toString('utf-8', 1, 3) );//ar

var bf2 = new Buffer('学习');//存的是十六进制
console.log(bf2);//<Buffer e5 ad a6 e4 b9 a0>
console.log( bf2.toString('utf-8', 1) ); //存的是十六进制.中文打印出来的是乱码


console.log( bf.toJSON() ); //{ type: 'Buffer',data: [ 109, 97, 114, 107, 100, 119, 111, 110 ] }

FileSystem

1.文件系统模块 require('fs')
2.该模块是核心模块，需要使用reqire导入后使用
3.该模块提供了操作文件的一些API

fs.open(path, flags, [mode], callback)

• path : 要打开的文件的路径

• flags : 打开文件的方式 读/写

• mode : 设置文件的模式 读/写/执行 4/2/1

• callback : 回调

• err : 文件打开失败的错误保存在err里面，如果成功err为null

• fd : 被打开文件的标识，和定时器

    fs.open('1.txt', 'r', function(err, fd) {
        if (err) {
            console.log( '文件打开失败' );
        } else {
            console.log( '文件打开成功' );
            console.log( fd );
        }
    
    });

openSync

var fd = fs.openSync('1.txt', 'r');
console.log(fd);

fs.read(fd, buffer, offset, length, position, callback)

• fd : 通过open方法成功打开一个文件返回的编号

• buffer : buffer对象

• offset : 新的内容添加到buffer中的起始位置

• length ： 添加到buffer中内容的长度

• position ：读取的文件中的起始位置

• callback : 回调

• err

• buffer的长度

• buffer对象

var fs = require('fs');

fs.open('1.txt', 'r', function(err, fd) {

    if (err) {
        console.log('文件打开失败');
    } else {


        var bf1 = new Buffer('123456789');

        console.log(bf1);//<Buffer 31 32 33 34 35 36 37 38 39>

        fs.read( fd, bf1, 0, 4, null, function( err, len, newBf ) {

            console.log( bf1 );//<Buffer 61 62 63 64 35 36 37 38 39>
            console.log( len );4
            console.log( newBf );//<Buffer 61 62 63 64 35 36 37 38 39>

        } );

    }

});

当我们要对打开的文件进行写操作的时候，打开文件的模式应该是 读写 方式
fs.write(fd, buffer, offset, length[, position], callback)

• fd : 打开的文件

• buffer : 要写入的数据

• offset : buffer对象中要写入的数据的起始位置

• length : 要写入的buffer数据的长度

• position : fd中的起始位置

• callback : 回调
  其他详见api文档

项目构建

//项目构建
var projectData = {

    'name' : 'noedTest', //项目名称
    'fileData' : [  //创建的文件
        {
            'name' : 'css',
            'type' : 'dir'
        },
        {
            'name' : 'js',
            'type' : 'dir'
        },
        {
            'name' : 'images',
            'type' : 'dir'
        },
        {
            'name' : 'index.html',
            'type' : 'file',
            'content' : '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<h1>Hello</h1>\n\t</body>\n</html>',
        }
    ]

};

var fs = require('fs');
//判断
if ( projectData.name ) {
    fs.mkdirSync(projectData.name);

    var fileData = projectData.fileData;

    if ( fileData && fileData.forEach ) { //存在并且是个数组

        fileData.forEach(function(f) {//遍历数组

            f.path = projectData.name + '/' + f.name;//路径

            f.content = f.content || '';

            switch (f.type) {

                case 'dir':
                    fs.mkdirSync(f.path);
                    break;

                case 'file':
                    fs.writeFileSync(f.path, f.content);
                    break;

                default :
                    break;

            }

        });

    }

}

自动合并

var fs = require('fs');

var filedir = './noedTest/source';
//监听文件
fs.watch(filedir,function(ev,file){
    //console.log(ev + ' / ' + file); // 这里不需要判断file是否有内容
    //只要有一个文件发生了变化，我们就需要对这个文件夹下的所有文件进行读取，然后合并
    fs.readdir(filedir, function(err, dataList){
        var arr = [];
        dataList.forEach(function(f){
            if (f) {
                var info = fs.statSync(filedir + '/' + f);

                //console.log(info);

                if (info.mode == 33206) {
                    arr.push(filedir + '/' + f);
                }
            }
        });

        //读取数组中的文件内容，并合并

        var content = '';
        arr.forEach(function(f) {
            var c = fs.readFileSync( f );
            //console.log(c);
            content += c.toString() + '\n';

        });

        console.log(content);

        fs.writeFile('./noedTest/js/index.js', content);
    });


});

使用node进行web开发

用户浏览的简单流程：

• 1.用户通过浏览器发送一个http的请求到指定的主机

• 2.服务器接收到该请求，对该请求进行分析和处理

• 3.服务器处理完成以后，返回对应的数据到用户机器

• 4.浏览器接收服务器返回的数据，并根据接收到的进行分析和处理
  *

• 客户端 服务端

• 由客户端发送一个http请求到指定的服务端 -> 服务端接收并处理请求 -> 返回数据到客户端
  1.搭建一个http的服务器，用于处理用户发送的http请求

需要使用node提供一个模块 http

---

参考资料：

1.nodejs安装及环境配置（windows系统）
2.win8怎样打开命令提示符[cmd]
3.Node.js等安装包出现2503错误的解决方法