NodeJS学习

一、Node.js概述：

Node.js官网：www.nodejs.org
1.Node.js是基于C++编写的基于V8引擎的javascript运行时环境。
2.Node.js是一门基于ECMAScript开发的服务器端语言，提供了（前端js
    没有的）很多扩展对象。
前端js：
    ES原生对象：string，number，Boolean， Math，date，error，
        function，Object，array，regexp
    Node.js：
        1.ES原生对象
        2.Node.js内置对象
        3.大量的第三方对象
        4.自定义对象
3.Node.js可以编写独立的服务器应用，无需借助其他
Node.js的意义：
    1.执行效率比PHP，jsp，java要快
    2.用一种语言统一了前后端开发。

特点：
    1.单线程逻辑处理
    2.非阻塞
    3.异步I/O处理
    4.事件驱动编程。

二、Node.js的两种运行方式

1.交互模式——用于测试 （控制台）
    读取用户输入，执行运算，输出执行结果、继续下一循环
    执行方法：输入一行js语句，回车执行
2.脚本模式——用于开发
    把要执行的所有js语句编写在一个独立的js文件中，一次性的提交
    给nodejs处理。此文件可以没有后缀
    执行方法：C:\Users\chen>node C:\Users\chen\Desktop\NodeJS\index.js

三、Node.js的基础语法及ES6新特性

1.数据类型： 
    1.原始类型
        string，number，Boolean。。。
        原始类型数据直接赋值即可
    2.引用类型
        ES原生对象，Node.js对象，自定义对象，引用类型通常需要
        使用new关键字创建
2.模板字符串
    ES6中提供的一种新的字符串形式
    1.使用模板方式定义字符串，数据可以实现换行
        var info = `
            用户名：Tom
            密码：123
        `;
        花括号里是什么格式输出的就是什么格式
    2.使用${}拼接变量，并且可以执行运算。
3.严格模式
    ES5中新增一种比普通模式更为严格的js运算模式
    使用方法：
        1.在整个脚本文件中启用严格模式
            在脚本文件的开头：“use strict”；
            用于新项目
        2.在单个函数内启用严格模式。
            function info(){
                "sue strict";
                //body...
            };
            用于老项目维护
    规则：
        1.修改常量的值是非法的——将静默失败升级为错误。
        2.不允许对未声明的变量赋值
        3.匿名函数的this不再指向全局。
4.变量的作用域
    全局作用域，局部作用域，块级作用域（ES6中专有）
    块级作用域：只能在当前代码块中使用
    代码块：任何一个 {} 都是代码块，if/for/while/do-while/switch/with...
    代码块中使用“let”声明块级作用域变量，出了代码块，便不可使用；
    使用let需要启用严格模式
5.循环结构
    1.for...of...(ES6)遍历数组的 （for循环的{}后不可以加“;”
        不然报错）
6.函数
    1.匿名函数的自调。
        => 箭头函数
        ()=>{}
        箭头函数只用于匿名函数
        箭头函数中不存在arguments对象 也不可以调用callee（）
        如果括号内只有一个参数 可以省略括号 直接 ‘参数名’=>{}
7.对象
    创建对象的方式：
        1.对象直接量
        2.构造函数方式
        3.原型继承方式
        4.class方式——ES6新增
          class  类：是一组相似对象的属性和行为的抽象集合。（描述
          一类事物统一的属性和功能的程序结构）。
          事物的属性就是class的属性，事物的功能就是class的方法。
          class必须在严格模式下启用
          "use strict";
            //创建自定义对象
            class Emp {
                //constructor是固定写法
                constructor(ename, eprice) { //声明一个构造函数
                        this.ename = ename;
                        this.eprice = eprice;
                    }
                    //自定义方法
                work() {
                    return `${this.ename} is working!`;
                }
                sal() {
                    return `${this.ename}'s price is ${this.eprice}!`;
                }
            }
            var e1 = new Emp("bob", 20003);
            实现继承：
            class Program extends Emp {
                constructor(ename, price, skills) {
                    //super([arguments]); // 访问父对象上的构造函数
                    //super.functionOnParent([arguments]); // 访问父对象上的方法
                    super(ename, price);
                    this.skills = skills;
                }
            //子级写与父级同样的方法名 可覆盖父级的方法
                work() {
                    return super.work() + ` skills are : ${this.skills}`;
                };
            }
            var p1 = new Program('陈强', '29394', 'Bootstrop');
        5.全局对象
            Node.js中全局对象是Global。
            var age = 20;
            console.log(window.age) //报错 window is not defined
            global.age //20
            在交互模式下，声明的全局变量是global的成员——全局对象的污染
            在脚本模式下，声明的全局变量不是global的成员——避免了全局对象的污染
            Global对象的成员属性和方法
            1.console用于向stdout(标准输出)和stderr(标准错误)输出信息。
                console.log()   //向stdout输出日志信息
                console.info()  //向stdout输出日志信息

                console.error() //向stderr输出错误信息
                console.warn()  //向stderr输出错误信息

                console.trace()  //想stderr输出栈轨信息

                consloe.dir()   //向stdout输出指定对象的字符串表示

                conslole.assert()  //断言，为真的断言，错误信息不回输出
                    为假的断言，抛出错误对象，输出错误信息，并且终止脚本的运行，
                    可以自定义错误信息。

                    console.time()  //测试代码的执行时间，与timeEnd（）配合使用
                    console.timeEnd()

                注意：consloe中的成员方法是异步的，输出顺序和书写顺序不一定完全一致。
            2.prosess 进程
                process.arch    //获取CPU架构类型
                process.platform    //获取操作系统类型
                process.env //获取操作系统环境变量
                process.cwd()   //获取当前文件所在工作目录
                process.execPath    //获取Node.js解释器所在目录
                process.versions    //获取Node.js版本信息
                process.uptime()    //获取Node.js进程运行时间(s)
                process.memoryUsage()//获取Node.js进程内存使用信息
                process.pid //获取进程ID号
                process.kill( pid ) //向指定进程ID号发送退出信号
            3.定时器
                global.setTimeout
                global.setInterval
                global.setImmediate //在下一次事件循环开始之前立即执行的定时器
                process.nextTick()  //本次事件循环结束后立即执行的定时器
                    process.nextTick() 先于 global.setImmediate() 执行
8.模块系统：
    Node.js中使用“Module（模块）”来规划不同的功能对象
    模块的分类：
        1.核心模块——Node.js的内置模块（有些不需要引用，有些需要引入）
        2.第三方模块
        3.自定义模块
        每一个被加载的js文件对应一个模块对象，包含响应的功能和函数。
        模块中声明的变量或函数的作用域叫做“模块作用域”，这些变量和函数都不是global
        的成员，默认只能在当前的js文件（当前模块）中使用。
        Node.js启动时运行的第一个模块叫做“主模块”——main module，也是自身模块。
        获取主模块对象：
            process.mainModule
            require.main
        除主模块之外的其他模块都称为子模块。
        默认情况下，某一个模块不能直接使用其他模块中封装的数据，但是每个
        模块可以导出（exports）自己内部的对象供其他模块使用，也可以引入
        （require）并使用其他模块导出的对象。

        每一个模块内部都可以使用一个变量：module，指向当前模块自己。
        //判断当前模块是否是主模块：
        console.log(require.main === module); 
        //引入其他模块
        var fs = require("fs"); //"fs"引入文件系统模块
        fs.readFile('10window.html', 'utf8', (error, data) => {
            if (error) throw error;
            console.log(data);
        })；
        在交互模式下，Node.js自带的模块不需要使用require引入，直接使用
        导出模块中的属性和方法供其他模块使用：exports
            exports.‘自定义名称’ = ‘模块方法或属性’。

        预定义的模块作用域成员：
        _dirname    //获取当前模块文件所在的目录
        _filename   //当前模块所在的目录及所在的文件名
        module      //指向当前模块的引用。
        module.exports  //指向当前模块中待导出的供其他模块使用的对象 
        exports     //指向module.exports对象的引用
        require     //引入其他模块，使用其他模块的module.exports对象

        //如果要导出构造函数 必须使用module.exports
        //如果要导出单个属性或方法，可以使用module.exports 和 exports

        1.自定义模块：
            1.文件模块
                没有后缀的文件模块，被作为js文件加载
                .js后缀的文件模块，被作为js文件加载
                .json后缀的文件模块，被作为json字符串加载，会被自动解析为对象
                .node后缀的文件模块，被作为c/c++二进制加载。
            2.目录模块——目录模块引入时只需引入目录名即可
                文件放置规则：
                1.包含一个package.json文件的目录模块
                            "main":""  指向该模块的主文件
                    包含Index.js文件的目录模块
                    包含index.json文件的目录模块
                    包含index.node文件的目录模块
            放到node_modules目录下的模块，引入的时候直接写模块名
            称即可，不必指定路径。文件也可以不放在同一级，node.js会一直搜索
            到根目录。
            模块查找顺序：
            1.文件/目录模块的缓存
            2.原生模块的缓存
            3.原生模块
            4.文件/目录模块（尽量避免模块重名）

            包和npm
            包（package）是根据CommonJS规范，对模块进行的标准封装。
            包规范：
                包是一个目录
                目录中包含一个package.json包说明文件，存放于包顶级目录下。
                目录中包含js文件，如有inde.js，可以放到包顶级目录下。
                其他js文件，放到lib目录下。
                二进制文件放到bin目录下。
                文档应该放到doc目录下。
                单元测试文件放到test目录下
            CommonJS规范要求，包应该位于当前目录或者父目录下的node_modules
            文件夹下，require函数由近及远依次查找。

            NPM包管理器
            npm官网：www.npmjs.com
            npm是Node.js的包管理工具，用于下载，安装，升级，删除，或发布并
            维护包。
            Nodejs的安装文件中，已经集成了npm
            下载第三方包
            1.安装在当前项目目录下。
                npm install 包名
                会安装到指定目录的node_modules文件夹下
            2.安装到全局
                npm install 包名 -g
                会安装到npm目录下
                查看目标路径：npm root -g
                默认全局包位置 C:\Users\chen\AppData\Roaming\npm\node_modules
            列出其他已经安装的包：npm ls 包名  如果不加包名则列出所有包
            更新已经安装的包：npm update 包名
            卸载已经安装的包：npm uninstall 包名
            npm 查看全局安装过的包 npm list -g -depth 0
                    -g:全局的安装包  list：已安装的node包 

            生成包：
                使用npm init 命令，可以在当前目录下生成一个package.json文件
            发布包：
                1.在http://www.npmjs.com上注册用户
                2.使用npm adduser  命令 ，注册或登录已有账号。
                3.进入配置完成的包目录，使用npm publish 命令发布包。
                4.到npmjs.com上搜索一发布的包

        2.NodeJS核心模块
            1.console
                global.console  用于向stdout 和 stderr 输出日志信息
                console class   console模块中的Console构造函数，用于向任意
                指定的输出流（文件）中输入信息。
            2.Query String
                提供了处理URL中“查询字符串”部分的相关操作。
                parse()  //从查询字符串中解析出数据对象，参数为一个查询字符串
                stringify() //将一个数据对象反向解析为一个查询字符串格式参数
                为一个数据对象，可选参数2，指定键值对之间的分隔符（默认 &），
                可选参数3指定键和值之间的分隔符(默认 = )。

            3.URL模块
                提供了处理url中不同部分的相关操作
                url.parse(urlStr)   //解析出url的各个组成部分
                url.parse(urlStr, true) //第二个参数，可以把查询字符串部分解析为字符串
                parse（） 
                    Url {
                    protocol: 'http:',
                    slashes: true,
                    auth: 'tom:123',
                    host: 'chen.com:8080',
                    port: '8080',
                    hostname: 'chen.com',
                    hash: '#section',
                    search: '?pid=20',
                    query: 'pid=20',
                    pathname: '/news/index.html',
                    path: '/news/index.html?pid=20',
                    href: 'http://tom:123@chen.com:8080/news/index.html?pid=20#section' }

                format（）    //将对象反向格式化为url格式，参数为一个对象。
                resolve()   //根据基地址和相对地址解析出目标地址，参数1，
                基地址；参数2，相对地址。

            4.Path模块
                提供了对文件路径进行操作的相关方法。
                parse()     //解析一个路径，参数为路径字符串
                format()    //将路径对象格式化为路径字符串，参数为对象。
                join()      //用于连接路径，会正确的使用当前系统的路径分隔符。
                resolve()   //根据基础路径，解析出目标路径的绝对路径。
                relative()  //根据基础路径，获取目标路径与其的相对关系。

            5.DNS模块
                提供了域名和IP地址的双向解析功能。
                lookup()    //把一个域名解析成一个IP地址,从操作系统中插寻(缓存)
                resolve()   //把一个域名解析为一个DNS的记录解析数组，从DNS服务器中
                查询。
                reverse()   //把一个IP地址反向解析为一组域名。一般解析不成功。

            6.Util工具模块
                format()    //使用带占位符的方式格式化字符串
                inspect()   //返回一个对象的字符串表示。
                inherits()  //实现构造方法之间的继承。

            7.Buffer
                缓冲区，一块专用于存储数据的内存区域，与string类型向对应
                ，用于存储二进制数据。
                Buffer对象的实例，可以通过读取文件获得，也可以手动创建。
                Buffer是Global对象的成员，无需require引入。

            8.fs模块——文件系统模块
                fs模块提供了文件的读写，更名，删除，遍历目录等操作。
                fs模块中大多数方法都带有同步和异步两种
                所有的异步方法都有一个回调函数，此回调函数的第一个参数都是
                一个错误对象。
                异步方法中如果有错误的话，会静默失败，不会自己抛出error，
                通常情况下都需要手动处理。

                常用Class：
                    fs.Stats    //文件或目录的统计信息描述
                    fs.ReadStream   //stream.Readable 接口的实现对象。
                    fs.WriteStream  //streamWriteable接口的实现对象。
                    fs.FSWatcher    //可用于监视文件修改的文件监视器对象。
                常用的方法：  默认为异步   //都有一个同步方法 如 fs.statSync();
                    fs.stat()   //用于返回一个文件或目录的统计信息(fs.Stats对象)
                    fs.mkdir()  //创建目录
                    fs.rmdir()  //删除目录
                    fs.readdir()    //读取目录下的内容
                    fs.readFile()//读取文件内容
                    fs.writeFile()//向文件中写入内容 
                    fs.appendFile()//向文件末尾追加内容
                    fs.unlink() //删除文件
                    fs.rename() //重命名文件

                    fs.stat() & fs.statSync() //用于返回一个文件或目录的统计
                    信息对象（fs.Stats对象）
                        fs.Stats对象的方法：
                            stats.isFile()  //是否为文件
                            stats.isDirectory() //是否为目录
                    操作目录：
                        fs.mkdir() & fs.mkdirSync//创建目录
                        fs.rmdir() & fs.rmdirSync()//删除目录
                        fs.readdir() & fs.readdirSync//读取目录下的内容

                    操作文件：
                        fs.readFile() & fs.readFileSync//读取文件内容
                        fs.writeFile() & fs.writeFileSync//向文件中写入内容
                        当使用writeFile()方法向文件写入内容时，若文件不存在，会
                        自动创建指定文件，如果存在，会在文件末尾追加内容。
                        fs.appendFile() & fs.appendFileSync//向文件末尾追加内容
                        fs.unlink() & fs.unlinkSync()//删除文件
                        fs.rename() & fs.renameSync//重命名文件
            9.HTTP模块    
                用于构建使用HTTP协议的客户端应用或服务器端应用
                创建并发起请求消息，等待并解析响应消息——实现web客户端
                接收并解析请求消息，构建并发送响应消息——实现web服务器
                常用对象：
                    http.ClientRequest
                    http.Server
                    http.ServerResponse
                    http.IncomingMessage
                常用方法：
                    http.createServer   //创建服务
                    http.get()
                    http.request()

                1.http.request
                    http.request是一个HTTP客户端工具
                    用于向web服务器发起一个http请求，并获取响应数据
                    有两个主要方法：
                        http.get()
                        http.request()
                    该方法返回一个http.ClientRequest对象，用来描述请求信息，
                    回调函数的参数是一个http.IncomingMessage对象，此对象封装
                    着响应信息。
                    http.ClientRequest对象常用方法：
                        write(chunk):向服务器追加请求主体数据
                        end(chunk):提交请求消息主体结束
                        setTimeout():设置请求消息超时时间
                        abort():终止请求
                    http.ClientRequest对象常用事件：
                        response:接收到响应消息
                        abort:请求终止事件
                        error:请求发生错误
                    使用get()方法不需要手动调用end()方法，使用request()方法
                    时必须手动调用end()方法。

                2.http.server
                    http.server是一个基于事件的http服务器。
                    用于创建web服务器，接收客户端请求，返回相应消息。所有
                    的请求都被封装到独立的事件当中，我们只需对他的事件编写相应
                    的处理程序，就可以实现http服务器的所有功能。
                    方法；http.ceateServer()
                    用于创建web服务器应用，接收客户端请求，返回响应消息。
                    该方法的返回值是一个http.Server对象
                    http.Server对象的常用方法：
                        listen() //用于启动服务器，监听指定的服务端口
                        colse() //停止服务器的运行
                        setTimeout()//设置服务器的响应消息超时时间
                    http.Server对象的常用事件：
                        conneciton:出现客户端连接时触发
                        request:接收到请求消息
                        close:服务器停止事件
                        error:响应发生错误时触发
                    http.Server对象的request事件回调函数中有两个参数。
                        第一个参数：是一个http.IncomingMessage对象，封装着客户
                        端提交的请求消息数据。
                        第二个参数：是一个http.ServerResponse对象，用于构建向客户端
                        输出的响应消息数据。
                        在每次修改服务器命令时总要重新启动一次服务器。 
                        http.IncomingMessage对象：
                                请求方法：req.method
                                请求URL: req.url
                                请求版本：req.httpVersion
                                请求头：req.headers
                        http.ServerResponse对象：
                                res.statusCode = 200;   //设置响应状态码
                                res.setHeader("Content-Type","text/html;charset=utf-8");   //设置响应消息头部
                                res.write('<html>');    //向客户端输出的响应主体内容
                                res.end();  //响应主体内容完毕，向客户端发送响应。
            10.MySql模块
                MEAN    （MySQL，express，Angular，nodejs）
                createConnection()  //创建一个MySQL服务器的连接该方法返回一个
                连接对象，该对象有以下常用方法：
                    connect()   //连接数据库
                    query()     //提交sql语句给MySQL服务器执行
                    end()       //断开与MySQL服务器的连接


            12.express模块
                可以方便的实现服务器的路由、发送和接收http请求，返回响应、发送和
                接收cookie以及实现模板引擎功能。
                connect();
                app.method(path,[middleware,]function(req,res){});  //path：路径