node.js(1)

霞觀小刺 發表於 2019-11-1 15:30:00

<img src="https://img2018.cnblogs.com/blog/1734707/201911/1734707-20191101150556350-803040587.png">
 
 
node.js基于谷歌的v8引擎，将谷歌的v8引擎单独拿出来运行在服务器端
 <img src="https://img2018.cnblogs.com/blog/1734707/201911/1734707-20191101150958003-153631691.png">
 
<h3> 全局对象</h3>
<h3>Node.js   ---->     global</h3>
在一个文件中，声明的变量和函数都属于局部变量或局部函数，在交互模式下属于全局变量或全局函数；
例1：
<div class="cnblogs_code">
<pre>var a=1;
console.log(global.a);</pre>
</div>
例2：
<div class="cnblogs_code">
<pre>function fn(){
console.log(123);
}
var res=global.fn();
console.log(res);</pre>
</div>
<h3> JS:window</h3>
在浏览器下，文件中声明的变量或创建的函数都属于是全局作用域下的，可以使用全局对象访问；
xxx.html
<div class="cnblogs_code">
<pre><script src="xxx.js"></script></pre>
</div>
xxx.js
<div class="cnblogs_code">
<pre>var a=1;
function fn(){
console.log(123);
}
console.log(a);
fn()
console.log(window.a);
window.fn();</pre>
</div>
<h3> console对象</h3>
<div class="cnblogs_code">
<pre>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');</pre>
</div>
<h3>process对象 --->  查看当前计算机的进程</h3>
语法：process.arch                // 多少当前cpu架构
           process.platform         // 什么当前操作系统
           process.env                // 查看当前计算机的环境变量
           process.version          // 查看node.js的版本号
           process.pid                 // 进程编号
           process.kill(pid)          // 杀死进程
<h3>buffer对象 --->  缓冲区(在内存中存储数据的区域，存储网络传出时的资源)</h3>
<div class="cnblogs_code">
<pre>// 创建buffer,大小是5个字节
var buf=global.Buffer.alloc(5,'abcde');
console.log(buf);
// 将buffer数据转成普通字符
console.log(buf.toString());</pre>
</div>
<h3>全局函数</h3>
parseInt / parseFloat / encodeURI / decodeURI  / isNaN  /  isFinite  /eval
<div class="cnblogs_code">
<pre>console.log(global.parseInt(3.14)); // 3 </pre>
</div>
1) 一次性定时器
<div class="cnblogs_code">
<pre>// 定时器,参数1是执行的操作，参数2是间隔的时间(ms)，当间隔时间到了就执行回调函数
var timer = setTimeout(function(){
console.log('响铃');
},3000);

// 清除一次性定时器
clearTimeout(timer);</pre>
</div>
2）周期性定时器
<div class="cnblogs_code">
<pre>// 周期性定时器，每间隔3秒响一次
var timer = setInterval(function(){
console.log('响铃');
},3000);

// 清除
clearInterval(timer);</pre>
</div>
例1:
<div class="cnblogs_code">
<pre>// 使用周期性定时器每隔3秒打印hello,打印三次后清楚定时器
// 初始化1个变量用于记录执行次数
var i=0;
var timer = setInterval(function(){
i++;
console.log('hello');
// 当i为3的时候清除定时器
if(i==3){
 clearInterval(timer);
}
},3000);</pre>
</div>
3）立即执行的定时器
<div class="cnblogs_code">
<pre>// nextTick先执行，setImmediate后执行;
// 立即执行,放到一组事件的最后执行,没有清除方式；
process.nextTick(function(){
console.log('响铃');
});

// 在下一个循环的开头执行
setImmediate(function(){
console.log('响铃');
});</pre>
</div>
模块
1、模块：自定义模块、核心模块、第三方模块
2、任意一个文件都是一个模块
3、exports   require    module.exports   __diename     __dirname
4、导出：module.exports.fn=function(){ }
<div class="cnblogs_code">
<pre>/*
创建两个模块main.js(主模块)，circle.js(功能模块)；在功能模块中创
建两个函数，传递1个参数，分别获取圆的周长(getLength)和面积(getArea)，
导出这两个函数；在主模块中引入功能模块，调用两个方法；*/

//
function getLength(){
return 2*PI*r;
}

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

// 
// 引入功能模块circle.js，自定义模块格为js结尾，.js可以省略
var circle=require('./circle.js'); 
console.log(circle.getLength(2));
console.log(circle.getArea(2));</pre>
</div>
5、引入文件模块或目录模
<img src="https://img2018.cnblogs.com/i-beta/1734707/201911/1734707-20191107154107327-707879391.png">
 
 
 
 例1：
<div class="cnblogs_code">
<pre>/*创建模块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"}</pre>
</div>
例2：
<div class="cnblogs_code">
<pre>/*在05目录下创建模块05_1.js,引入不带路径的目录模块05_2,
05_2目录中含有hello.js文件(打印一句话)*/

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

// 
console.log('hello');

// 
{"main":"hello.js"}</pre>
</div>
 
包和npm
<h3> npm:node package manage</h3>
包：就是一个目录模块，里边包含多个文件，其中有一个文件命名为package,json文件，是包说明文件。
<h3> </h3>
<h3>核心模块--> nodejs官方提供的模块，可以直接引用，不需要创建</h3>
1) 查询字符串模块——quearystring
浏览器向服务器发送请求，传递数据的一种方式
parse()    将查询字符串解析为对象
stringify()    将对象转换为查询字符串
http://www.codeboy.com/product_details.html?lid=5&name=dell
例1：
<div class="cnblogs_code">
<pre>//
// 引入查询字符串模块
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);</pre>
</div>
 例2：
<div class="cnblogs_code">
<pre>/* 把百度搜索时的查询字符串解析为对象，获取关键词
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);</pre>
</div>
2）url模块
parse()     将url解析为对象
protocol    协议    hostname   主机     port    端口     pathname   文件在服务器上路径    query    查询字符串
例1:
<div class="cnblogs_code">
<pre>// 引入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);</pre>
</div>
format()      将对象转化为一个url
例1：
<div class="cnblogs_code">
<pre>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);</pre>
</div>
例2：
<div class="cnblogs_code">
<pre>// 浏览器请求的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);</pre>
</div>
3）文件系统模块——fs
fs.stat(path,callback)/fs.statSync(path)      查看文件的状态，通过回调函数来获取结果。
path     要查看的文件路径
callback     回调函数
    err       如果查看失败的错误信息
    stats    文件状态信息
　　isDirectory()   是否为目录
       isFile()    是否为文件
 
对比同步和异步的区别？
　　同步会组织后续代码的主席那个，只有方法执行完才能继续执行后边的代码；是通过返回值来获取结果；
　　异步不会阻止后续代码的执行，把执行的结果放到整个程序的最后执行；通过回调函数来获取结果；
 
例1：
<div class="cnblogs_code">
<pre>// 引入fs模块
const fs = require('fs');
// 查看文件状态
fs.stat('C:/Users/ecarx/Desktop/ffwdx200.jtl',(err,stats)=>{
// err 如果有错误信息，会存储再err中
// stats 文件的具体状态信息
 console.log(stats);
console.log(err);
});</pre>
</div>
例2： 有错误时抛出错误（异步）
<div class="cnblogs_code">
<pre>// 引入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); // 不会组组织后续代码执行</pre>
</div>
例3：使用同步
<div class="cnblogs_code">
<pre>// 使用同步statSync
var res = fs.statSync('C:/Users/ecarx/Desktop/ffwdx200.jtl')
console.log(res.isDirectory());
console.log(res.isFail()); console.log(123); // 同步方法，会阻止后续代码执行</pre>
</div>
创建目录：
fs.mkdir(path,callback)/fs.mkdirSync(path)    
path  要创建的目录的路径
callback  回调函数，只有一个参数
      err     如果创建失败的错误信息
 
<div class="cnblogs_code">
<pre>// 创建目录——异步方法

// 引入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);</pre>
</div>
删除目录：
fs.rmdir(path,callback)/fs.rmdirSync(path)
path     要删除的目录的路径
callback     回调函数，获取函数的结果
　　err    如果删除失败的错误信息
<div class="cnblogs_code">
<pre>// 删除目录
const fs = require('fs');
// 异步
fs.rmdir('mydir',(err)=>{
if(err) throw err;
console.log('删除成功'); 
}); </pre>
<pre>console.log(123); </pre>
<pre>// 同步 const fs = require('fs'); var res = fs.rmdirSync('mydir'); console.log(res); console.log(123);</pre>
</div>
读取目录
fs.readdir(path,callback)/fs.readdirSync(path)
path     要读取的目录的路径
callback     回调函数，获取函数的结果
　　files    读取的文件，返回数组
　　err    如果读取失败的错误信息
<div class="cnblogs_code">
<pre>// 读取目录(异步)
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);</pre>
</div>
例子：组合
<div class="cnblogs_code">
<pre>// 练习：创建目录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('删除成功');
});</pre>
</div>
创建文件
fs.writeFile(path,data,callback)    写入文件/创建文件
data   要写入的数据
如果文件不存在则创建文件，然后写入，若已存在，则清空内容写入；
 
<div class="cnblogs_code">
<pre>// 创建文件,每次写入会先清空后写入

// 引入fs模块(异步)
const fs = require('fs');
fs.writeFile('data.txt','hello',(err)=>{
if(err) throw err;
});</pre>
</div>
 
例1：
<div class="cnblogs_code">
<pre>/* 练习：创建目录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);</pre>
</div>
读取文件（返回的数据是buffer形式）
fs.readFile(path,callback)/fs.readFileSync(path)
追加写入（若文件不存在则创建文件，若文件已存在，则在末尾写入数据）
fs.appendFile(path,data,callback)
fs.appendFileSync(path,data)
 例2：
<div class="cnblogs_code">
<pre>/* 创建文件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);
fs.appendFileSync('user.txt',user+' ');

}
// 每次写完数据加换行
fs.appendFileSync('user.txt','\n');</pre>
</div>
 
  
来源：https://www.cnblogs.com/hd-test/p/11777295.html

頁: [1]

琼殿技术论坛's Archiver

node.js(1)