nodejs汇总

一.node中的模块引入

1.模块的基本导入导出

//one.js
//导出模块方式1
module.exports = {
    a: 10,
    b: 20,
    c: function () {
        console.log("我是c函数");
    },
};

//index.js
//引入模块: 注意要带./因为是服务器运行了
var one = require("./one");
console.log(one);
console.log(one.a);
console.log(one.b);
one.c();
console.log("----------");

2.四种模块导出写法

//1.综合写法
module.exports = {
    a: 10,
    b: 20,
    c: function () {
        console.log("我是c函数");
    },
};

//2.单独写法
module.exports.a = 10;
module.exports.b = 20;
module.exports.c = function () {
    console.log("c函数");
};

// 3.拆分写法
var a = 10;
var b = 20;
var c = function () {
    console.log("我是c函数");
};
module.exports = {
    a,
    b,
    c,
};

//4.exports简写
exports.a = 10;
exports.b = 20;
exports.c = function () {
    console.log("c函数");
};

//注意: exports不能直接导出对象, 拿不到对象的值
(exports跟module.exports是指向同一个对象,
    //这种写法是错误的
    (exports = {
        a: 10,
        b: 20,
        c: function () {
            console.log("我是c函数");
        },
    }));

3.module.exports 和exports的关系

为了方便，Node为每个模块提供一个exports变量，指向module.exports。这等同在每个模块头部，有一行这样的命令。

var exports = module.exports;

其结果是，在对外输出模块接口时，我们可以直接在 exports 对象上添加方法， 如同在module.exports上添加一样。

注意：因为 Node 模块是通过 module.exports 导出的，如果直接将exports变量指向一个值，就切断了exports与module.exports的联系，导致意外发生。

var exports = module.exports;

//两个是相等的关系，但又不是绝对相当的关系
/*
例如：
1.module.exports可以直接导出一个匿名函数或者一个值
*/
module.exports = function () {
    var a = "Hello World";
    return a;
};
//但是exports是不可以的，因为这样等于切断了exports与module.exports的联系，exports不再指向module.exports了。

参考文档: module.exports与exports,export与export default之间的关系和区别

4.require引入包的顺序

require('./one')
1.内置模块(node的)
2.文件模块(插件当前文件)
3.文件目录模块(没有对应的文件,就找对象的目录)
4.node_modules模块(先本地,后全局)

更多参考：CommonJS规范

二.nodemon热重载工具

nodemon 也是热部署工具
作用: 自动检测程序的变化，不需要你自己每次修改一点就重启服务器
npm i nodemon -g
nodemon js文件

不需要重启服务器,直接刷新网页就可以了

三.http模块

注意: http模块是node自带的模块，不需要下载，直接引用就可以了
http模块是用来创建服务器的

http.createServer(function (req, res) {}); //http模块的createServer方法,会返回一个服务器对象
server.listen(端口); //服务器对象,调用listen方法来监听端口
res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" }); //响应头
res.write(); //返回数据内容,也必须使用res.end结束,不然一直请求
res.end(); //结束返回(可以包含res.write)----建议使用

req.url; //可以获得用户请求的网址路径
req.method; //获得用户请求的方法

node的http模块主要使用来创建服务器的.
1. 引入http模块
2. 创建服务器(req和res表示请求和响应对象)
3. 监听端口

//注意: 端口一般大于3000就可以,系统用了一部分,只要不冲突就行了

//1.引入模块
const http  = require('http');
//2.创建服务器,接收请求和响应
let server = http.createServer(function(req,res){
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" })
    // res.end('返回的内容')
    res.write('返回的内容')
    res.end();
})
//3.监听端口
server.listen(3000,function(){
    console.log('服务器已经开启');
});

//注意,修改服务器代码之后,一定要重启服务器,才能生效
//注意: req.url可以拿到用户请求的网址
//注意:res.end() 相当于: res.write()和res.end();
res.write()写入数据，多个会连接成一个

1.url模块

//url模块用来将请求地址,转换为对象
    url.parse(路径,参数是否为对象);  //默认为false字符串,一般设置为true对象

例如:http://127.0.0.1:3000/login?username=zhangsan&password=123456
//true表示返回一个对象,false表示还是一个字符串, 返回一个对象,其中query中放着参数
let urlObj=url.parse(请求路径,true);   //将参数包装成对象,第二个参数为ture,参数变为对象
urlObj.query.username  //获得用户名
urlObj.query.password  //获得密码


//参考代码
const http = require('http');
const url = require('url')
let server = http.createServer(function(req,res){
    //设置响应格式
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" })
    if(req.url == '/favicon.ico') return;
    //将url请求字符串,转换为对象
    console.log(req.url);
    //将网址转换为对象
    var urlObj = url.parse(req.url,true);
    console.log(urlObj.query.username)
    res.end('返回的数据');
})

server.listen(3000,function(){
    console.log('服务器启动了');
})

注意：每次修改服务器内容代码，就需要重启

2.node处理get请求

get 请求的参数在网址中: http://127.0.0.1:3000/login?username=zhangsan&password=123456

const http = require('http');
const url = require('url');
let server = http.createServer(function(req,res){
    res.writeHead(200, { "Content-Type": "text/html;charset=UTF-8" });
    if(req.url == '/favicon.ico') return;
    console.log(req.url);
    //将请求参数转换为对象
    let params = url.parse(req.url,true);
    //得到参数对象
    console.log(params.query);
    res.end('得到数据了'+req.url);
})

server.listen(3000,function(){
    console.log('服务器启动了');
})

3.node处理post请求

//post请求的数据,在请求体中,需要以文件块的方式进行接收

//获得请求数据,chunk就是一块块数据,然后拼接在一起
req.on("data", function (chunk) {});
//数据获取结束
req.on("end", function () {
    //获取数据结束后,使用res.end的打印
});

// 使用postman模拟发送post数据并且,写在body中
const http = require("http");

let server = http.createServer(function (req, res) {
    //判断是否是post请求
    if (req.method === "POST") {
        //定义变量存储数据
        let postData = "";
        //接收数据
        req.on("data", function (chunk) {
            //将二进制转换为字符串
            postData += chunk;
        });
        //接收数据完毕
        req.on("end", function () {
            //直接输出,不识别中文
            console.log(postData);
            res.end(postData);
        });
    }
});
server.listen(3000, function () {
    console.log("服务器运行了");
});

注意: 对象转换为字符串的方法: util.inspect() 或者 JSON.stringify()

querystring.parse() 将字符串转换为对象

4.node返回JSON数据

// 根据请求，返回JSON数据。写死一个对象，然后转为JSON字符串，返回就行了
JSON.stringify();

const http = require("http");
let server = http.createServer(function (req, res) {
    res.writeHead(200, { "Content-Type": "text/json;charset=UTF-8" });
    let user = {
        name: "张三",
        age: 19,
    };

    res.end(JSON.stringify(user));
});
server.listen(3000, function () {
    console.log("服务器运行了");
});

四.fs模块

fs.stat  检测是文件还是目录
fs.mkdir  创建目录
fs.writeFile  创建写入文件
fs.appendFile  追加文件
fs.readFile   读取文件
fs.readdir    读取目录
fs.rename    重命名
fs.rmdir     删除目录
fs.unlink    删除文件
fs.createReadStream  从文件流中读取数据
fs.createWriteStream 写入文件流数据
管道流概念: 实现大文件传输(小文件一次性传输过去,大文件慢慢传)

1.创建文件夹

const fs = require("fs");
//第一个参数,文件夹路径和名字, 第二个参数是权限默认就可以,不写,第三个参数是错误的回调
fs.mkdir("demo", function (err) {
    if (err) {
        console.log("文件夹创建失败");
        console.log(err);
        //创建文件失败后,就不继续打印创建成功了
        return false;
    }
    console.log("创建文件夹成功");
});

//注意: 如果demo/a 就可以创建两个文件夹 demo下有个a

2.检测文件和目录

const fs = require("fs");
//err错误信息, stats检测对象,然后可以调用
//isFile() 判断是否是文件,返回布尔类型
//isDirectory() 判断是文件夹,返回布尔类型
fs.stat("demo", function (err, stats) {
    if (err) {
        console.log("文件检测错误");
        console.log(err);
        return false;
    }
    console.log("文件:" + stats.isFile());
    console.log("文件夹:" + stats.isDirectory());
});

3.删除目录

const fs = require("fs");

fs.rmdir("demo", function (err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log("删除目录成功");
});

4.读取目录

//fs.readdir 读取目录:  会将目录下的文件和文件夹都获取到
let fs = require("fs");

//拿到一个文件夹下的所有目录: 包括文件夹和文件
fs.readdir("demo", function (err, data) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log(data);
});

5.创建文件

//创建文件,并写入内容
let fs = require("fs");

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数: 文件内容
//第三个参数: 文件编码格式
//第四个参数:错误的回调
fs.writeFile("a.txt", "用node创建的文件111", "utf-8", function (err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log("写入成功");
});

6.追加文件内容

let fs = require("fs");

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数: 文件内容
//第三个参数: 文件编码格式
//第四个参数:错误的回调
fs.appendFile("a.txt", "111这是追加的内容", function (err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log("追加成功");
});

7.读取文件

let fs = require("fs");

//第一个参数: 文件名字,没有这个文件创建,有文件覆盖
//第二个参数:错误的回调
fs.readFile("a.txt", function (err, data) {
    if (err) {
        console.log(err);
        return false;
    }
    //默认读取格式为16进制 Buffer
    console.log(data);
    console.log(data.toString());
});

8.删除文件

let fs = require("fs");

fs.unlink("a.1.txt", function (err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log("删除文件成功");
});

9.重命名

let fs = require("fs");

//修改文件的名字
// fs.rename('c.html', 'x.html', function(err) {

//     if (err) {
//         console.log(err);

//         return false;
//     }
//     console.log('修改名字成功');
// })

//也可以修改文件夹名字
// 还可以进行剪切,文件夹必须存在
fs.rename("demo/b/1.txt", "./1.txt", function (err) {
    if (err) {
        console.log(err);
        return false;
    }
    console.log("修改名字成功");
});

10.读取流

1.创建读取流
let readStream = fs.createReadStream('mi.jpg');
2.接收数据的回调 readStream.on('data',function(err){})
3.数据接收完毕的回调
4.错误信息的回调

//图片读取的很慢,文字读取的很快

const fs = require("fs");

//创建读取流,读取a.txt文件
let readStream = fs.createReadStream("mi.jpg");

//定义一个空字符串,用于拼接数据
let str = "";
//记录读取次数
let count = 0;

//开始读取数据
//data就是数据事件,chunk是每个数据的分片
//count表示读取多少次
readStream.on("data", function (chunk) {
    str += chunk;
    count++;
});

//读取完毕后
readStream.on("end", function (chunk) {
    console.log(count);
    // console.log(str);
});

//读取失败的处理
readStream.on("error", function (err) {
    console.log(err);
});

11.写入流

1.创建写入流,会创建某个文件
    let writeStream = fs.createWriteStream('str.txt');
2.写入文件,并结束
    writeStream.write(str,'utf-8');
    writeStream.end();
3.写入结束事件
    writeStream.on('finish',function(){
        console.log('写入完成');
    })

const fs = require("fs");

let str = "我是从数据库获取的数据";

//创建写入流
let writeStream = fs.createWriteStream("str.txt");

//循环写入100句这个内容
for (let i = 0; i < 100; i++) {
    writeStream.write(str, "utf-8");
}
//标记写入完成
writeStream.end();

//写入完成的事件
writeStream.on("finish", function () {
    console.log("写入完成");
});

//写入失败的事件
writeStream.on("error", function () {
    console.log("写入失败");
});

12.管道流

文件读取: 适合小文件,直接先将文件读入内存中,然后再存起来
管道流读取: 适合大文件进行拷贝,传输,将文件分片,慢慢传输.(读取流,写入流,管道流)

fs.createReadStream()  读取文件流
fs.createWriteStream() 写入文件流

http://www.zymseo.com/node/434.html

const fs = require("fs");

//创建一个读取流
let readStream = fs.createReadStream("snow.mp3");

//创建一个写入流
let writeStream = fs.createWriteStream("mysnow.mp3");

//管道读写操作,读取snow.mp3到新创建的mysnow.mp3,实现文件拷贝

readStream.pipe(writeStream);

五.path模块

path模块提供了一些方法,用来解决路径拼接的问题(可以简单理解为字符串拼接)

路径拼接: path.join(路径1,路径2)  拼接两个路径
路径获取:  path.resolve()   返回当前目录的绝对路径

获取路径：path.dirname(filepath)
获取文件名：path.basename(filename)
获取扩展名：path.extname(filepath)

//重点掌握: path.join() 和path.resovle()
//https://blog.csdn.net/NextStand/article/details/59535555

const path = require("path");

var str = path.join("demo", "test");
console.log(str);

//返回当前目录的全局路径
var a = path.resolve();
console.log("本地路径" + a);

//获得当前的文件夹名字
var b = path.dirname("demo/a.txt");
console.log(b);

//获取文件名
var c = path.basename("demo/a.txt");
console.log(c);

// 获取文件的后缀名
var d = path.extname("demo/a.txt");
console.log(d);

六.全局对象模块

__filename 表示当前正在执行的脚本的文件名
__dirname 表示当前执行脚本所在的目录。

//单次和多次定时
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)

七.node中常见模块的总结

1.npm的常见命令使用
2.node的模块引入(4种,1个注意点)
3. node中的常用模块
    http模块
    url模块
    fs文件模块
    path 路径模块
    global 全局模块
node是别人在js的基础上重新开发了一套api和解析器, 这样js代码就具备了上面的这些功能.但是用这些功能我们能做出东西,但是效率很低,所以有了其他的框架; 目前前端中的node开发框架有: express < koa < egg

八.node中操作mysql数据库

学mysql这种类型的第三方包,主要是看文档,能够正确的实现功能就可以了.不需要自己独立背下来.
1.下载mysql包,并引入
2. 创建连接 mysql.createConnection(数据库参数对象)---得到连接
3. 开始连接  conn.connect();
4.查询数据库 conn.query(sql语句,参数数组,回调函数)
5.结束连接  conn.end();

1.查询数据

const mysql = require("mysql");
//1.创建数据库连接
const conn = mysql.createConnection({
    host: "127.0.0.1",
    user: "root",
    password: "",
    database: "qd01",
    port: "3306",
});
// 2.开始连接
conn.connect();
// 3.查询语句
let sql = "select * from user";
conn.query(sql, function (err, rows) {
    if (err) throw err;
    console.log(rows);
});

//4.结束连接
conn.end();

//返回错误的两种写法,如果数据库错误,就会报错
if (err) {
    console.log(err);
    return false;
}
//简易写法
if (err) throw err;

2.添加数据

1.sql中使用?当占位符
2.conn.query(sql语句,参数数组,function(err,result){})
3.affectedRows受影响行数

const mysql = require("mysql");
//1.创建数据库连接
const conn = mysql.createConnection({
    host: "127.0.0.1",
    user: "root",
    password: "",
    database: "qd01",
    port: "3306",
});
// 2.开始连接
conn.connect();
// 3.查询语句
let sql = "insert into user(name,age,sex,tel) values(?,?,?,?)";
let params = ["任正非", 29, 1, "111111"];
conn.query(sql, params, function (err, result) {
    if (err) throw err;
    console.log(result);
    if (result.affectedRows > 0) {
        console.log("插入成功");
    } else {
        console.log("插入失败");
    }
});
//4.结束连接
conn.end();

3.删除数据

//删除,如果只有一个参数,就直接写,不用当数组
let sql = "delete from user where id=?";
let params = 13;
conn.query(sql, params, function (err, result) {
    if (err) throw err;
    console.log(result);
    if (result.affectedRows > 0) {
        console.log("删除成功");
    } else {
        console.log("删除失败");
    }
});

4.修改数据

//修改
let sql = "update user set name =? where id=?";
let params = ["曹操111", 12];
conn.query(sql, params, function (err, result) {
    if (err) throw err;
    console.log(result);
    if (result.affectedRows > 0) {
        console.log("修改成功");
    } else {
        console.log("修改失败");
    }
});

5.数据库连接池

1.创建连接池对象mysql.createPool(配置)
2.从连接池中获得数据库连接对象  pool.getConnection()
3.查询数据库 conn.query(sql语句,参数,回调)
4.释放连接 conn.release();

query(sql语句,参数,回调函数)
参数的写法: 一个值,直接写
        多个值用数组[参数1,参数2]
        如果插入的数据有多个,可以用对象,但是insert语句的写法就要修改
        insert into users set ?
        后面就可以写对象

const mysql = require("mysql");

const dbconfig = {
    host: "127.0.0.1",
    user: "root",
    password: "",
    database: "qd01",
    port: "3306",
};

//1.创建数据库连接池对象
const pool = mysql.createPool(dbconfig);

let sql = "select * from user";
//获得连接对象
pool.getConnection(function (err, conn) {
    //查询数据
    conn.query(sql, function (err, rows) {
        console.log(rows);
        //释放连接
        conn.release();
    });
});

6.数据库返回到页面

const http = require("http");
const mysql = require("mysql");

//创建服务器
let server = http.createServer(function (req, res) {
    res.end(JSON.stringify(userDate));
});

server.listen(3000, function () {
    console.log("服务器启动了");
});

let userDate = "空数据";
//数据库相关的操作
const dbconfig = {
    host: "127.0.0.1",
    user: "root",
    password: "",
    database: "qd01",
    port: "3306",
};

//1.创建数据库连接池对象
const pool = mysql.createPool(dbconfig);
let sql = "select * from user";
//获得连接对象
pool.getConnection(function (err, conn) {
    //查询数据
    conn.query(sql, function (err, rows) {
        userDate = rows;
        console.log(rows);
        //释放连接
        conn.release();
    });
});

九.Node多进程

我们都知道 Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。

每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。

Node 提供了 child_process 模块来创建子进程，方法有：

• exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。
• spawn - child_process.spawn 使用指定的命令行参数创建新进程。
• fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork(‘./son.js’) 相当于 spawn(‘node’, [‘./son.js’]) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

1.exec() 方法

child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。

语法如下所示：

child_process.exec(command[, options], callback)

参数

参数说明如下：

command： 字符串， 将要运行的命令，参数使用空格隔开

options ：对象，可以是：

• cwd ，字符串，子进程的当前工作目录
• env，对象 环境变量键值对
• encoding ，字符串，字符编码（默认： ‘utf8’）
• shell ，字符串，将要执行命令的 Shell（默认: 在 UNIX 中为/bin/sh， 在 Windows 中为cmd.exe， Shell 应当能识别 -c开关在 UNIX 中，或 /s /c 在 Windows 中。 在Windows 中，命令行解析应当能兼容cmd.exe）
• timeout，数字，超时时间（默认： 0）
• maxBuffer，数字， 在 stdout 或 stderr 中允许存在的最大缓冲（二进制），如果超出那么子进程将会被杀死 （默认: 200*1024）
• killSignal ，字符串，结束信号（默认：’SIGTERM’）
• uid，数字，设置用户进程的 ID
• gid，数字，设置进程组的 ID

callback ：回调函数，包含三个参数error, stdout 和 stderr。

exec() 方法返回最大的缓冲区，并等待进程结束，一次性返回缓冲区的内容。

空格路径处理

当 command 中包含空格的文件路径时，需要手动添加双引号或转义空格，否则会导致命令解析错误：

// 错误示例：包含空格的路径未加引号
child_process.exec(
    "type C:\\Users\\Administrator\\Desktop\\test folder\\file.txt",
    (error, stdout, stderr) => {
        // 会报错：系统找不到指定的文件
    }
);

// 正确示例：为包含空格的路径添加双引号
child_process.exec(
    'type "C:\\Users\\Administrator\\Desktop\\test folder\\file.txt"',
    (error, stdout, stderr) => {
        // 正确执行
    }
);

// 使用变量的情况
const filePath = "C:\\Users\\Administrator\\Desktop\\test folder\\file.txt";

// 错误示例：使用变量但未加引号
child_process.exec(`type ${filePath}`, (error, stdout, stderr) => {
    // 会报错：系统找不到指定的文件
});

// 正确示例：使用变量并添加双引号
child_process.exec(`type "${filePath}"`, (error, stdout, stderr) => {
    // 正确执行
});

// 推荐：优先使用 spawn 方法处理包含空格的路径
// spawn 方法会自动处理空格，无需手动转义
const { spawn } = require("child_process");
const spawnProcess = spawn("type", ["C:\\Users\\Administrator\\Desktop\\test folder\\file.txt"], {
    shell: true, // Windows 下需要 shell: true
});

// spawn 使用变量的情况（推荐）
const spawnProcessWithVar = spawn("type", [filePath], {
    shell: true, // Windows 下需要 shell: true
});

//support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。");

//master.js 文件代码：
const fs = require("fs");
const child_process = require("child_process");

for (var i = 0; i < 3; i++) {
    var workerProcess = child_process.exec(
        "node support.js " + i,
        function (error, stdout, stderr) {
            if (error) {
                console.log(error.stack);
                console.log("Error code: " + error.code);
                console.log("Signal received: " + error.signal);
            }
            console.log("stdout: " + stdout);
            console.log("stderr: " + stderr);
        }
    );

    workerProcess.on("exit", function (code) {
        console.log("子进程已退出，退出码 " + code);
    });
}

执行以上代码，输出结果为：

$ node master.js
子进程已退出，退出码 0
stdout: 进程 1 执行。

stderr:
子进程已退出，退出码 0
stdout: 进程 0 执行。

stderr:
子进程已退出，退出码 0
stdout: 进程 2 执行。

stderr:

2.spawn() 方法

child_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：

child_process.spawn(command[, args][, options])

参数

参数说明如下：

command： 将要运行的命令

args： Array 字符串参数数组

options Object

• cwd String 子进程的当前工作目录
• env Object 环境变量键值对
• stdio Array|String 子进程的 stdio 配置
• detached Boolean 这个子进程将会变成进程组的领导
• uid Number 设置用户进程的 ID
• gid Number 设置进程组的 ID

spawn() 方法返回流 (stdout & stderr)，在进程返回大量数据时使用。进程一旦开始执行时 spawn() 就开始接收响应。

// support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。");

// master.js 文件代码：
const fs = require("fs");
const child_process = require("child_process");

for (var i = 0; i < 3; i++) {
    var workerProcess = child_process.spawn("node", ["support.js", i]);

    workerProcess.stdout.on("data", function (data) {
        console.log("stdout: " + data);
    });

    workerProcess.stderr.on("data", function (data) {
        console.log("stderr: " + data);
    });

    workerProcess.on("close", function (code) {
        console.log("子进程已退出，退出码 " + code);
    });
}

执行以上代码，输出结果为：

$ node master.js stdout: 进程 0 执行。

子进程已退出，退出码 0
stdout: 进程 1 执行。

子进程已退出，退出码 0
stdout: 进程 2 执行。

子进程已退出，退出码 0

spawn详细实例使用查看：child_process.spawn 的详细使用

3.fork 方法

child_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：

child_process.fork(modulePath[, args][, options])

参数

参数说明如下：

modulePath： String，将要在子进程中运行的模块

args： Array 字符串参数数组

options：Object

• cwd String 子进程的当前工作目录
• env Object 环境变量键值对
• execPath String 创建子进程的可执行文件
• execArgv Array 子进程的可执行文件的字符串参数数组（默认： process.execArgv）
• silent Boolean 如果为true，子进程的stdin，stdout和stderr将会被关联至父进程，否则，它们将会从父进程中继承。（默认为：false）
• uid Number 设置用户进程的 ID
• gid Number 设置进程组的 ID

返回的对象除了拥有ChildProcess实例的所有方法，还有一个内建的通信信道。

// support.js 文件代码：
console.log("进程 " + process.argv[2] + " 执行。");

// master.js 文件代码：
const fs = require("fs");
const child_process = require("child_process");

for (var i = 0; i < 3; i++) {
    var worker_process = child_process.fork("support.js", [i]);

    worker_process.on("close", function (code) {
        console.log("子进程已退出，退出码 " + code);
    });
}

执行以上代码，输出结果为：

$ node master.js
进程 0 执行。
子进程已退出，退出码 0
进程 1 执行。
子进程已退出，退出码 0
进程 2 执行。
子进程已退出，退出码 0

十.node的知识总结

1.npm的常见命令
    npm i  包名 -g      全局安装
    npm i 包名 -S       项目依赖
    npm i 包名 -D       开发依赖

2.模块的导入导出
//a.js
module.exports = {//对象和方法}

//index.js
var m = require('./a.js');
console.log(m.name);
m.run();

3.热重载工具
    nodemon

4.http模块
    http.createServer(function(req,res){})  //http模块的createServer方法,会返回一个服务器对象
    server.listen(端口);    //服务器对象,调用listen方法来监听端口
    res.writeHead(200,{"Content-Type":"text/html;charset=UTF-8"}); //响应头
    res.write();  //返回数据内容
    res.end();   //结束返回(可以包含res.write)----建议使用

    req.url     //可以获得用户请求的网址路径

5.url模块
    let urlObj=url.parse(请求路径,true);   //将参数包装成对象
    urlObj.query.username  //获得用户名
    urlObj.query.password  //获得密码

6.fs模块
    fs.stat  检测是文件还是目录
    fs.mkdir  创建目录
    fs.writeFile  创建写入文件
    fs.appendFile  追加文件
    fs.readFile   读取文件
    fs.readdir    读取目录
    fs.rename    重命名
    fs.rmdir     删除目录
    fs.unlink    删除文件
    fs.createReadStream  从文件流中读取数据
    fs.createWriteStream 写入文件流数据
    管道流概念: 实现大文件传输(小文件一次性传输过去,大文件慢慢传)

7.path模块
    路径拼接: path.join(路径1,路径2)  拼接两个路径
    路径获取:  path.resolve()   返回当前目录的绝对路径
    获取路径：path.dirname(filepath)
    获取文件名：path.basename(filename)
    获取扩展名：path.extname(filepath)
8.全局模块
    __filename 表示当前正在执行的脚本的文件名
    __dirname 表示当前执行脚本所在的目录。

9.node操作数据库
    1.创建连接
    2.开始连接
    3.查询数据库
    4.关闭连接