node.js

Posted 2020-12-01 Alieen617

 

 

node.js基于谷歌的v8引擎，将谷歌的v8引擎单独拿出来 运行在服务器端

 

 

 全局对象

Node.js   ---->     global

在一个文件中，声明的变量和函数都属于局部变量或局部函数，在交互模式下属于全局变量或全局函数；

例1：

var a=1;
console.log(global.a);

例2：

function fn(){
    console.log(123);
}
var res=global.fn();
console.log(res);

 JS:window

在浏览器下，文件中声明的变量或创建的函数都属于是全局作用域下的，可以使用全局对象访问；

xxx.html

<script src="xxx.js"></script>

xxx.js

var a=1;
function fn(){
    console.log(123);
}
console.log(a);
fn()
console.log(window.a);
window.fn();

 console对象

global.console.log(123);      // 打印消息
// 返回值：123
global.console.info(123);     // 打印消息
global.console.warn(123);     // 打印警告消息，感叹号
global.console.error(123);    // 打印错误消息，叉号

// 开始计时
global.console.time(\'for-loop\');
for(var i=0;i<10;i++){

}
// 计时结束
global.console.timeEnd(\'for-loop\');

process对象 --->  查看当前计算机的进程

语法：process.arch                // 多少当前cpu架构

           process.platform         // 什么当前操作系统

           process.env                // 查看当前计算机的环境变量

           process.version          // 查看node.js的版本号

           process.pid                 // 进程编号

           process.kill(pid)          // 杀死进程

buffer对象 --->  缓冲区(在内存中存储数据的区域，存储网络传出时的资源)

// 创建buffer,大小是5个字节
var buf=global.Buffer.alloc(5,\'abcde\');
console.log(buf);
// 将buffer数据转成普通字符
console.log(buf.toString());

全局函数

parseInt / parseFloat / encodeURI / decodeURI  / isNaN  /  isFinite  /eval

console.log(global.parseInt(3.14));     // 3 

1) 一次性定时器

// 定时器,参数1是执行的操作，参数2是间隔的时间(ms)，当间隔时间到了就执行回调函数
var timer = setTimeout(function(){
    console.log(\'响铃\');
},3000);

// 清除一次性定时器
clearTimeout(timer);

2）周期性定时器

// 周期性定时器，每间隔3秒响一次
var timer = setInterval(function(){
    console.log(\'响铃\');
},3000);

// 清除
clearInterval(timer);

例1:

// 使用周期性定时器每隔3秒打印hello,打印三次后清楚定时器
// 初始化1个变量用于记录执行次数
var i=0;
var timer = setInterval(function(){
    i++;
    console.log(\'hello\');
    // 当i为3的时候清除定时器
    if(i==3){
        clearInterval(timer);
    }
},3000);

3）立即执行的定时器

// nextTick先执行，setImmediate后执行;
// 立即执行,放到一组事件的最后执行,没有清除方式；
process.nextTick(function(){
    console.log(\'响铃\');
});


// 在下一个循环的开头执行
setImmediate(function(){
    console.log(\'响铃\');
});

模块

1、模块：自定义模块、核心模块、第三方模块

2、任意一个文件都是一个模块

3、exports   require    module.exports   __diename     __dirname

4、导出：module.exports.fn=function(){ }

/*
创建两个模块main.js(主模块)，circle.js(功能模块)；在功能模块中创
建两个函数，传递1个参数，分别获取圆的周长(getLength)和面积(getArea)，
导出这两个函数；在主模块中引入功能模块，调用两个方法；*/


//[circle.js]
function getLength(){
    return 2*PI*r;
}

function getArea(){
    return PI*r*r;
}
// 导出
module.exports.getLength=getLength;
module.exports.getArea=getArea;



// [main.js]
// 引入功能模块circle.js，自定义模块格为js结尾，.js可以省略
var circle=require(\'./circle.js\');   
console.log(circle.getLength(2));
console.log(circle.getArea(2));

5、引入文件模块或目录模

 

 

 

 例1：

/*创建模块03_1.js，引入当前目录下的03_2目录模块；
在03_2下创建test.js，导出一个函数fn(打印两个数字
相加),在03_1.js中调用*/

//【03_1.js】
var test=require(\'/03_2/test.js\')
console.log(test.add(2,3));



//【test.js】
function add(a,b){
    return a+b;
}
module.exports.add=add;


// 【package.json】
{"main":"test.js"}

例2：

/*在05目录下创建模块05_1.js,引入不带路径的目录模块05_2,
05_2目录中含有hello.js文件(打印一句话)*/

// 【05目录下05_1.js模块】
require(\'05_2\');


// [node_modules目录下05_2目录，文件名hello.js]
console.log(\'hello\');

// [node_modules目录下05_2目录，创建package.json]
{"main":"hello.js"}

 

包和npm

 npm:node package manage

包：就是一个目录模块，里边包含多个文件，其中有一个文件命名为package,json文件，是包说明文件。

 

核心模块--> nodejs官方提供的模块，可以直接引用，不需要创建

1) 查询字符串模块——quearystring

浏览器向服务器发送请求，传递数据的一种方式

parse()    将查询字符串解析为对象

stringify()    将对象转换为查询字符串

http://www.codeboy.com/product_details.html?lid=5&name=dell

例1：

//[querystring.js]
// 引入查询字符串模块
const querystring=require(\'querystring\');   // 对象     用户引入核心模块
var str=\'lid=5&pname=dell\';
// 获取查询字符串传递的数据
// 将查询字符串解析为对象
var obj=querystring.parse(str);
console.log(obj.lid,obj.dell);

var obj2={
    name:\'tom\',
    age:18,
    sex:1
}
// 将对象转换为查询字符串
var str2=querystring.stringfy(obj2);
console.log(str2);

 例2：

/* 把百度搜索时的查询字符串解析为对象，获取关键词 
ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&wd=电脑& */
const querystring=require(\'querystring\');
var str=\'ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&wd=电脑&\';
var obj=querystring.parse(str);
console.log(obj.wd);

2）url模块

parse()     将url解析为对象

protocol    协议    hostname   主机     port    端口     pathname   文件在服务器上路径    query    查询字符串

例1:

// 引入url模块
const url = require(\'url\'); 
var str=\'http://www.codebody.com:80/list/details.html?lid=5&pname=dell\';
// 将url解析为对象
var obj = url.parse(str)
console.log(obj);

format()      将对象转化为一个url

例1：

var obj={
    protocol:\'http\',
    hostname:\'www.codebody.com\',
    port:8080,
    pathname:\'/course/100037.html\',
    query:{lid:5,pname:\'dell\'}
}
// 将对象转换为url
var str = url.format(obj);
console.log(str);

例2：

// 浏览器请求的url为https://www.tmooc.cn:3000/web/1810.html?sid=10&name=tom,获取url中传递的sid和name值

// 引入查询字符串模块
const querystring=require(\'querystring\'); 
// 引入url模块
const url = require(\'url\');
var str = \'https://www.tmooc.cn:3000/web/1810.html?sid=10&name=tom\';
var obj=parse(str);
// 获取查询字符串
var qs = obj.query;
// 解析查询字符串为对象
var res = querystring(qs);
console.log(res.sid,res.name);

3）文件系统模块——fs

fs.stat(path,callback)/fs.statSync(path)      查看文件的状态，通过回调函数来获取结果。

path     要查看的文件路径

callback     回调函数

    err       如果查看失败的错误信息

    stats    文件状态信息

　　isDirectory()   是否为目录

       isFile()    是否为文件

 

对比同步和异步的区别？

　　同步会组织后续代码的主席那个，只有方法执行完才能继续执行后边的代码；是通过返回值来获取结果；

　　异步不会阻止后续代码的执行，把执行的结果放到整个程序的最后执行；通过回调函数来获取结果；

 

例1：

// 引入fs模块
const fs = require(\'fs\');
// 查看文件状态
fs.stat(\'C:/Users/ecarx/Desktop/ffwdx200.jtl\',(err,stats)=>{
    // err   如果有错误信息，会存储再err中
    // stats   文件的具体状态信息
    console.log(stats);
    console.log(err);
});

例2： 有错误时抛出错误（异步）

// 引入fs模块
const fs = require(\'fs\');
// 查看文件状态
fs.stat(\'C:/Users/ecarx/Desktop/ffwdx200.jtl\',(err,stats)=>{
    // err   如果有错误信息，会存储再err中
    // stats   文件的具体状态信息
    // 如果有错误，抛出错误，阻止程序往后运行
    if(err) throw err;
    // 查看文件是目录形式还是文件形式
    // 查看是否为目录
    console.log(stats.isDirectory());  
    // 查看是否为文件按
    console.log(stats.ifFile());
});
console.log(123);    // 不会组组织后续代码执行

例3：使用同步

// 使用同步statSync
var res = fs.statSync(\'C:/Users/ecarx/Desktop/ffwdx200.jtl\')
console.log(res.isDirectory());
console.log(res.isFail());

console.log(123);      // 同步方法，会阻止后续代码执行

创建目录：

fs.mkdir(path,callback)/fs.mkdirSync(path)    

path  要创建的目录的路径

callback  回调函数，只有一个参数

      err     如果创建失败的错误信息

 

// 创建目录——异步方法

// 引入fs模块
const fs = require(\'fs\');
fs.mkdir(\'mydir\',(err)=>{
    if(err) throw err;
    console.log(\'目录创建成功\');
});
console.log(123);


// 创建目录——同步方法
// 引入fs模块
const fs = require(\'fs\');
var res = fs.mkdirSync(\'mydir\');
console.log(res);
console.log(123);

删除目录：

fs.rmdir(path,callback)/fs.rmdirSync(path)

path     要删除的目录的路径

callback     回调函数，获取函数的结果

　　err    如果删除失败的错误信息

// 删除目录
const fs = require(\'fs\');
// 异步
fs.rmdir(\'mydir\',(err)=>{
    if(err) throw err;
    console.log(\'删除成功\');   
});

console.log(123);

// 同步 
const fs = require(\'fs\'); 
var res = fs.rmdirSync(\'mydir\'); 
console.log(res); console.log(123);

读取目录

fs.readdir(path,callback)/fs.readdirSync(path)

path     要读取的目录的路径

callback     回调函数，获取函数的结果

　　files    读取的文件，返回数组

　　err    如果读取失败的错误信息

// 读取目录(异步)
const fs = require(\'fs\');
fs.readdir(\'05\',(err,files)=>{

    if(err) throw err;
    // files如果没有错误，读取的文件是一个数组
    console.log(files);
})
console.log(123);


// 读取目录(同步)
const fs = require(\'fs\');
var files = fs.readdirSync(\'05\');
console.log(files);
console.log(123);

例子：组合

// 练习：创建目录hello,读取03_2下的所有文件，删除目录hello

// 引入fs模块
const fs = require(\'fs\');
fs.mkdir(\'hello\',(err)=>{
    if(err) throw err;
    console.log(\'hello目录创建成功\')
});
fs.readdir(\'03_2\',(err,files)={
    if(err) throw err;
    console.log(files);
})
fs.rmdir(\'hello\',(err){
    if(err) throw err;
    console.log(\'删除成功\');
});

创建文件

fs.writeFile(path,data,callback)    写入文件/创建文件

data   要写入的数据

如果文件不存在则创建文件，然后写入，若已存在，则清空内容写入；

 

// 创建文件,每次写入会先清空后写入

// 引入fs模块(异步)
const fs = require(\'fs\');
fs.writeFile(\'data.txt\',\'hello\',(err)=>{
    if(err) throw err;
});

 

例1：

/* 练习：创建目录mydir,在该目录下创建文件1.txt,写入1，创建文件2.txt,写入2，
读取mydir下所有文件；删除mydir整个,过程全部使用同步方法。*/


// 引入fs模块
const fs = require(\'fs\');
var creat = fs.mkdirSync(\'mydir\');
console.log(creat);
var file1 = fs.writeFileSync(\'1.txt\',1);
console.log(file1);
var file2 = fs.writeFileSync(\'2.txt\',2);
console.log(file2);
var all = fs.readdirSync(\'mydir\');
console.log(all);
var rm = fs.rmdirSync(\'mydir\')
console.log(rm);

读取文件（返回的数据是buffer形式）

fs.readFile(path,callback)/fs.readFileSync(path)

追加写入（若文件不存在则创建文件，若文件已存在，则在末尾写入数据）

fs.appendFile(path,data,callback)

fs.appendFileSync(path,data)

 例2：

/* 创建文件user.txt,每次写入一个对象{uid:1,uname:\'tom\',upwd:\'123456\'}*/

// 引入fs模块(异步)
const fs = require(\'fs\');
var user = {uid:1,uname:\'tom\',upwd:\'123456\'};
// 遍历对象获取数据
for(var key in user){
    console.log(key+\'---\'+user[key]);
    fs.appendFileSync(\'user.txt\',user[key]+\' \');

}
// 每次写完数据加换行
fs.appendFileSync(\'user.txt\',\'\\n\');