Node.js基础

Node.js

1、什么是？

              （nodejs.cn -中文nodejs.org-官网）

              是一个基于ChromeV8引擎的JavaScript运行环境，可以编写独立的服务器端程序，提供了更多符合CommonJS规范的对象

       （1）JS与Nodejs的区别：

              1、用途： JavaScript主要用于客户端，Nodejs用来实现服务器端应用程序

              2、包含对象：nodejs不包含JS当中的BOM/DOM对象

2、用处：

       IO密集型的服务器端的应用程序

3、特点：

     1、简单，避免过度的设计

     2、单线程逻辑处理    

             （1）关于进程和线程

                               -1.进程：操作系统系统分配资源的基本单位

                               -2.线程：CPU调度和分配的基本单位

                               每个进程都有自己独立的系统资源，而线程几乎没有

                               关系：进程中可以包括多个线程，线程必须依赖于进程的存在

                               每个进程至少有一个线程，称为主线程

      3、非阻塞的异步I/O处理

      4、事件驱动编程

      5、无锁机制，不会产生死锁

      6、支持数万个并发连接

4、如何？

  （1）.下载对应的程序，安装好，建议使用LTS，常年使用

     运行中打开cmd输出node -v，可以查看版本

5、与webstorm整合

  （1）.配置nodejs     

    -1.点击file->settings->Languages& frameworks -> Node.js and NPM->Coding Assistance - >Enable -> OK

6、基本概念

              1、基础语法：

                     数据类型：

                            1、基本原始类型

                            2、引用类型：ES原生对象，nodeJS对象，自定义对象

              2、模板字符串

                     同ES6新特性

              3、变量和常量

                     声明变量： let  var  全局       声明常量：const

        4、运算符：

                     同JS，=>（箭头函数）

        5、逻辑结构

              1、顺序结构

              2、选择结构

                     if else...

              3、循环结构

                     for for..in（取下标） for..of（取值）等

       6、函数和对象

              函数：为了实现某种功能可以重复使用的特定功能

                     1、命名函数：命名了的函数对象

                     2、匿名函数：未命名的函数对象

                     3、自调函数

                     4、箭头函数

                     5、闭包：同ES6

 对象：

 分类：

  1、ECMAScript预定义对象：String Boolean Number Date Array Math Error  RegExp Function Object                                 EvalError RangeErrorReferenceError SyntaxError TypeError URIError等，以及更多的ES6新对象

     2、Nodejs核心模块定义的对象：Buffer WriteStream Socket ChildProcess等

      

创建对象：

  前三种同JS

class方法：

      1、class：类，是一组相似对象的属性和行为的抽象集合

      2、instance：实例，是从属于某个类的一个具体对象

面向对象编程的三大基本特征：

  1、封装

    使用class关键字声明一个类

  2、继承

     class Programmer extends（继承） Emp{

      }

  3、多态

                                 

                                   class Programmer extends Emp{

                                        constructor(enamel,skills){

                                                super(ename);
                                                this.skills = skills;

                                                }
                                         work(){
                                            return super.work()    //重写父类 多态
                                         }
                                     }

   

全局对象：

                     在JS中，全局对象保存在window中

                     在nodejs中，不支持BOM和DOM对象，全局对象称为global

                     声明的全局变量和函数在交互模式下是global对象的成员-全局对象污染

                     在脚本模式下不是global对象的成员-避免全局对象污染         

脚本模式：

        在终端中输入node点击回车在命令行中做交互

交互模式：

        在终端中，通过node加载

global.console

    global.console对象类似于Chrome中的console对象，用于向stdout和stderr中输出信息

stdin stdout stderr

    stdin - 标准输入 - >键盘

    stdout - > 标准输出 - > 显卡（屏幕）

    stderr - > 标准错误输出 - >显卡（屏幕） - > 红色高亮

强调：

    console.log/warn（error别名）/error（错误）/assert（断言）

    console时global对象的方法，用来负责向stdout输出信息

    为真的断言，错误信息不会输出

    console.assery(data.count>0,'COUNT IS ZERO')

    当条件成立，不输出，条件不成立，输出

示例:

//console.assery 断言实例
console.assert(3<2,"测试失败");
console.log("测试完成");
//输出测试失败，输出错误，停止执行

function login(uname,upwd){
    if(uname == 'root') {
        if (upwd == '123456')
            return 200;
        else
            return 402;
    }else
        return 401;
}
var result = login("root","123456");
console.assert(result == 200,"参数测试root/123456测试失败");
result = login("tom","123465");
console.assert(result == 401,"参数测试tom/123456测试失败");
result = login("root","123");
console.assert(result == 402,"参数测试root/123测试失败");
console.log("测试成功");

global.process

    process:Object

        表示执行当前解释器运行所在的进程对象

        可以使用该对象获取当前操作系统以及运行时的信息，并操作脚本所在的执行进程

    相关成员：

        process.arch            获取CPU架构类型

        process.platfrom     获取操作系统类型

        process.env             获取操作系统环境变量

        process.pid              获取进程编号

        process.kill(pid)       向指定进程ID号发送退出信号

        process.hrtime         获取高精度的实时时间

        process.cwd()           获取当前所在目录

        process.execPath     获取解释器所在目录

        process.execArgv     获取解释器执行参数

        process.argv             获取解释器运行时的命令行参数

        process.versions       获取node.js版本信息

        process.uptime()       获取node.js解释器运行时间

        process.memoryUsage()   loo 获取内存信息  

实例应用：

console.log(process.arch);      //查看当前系统架构
console.log(process.platform);  //查看当前平台
var result = process.hrtime();  //获取当前系统时间 nm级别
setTimeout(function(){
    console.log(process.hrtime(result)); //放入参数-》算出当前时间与上次的时间差
},1000);
console.log(process.pid);   //获取进程id
var result = process.pid;   //获取当前nodejs运行进程的进程编号
process.kill(result);       //关闭当前进程编号的进程

另外两个属性：

    __filename    路径

    __dirname     盘符

实例：

/**
 * Created by web-01 on 2018/3/18.
 */
console.log(__filename);    //路径
console.log(__dirname);     //盘符

定时器

    定时器任务：在间隔指定的事件后执行的任务，由于Node.js时单线程处理模型，所有到期要执行的定时器任务统一进入一个

事件循环队列，由Node.js解释器依次调用执行。

    Node.js提供了四种形式的定时器：

         （1）process.nextTick()            本次事件循环结束时立即执行的定时器

         （2）global.setImmediate()     下次事件循环立即执行的定时器    （global.clearInterval）

         （3）global.setTimeout()          一次性定时器                              （global.clearTimeout）

         （4）global.setInterval()            周期性定时器                             （global.clearImmediate）

/**
 * Created by web-01 on 2018/3/18.
 */
//setInterval 创建周期形定时器
//setTimeout 创建延迟定时器
//setImmediate()
setTimeout(function(){
    console.log("1s延时后执行")
},1000);
setImmediate(function(){
    console.log("立即执行")
})
function count(){
    var count = 0;
    return function c(){
        count++;
        console.log(count);
    }
}
var dd = count();
var timer = setInterval(dd,1000);
console.log("脚本执行完成");

更多全局函数：

        decodeURI()                     把字符串编码为URI

        decodeURIComponent()  把字符串编码为URI组件

        encodeURI()                      

        encodeURIComponent()   

        unescape()                        对由escape()编码的字符串进行解码

        parseInt()

        parseFloat()

        isNaN                               检查是否为NaN

        isFinite()                           检查是否为有穷大的数字

        eval()                                计算指定字符串，将其作为语句来执行

更多的全局对象

        JSON            JSON.parse()个JSON.stringify()

        Math

        Array

        Boolean

        Date

        Error

        Function

        Number

        Object

        String

        Buffer                构建内存缓冲区对象

模块系统

    什么是？

        ·文件即模块，Node.js使用模块(Module)来规划不同的功能对象。

        ·Node.js中每一个文件或者文件夹都是一个独立的模块对象

    用处？（封装，重用）

        一个文件/模块被第一次加载后，会在内存中保存对应的缓存对象;

        对一个模块多次重复引入，会使用该缓存对象，从而避免了重复加

        载导致创建多个完全相同的模块对象。

    本质？

         NodeJS中模块的本质是一个构造方法内的执行体

         每个文件在导入的时候都是一个构造函数          

        原理（对模块化的理解）：

(function(exports,require,module,__filename,__dirname){

    module.exports = {};

    exports = module.exports

    return moudle.exprots;

    //开发人员编写的代码将会自动的添加到该位置
    //__filename 这是一个完整的文件名
    //__dirname  完整的路径名
    //require    是一个方法，用于创建指定模块的对象，或者是返回一个已经存在的对象
    //module     指的是当前的模块对象
    //module.exports    当前模块对外导出的对象
 })  

         在一个JS文件中读取另外一个JS

         借助于：exports    require

        

         require("完整的文件名");

    

        eg:

    require("./7_other.js");

         通过模块完成导出和引入

         实例

         8_1.js:文件的引入

    console.log("8_1.js 被执行");
    var result = require("./8_2.js");
    console.log(result.stuAge);
    console.log(result.stuTest());

        8_2.js:文件的导出     

    console.log("8_2 被执行");
    var age = 30;
    function test(){
    return "这是一个test";
    }
    module.exports.stuAge = age;
    module.exports.stuTest = test;

当引入多次时，不会反复请求。

    练习：

//创建矩形模块，创建两个变量(width/height),两个方法getSize面积和getPerimeter周长
var width;
var height;
function getSize(width,height){
    var size = width * height;
    return console.log("矩形的面积为"+size);
}
function getPerimeter(width,height){
    var perimeter = width*2+height*2;
    return console.log("矩形周长为"+perimeter);
}
module.exports.rectSize = getSize;
module.exports.rectPerimeter = getPerimeter;

//圆形模块，创建一个变量r，两个方法getSize面积，getPerimeter周长
var r;
const PI = 3.14;
function getSize(r){
    return console.log("圆的面积为"+PI*r*r);
}
function getPerimeter(r){
    return console.log("圆的周长为"+2*PI*r);
}
module.exports.circleSize = getSize;
module.exports.circlePerimeter = getPerimeter;

//引入rect.js和circle.js同时实现将矩形和圆形的面积，周长的输出
var rect = require("./rect.js");
var circle = require("./circle.js");
rect.rectSize(200,300);
rect.rectPerimeter(200,300);
circle.circlePerimeter(2);
circle.circleSize(2);

    当一个文件夹中的文件模块名为index.js时，可以requre(./文件夹)直接调用

    强调：

           各种模块引入的规则：

            两大类：

            1、引入文件

                    1、路径开头            eg:require("./test/index.js")

                    2、不需要写路径      require("http") 前提：引入官方预定义好的模块

            2、引入目录

                    1、路径开头            require(",.test02.js")      情况一：index.js，情况二：package.json    当一个文件夹下同时又

                                                                                                index.js和package.json的时候，以package.json所指定的为准

                    2、不需要路径开头  require("test05")           前提：test05文件夹必须在node_modules目录下

未完待续。。。