Node.js
1.命令行窗口
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<!--
1.命令行窗口(小黑屏、cmd窗口、终端、shell)
开始菜单==>运行==>cmd==>回车
常用的指令：
dir：列出当前目录下所有的文件
cd 目录名：进入指定的目录
md 目录名：创建一个文件夹
rd 目录名：删除一个文件夹
目录：
.表示当前目录
..表示上一级目录
环境变量(windows系统中的变量)
path
当我们在命令行窗口打开一个文件，或调用一个程序时
系统会首先在当前目录下寻找文件程序，如果找到了则直接打开
如果没有找到则会依次到环境变量path的路径中寻找，直到找到为止
如果没找到则报错
所以我们可以将一些经常需要访问的程序和文件的路径添加到path中
这样我们就可以在任意位置来访问这些文件和程序
-->
</body>
</html>
2.进程和线程
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<!--
进程
进程负责为程序的运行提供必备的环境
进程就相当于工厂中的车间
线程
线程是计算机中最新的计算单位，线程负责执行进程中的程序
线程就相当于工厂中的工人
单线程
JS是单线程
多线程
-->
</body>
</html>
3.Node简介
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<!--
Node.js是一个能够在服务器端运行JavaScript的开放源代码、跨平台的JavaScript运行环境
Node采用Google开发的V8引擎运行js代码，使用事件驱动、非阻塞和异步I/O模型等技术来提高性能，可优化应用程序的传输量和规模
Node的用途：
Web服务API，比如REST
实时多人游戏
后端的Web服务，例如跨域，服务器端的请求
基于Web的应用
多客户端的通信，如即时通信
-->
<!--
Node是对ES标准的一个实现，Node也是一个JS引擎
通过Node可以使js代码在服务器端执行
Node仅仅对ES标准进行了实现，所以在Node中不包含DOM和BOM
Node中可以使用所有的内建对象
String Number Boolean Math Date RegExp Function Object Array
而BOM和DOM都不能使用
但是可以使用console，也可以使用定时器
传统的服务器都是多线程的
每进来一个请求，就创建一个线程去处理请求
Node的服务器是单线程的
Node处理请求时是单线程，但是在后台拥有一个I/O线程池
I/O(Input/Output)
I/O操作指的是对磁盘的读写操作
-->
</body>
</html>
4.模块化
/*
模块化
在Node中，一个js文件就是一个模块
在Node中，每一个js文件中的js代码都是独立运行在一个函数中
而不是全局作用域，所以一个模块中的变量和函数在其他模块中无法访问
CommonJS规范
*/
console.log('我是一个模块');
/*
我们可以通过exports来向外部暴露变量和方法
只需要将需要暴露给外部的变量或方法设置为exports的属性即可
*/
// 向外部暴露属性或方法
exports.x = "我是02.module.js中的x";
exports.fn = function () {
}
// 引入其他模块
/*
在Node中，通过require()函数来引入外部的模块
require()可以传递一个文件的路径作为参数，node将自动根据该路径来引入外部模块
如果使用相对路径，必须以.或..开头
使用require引入模块以后，该函数会返回一个对象，这个对象代表的是引入的模块
我们使用require引用外部模块时，使用的就是模块标识，我们可以通过模块标识来找到指定的模块
模块分成两大类
核心模块
由Node引擎提供的模块
核心模块的标识就是模块的名字
文件模块
由用户自己创建的模块
文件模块的标识就是文件的路径(绝对路径，相对路径)
*/
var md = require("./02.module.js");
var math = require("./math.js")
var fs = require("fs")
// console.log(md.x);
console.log(math.add(123,456));
var a = 10;
/*
在Node中有一个全局对象global，它的作用和网页中window类似
在全局中创建的变量都会作为global的属性保存
在全局中创建的函数都会作为global的方法保存
当node在执行模块中的代码时，它会首先在代码的最顶部，添加如下代码
function (exports, require, module, __filename, __dirname) {
在代码的最底部，添加如下代码
}
实际上模块中的代码都是包装在一个函数中执行的，并且在函数执行时，同时传递进了5个实参
exports
该对象用来将变量或函数暴露到外部
require
函数：用来引入外部的模块
module
module代表的是当前模块本身
exports就是module的属性
既可以使用exports导出，也可以使用module.exports导出
__filename
当前模块的完整路径
__dirname
当前模块所在文件夹的完整路径
*/
// console.log(global.a);
/*
arguments.callee
这个属性保存的是当前执行的函数对象
*/
console.log(arguments.callee+"");
/* exports.name = 'a'
exports.age = 18
exports.sayName = function () {
console.log('我是a');
} */
/* module.exports = {
name:'b',
age:18,
sayName:function () {
console.log('我是b');
}
} */
/*
exports和module.exports
通过exports只能使用.的方式来向外暴露内部变量
而module.exports既可以通过.的形式，也可以直接赋值
*/
5.包
/*
包结构
包实际上就是一个压缩文件，解压以后还原为目录，符合规范的目录，应该包含如下文件
package.json 描述文件(必须)
bin 可执行二进制文件
lib js代码
doc 文档
test 单元测试
包描述文件用于表达非代码相关的信息，它是一个JSON格式的文件-package.json，位于包的根目录下，是包的重要组成部分。
package.json中的字段：
name,description,version,keywords,maintainers,dependencies,homepage......
*/
6.npm
/*
NPM(Node Package Manager)
CommonJS包规范是理论，NPM是其中的一种实践
对于Node而言，NPM帮助其完成了第三方模块的发布、安装和依赖等
借助NPM，Node与第三方模块之间形成了很好的一个生态系统
NPM命令
npm-v
查看npm的版本
npm version
查看所有模块的版本
npm
帮助说明
npm search 包名
搜索模块包
npm install/i 包名
在当前目录安装包
npm install 包名-g
全局模式安装包(全局安装的包一般都是一些工具)
npm install 包名 --save
安装包并添加到依赖中*****
npm install
下载当前项目所依赖的包
npm remove 包名
删除一个模块
npm install 文件路径
从本地暗转
npm install 包名 -registry=地址
从镜像源安装
npm config set registry 地址
设置镜像源
*/
/*
通过npm下载的包都放到node_modules文件夹中
我们通过npm下载的包，直接通过包名引入即可
node在使用模块名字来引入模块时，它会首先在当前目录的node_modules中寻找是否含有该模块
如果有则直接使用，如果没有则去上一级目录的node_modules中寻找
如果有则直接使用，如果没有则再去上一级目录中寻找，直到找到位置
直到找到磁盘的根目录，如果依然没有，则报错
*/
7.buffer
/*
Buffer(缓冲区)
Buffer的结构和数组很像，操作的方法也和数组类似
数组中不能存储二进制的文件，而buffer就是专门用来存储二进制的数据
使用buffer不需要引入模块，直接使用即可
在buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示
buffer中每一个元素的范围是从00 - ff 0 - 255
00000000 - 11111111
计算机 一个0 或一个1 我们成为1位(bit)
8bit - 1byte(字节)
buffer中的一个元素，占用内存的一个字节
Buffer的大小一旦确定，则不能修改，Buffer实际上是对底层内存的直接操作
*/
/*
Buffer.from(str) 将一个字符串转换为buffer
Buffer.alloc(size) 创建一个指定大小的buffer
Buffer.allocUnsafe(size) 创建一个指定大小的buffer，但是可能包含敏感数据
buf.toString() 将缓冲区的数据转换为字符串
*/
var str = "aaa";
// 将一个字符串保存到buffer中
var buf = Buffer.from(str);
console.log(buf);
// 创建一个指定大小的buffer
// buffer构造函数都是不推荐使用的
var buf2 = new Buffer.alloc(10);//10个字节的buffer
console.log(buf2.length);
// 通过索引，来操作buffer中的元素
buf2[0]=88;
buf2[1]=255;
buf2[2]=0xaa;
buf2[3]=255;
// 只要数字在控制套或页面中输出一定是10进制
console.log(buf2[2]);
for(var i = 0 ; i<buf2.length ; i++){
console.log(buf2[i]);
}
// Buffer.allocUnsafe(size) 创建一个指定大小的buffer，但是buffer中可能含有敏感数据
var buf3 = Buffer.allocUnsafe(10)
console.log(buf3);
8.fs
/*
文件系统(File System)
文件系统简单来说就是通过Node来操作系统中的文件
使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载
同步文件的写入
手动操作的步骤
1.打开文件
fs.openSync(path,flags[,mode])
path 要打开文件的路径
flags 打开文件要做的操作的类型
r 只读的
w 可写的
mode 设置文件的操作权限，一般不传
返回值：
该方法会返回一个文件的描述符作为结果，我们可以通过该描述符来对文件进行各种操作
2.向文件中写入内容
fs.writeSync(fd,string[,position[,encoding]])
fd 文件的描述符，需要传递要写入的文件的描述符
string 要写入的内容
position 写入的起始位置
encoding 写入的编码，默认utf-8
3.保存并关闭文件
fs.closeSync(fd)
fd 要关闭的文件的描述符
*/
var fs = require("fs");
// 打开文件
var fd = fs.openSync('hello.txt','w');
// 向文件中写入内容
fs.writeSync(fd,'今天天气真不错');
// 关闭文件
fs.closeSync(fd);
异步文件写入
/*
异步文件写入
fs.open(path,flags[,mode],callback)
用来打开一个文件
异步调用的方法，结果都是通过回调函数的参数返回的
回调函数两个参数
err 错误对象，如果没有错位则为null
fd 文件的描述符
fs.write(fd,string[,position[,encoding],callback)
用来异步写入一个文件
fs.close(fd,callback)
用来关闭文件
*/
// 引入fs模块
var fs = require('fs');
// 打开文件
fs.open('hello2.txt','w',function (err,fd) {
// 判断是否出错
if(!err){
// 如果没有出错，则对文件进行写入操作
fs.write(fd,"这是异步写入的内容",function (err) {
if(!err){
console.log("写入成功");
};
// 关闭文件
fs.close(fd,function (err) {
if(!err){
console.log("文件已关闭");
};
});
});
}else{
console.log(err);
};
});
简单文件写入
/*
简单文件写入
fs.writeFile(file,data[,options],callback)
fs.writeSync(file,data[,option])
file 要操作的文件的路径
data 要写入的数据
options 选项，可以对写入进行一些设置
callback 当写入完成后执行的函数
flag
r 只读
w 可写
a 追加
*/
// 引入fs模块
var fs = require('fs')
fs.writeFile('hello3.txt','这是通过writeFile写入的内容',{flag:'a'},function (err) {
if(!err){
console.log('写入成功');
}else{
console.log(err);
}
});
流式文件写入
/*
同步，异步，简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
*/
var fs = require('fs')
// 流式文件写入
// 创建一个可写流
/*
fs.createWriteStream(path[,options])
可以用来创建一个可写流
path文件路径
options 配置的参数
*/
var ws = fs.createWriteStream('hello3.txt')
// 可以通过监听流的open和close事件来监听流的打开和关闭
/*
on(事件字符串，回调函数)
可以为对象绑定一个事件
once(事件字符串，回调函数)
可以为对象绑定一个一次性的事件，该事件会在触发一次后自动失效
*/
ws.once('open',function () {
console.log('流打开了');
});
// 通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容")
ws.write("通过可写流写入文件的内容2")
// 关闭流
ws.end()
ws.once('close',function () {
console.log('流关闭了');
});
文件读取
/*
1.同步文件读取
2.异步文件读取
3.简单文件读取
fs.readFile(path[,options],callback)
fs.readFile(path[,options])
path 要读取的文件路径
options 读取的选项
callback 通过回调函数将读取到的内容返回
err 错误对象
data 读取到的数据，会返回一个buffer
4.流式文件读取
*/
var fs = require('fs')
fs.readFile('hello3.txt',function (err,data) {
if(!err){
// console.log(data.toString());
// 将data写入到文件中
fs.writeFile("hello.txt",data,function (err) {
if(!err){
console.log('文件写入成功');
}
})
};
});
流式文件读取
/*
流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
*/
var fs = require('fs')
// 创建一个可读流
var rs = fs.createReadStream("hello.txt");
// 创建一个可写流
var ws = fs.createWriteStream("a.txt");
// 监听流的开启和关闭
rs.once('open',function () {
console.log('可读流开启了');
})
rs.once('close',function () {
console.log('可读流关闭了');
// 数据读取完毕，关闭可写流
fs.end();
})
ws.once('open',function () {
console.log('可写流开启了');
})
ws.once('close',function () {
console.log('可写流关闭了');
})
// 如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，data事件绑定完毕，它会自动开始读取数据
rs.on('data',function (data) {
// console.log(data);
// 将读取到的数据写入到可写流中
ws.write(data);
})
/*
流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
*/
var fs = require('fs')
// 创建一个可读流
var rs = fs.createReadStream("hello.txt");
// 创建一个可写流
var ws = fs.createWriteStream("b.txt");
// pipe()可以将可读流中的内容，直接写入到可写流中
rs.pipe(ws);
fs其他方法
/*
fs.existsSync(path)
检查一个文件是否存在
fs.stat(path,callback)
fs.statSync(path)
获取文件的状态
它会给我们返回一个对象，这个对象中保存了当前对象状态的相关信息
fs.unlink(path,callback)
fs.unlinkSync(path)
删除文件
fs.readdir(path[,options],callback)
fs.readdirSync(path[,options])
读取一个目录的目录结构
files是一个字符串数组，每一个元素就是一个文件夹或文件的名字
fs.truncate(path,len,callback)
fs.truncateSync(path,len)
截断文件，将文件修改为指定的大小
fs.mkdir(path[,mode],callback)
fs.mkdirSync(path[,mode])
创建一个目录
fs.rmdir(path,callback)
fs.rmdirSync(path,)
删除一个目录
fs.rename(oldPath,newPath,callback)
fs.renameSync(oldPath,newPath)
对文件进行重命名
oldPath 旧的路径
newPath 新的路径
callback 回调函数
fs.watchFile(filename[,options],listener)
监视文件的修改
filename 要监视的文件的名字
options 配置选项
listener 回调函数，当文件发生变化时，回调函数会执行
在回调函数中会有两个参数：
curr 当前文件的状态
prev 修改前文件的状态
这两个对象都是state对象
*/
var fs = require('fs')
var isExists = fs.existsSync('hello.txt')
fs.stat('hello.txt',function (err,stat) {
/*
size 文件的大小
isFile() 是否是一个文件
isDirectory() 是否是一个文件夹/目录
*/
console.log(arguments);
})
fs.unlinkSync('hello.txt')
fs.readdir('.',function (err,files) {
if(!err){
console.log(files);
}
})
fs.truncateSync('hello.txt',10)
fs.watchFile('hello.txt',{interval:1000},function (curr,prev) {
console.log(prev.size);
console.log(curr.size);
})
751
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
