node常用命令
1.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的关系
//module.exports 和exports对象的对比
console.log(module.exports === exports); //true
exports = {
a :123
}//true
console.log(module.exports === exports); //true
//注意: exports不能直接导出对象, 因为会切断与module.exports对象的关系
参考文档: module.exports与exports,export与export default之间的关系和区别
4.require引入包的顺序
require('./one')
1.内置模块(node的)
2.文件模块(插件当前文件)
3.文件目录模块(没有对应的文件,就找对象的目录)
4.node_modules模块(先本地,后全局)
javascript.ruanyifeng.com/nodejs/modu…
2.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()写入数据,多个会连接成一个.
4.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('服务器启动了');
})
注意:每次修改服务器内容代码,就需要重启
5.nodemon热重载工具
nodemon 也是热部署工具
作用: 自动检测程序的变化,不需要你自己每次修改一点就重启服务器.
npm i nodemon -g
nodemon js文件
不需要重启服务器,直接刷新网页就可以了.
6.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('服务器启动了');
})
7.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() 将字符串 转换为对象
8.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('服务器运行了')
})
9.fs模块
后缀加Sync的是同步，不加是异步，同步方法的特点是阻塞代码，性能差，异步代码的特点是回调函数嵌套多，在使用fs应尽量使用异步方式编程来保证性能。
fs.stat/fs.statSync 检测是文件还是目录
fs.mkdir/fs.mkdirSync 创建目录
fs.writeFile/fs.writeFileSync 创建写入文件
fs.appendFile/fs.appendFileSync 追加文件
fs.readFile/fs.readFileSync 读取文件
fs.readdir/fs.readdirSync 读取目录
fs.rename/fs.renameSync 重命名
fs.rmdir/fs.rmdirSync 删除目录
fs.unlink/fs.unlinkSync 删除文件
fs.createReadStream/fs.createReadStreamSync 从文件流中读取数据
fs.createWriteStream/fs.createWriteStreamSync 写入文件流数据
管道流概念: 实现大文件传输(小文件一次性传输过去,大文件慢慢传)
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());
})
同步
const fs = require('fs')
const data = fs.readFileSync('E:\工作文件\学习文件\node\demo.text','utf-8')
console.log(data);
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.读取流
fs读取大文件占内存，效率低。流是将数据分割段，一段一段的读取，可以控制速率,效率很高,不会占用太大的内存。
1.创建读取流
let readStream = fs.createReadStream('mi.jpg');
2.open -打开文件
rs.on("open",()=>{
console.log("文件打开")
});
3.data -当有数据可读时触发。
rs.on('data',(data)=>{
console.log(data);
});
4.error -在读收和写入过程中发生错误时触发。
rs.on("err",()=>{
console.log("发生错误")
});
5.close -关闭文件
rs.on("close",()=>{ //最后文件关闭触发
console.log("关闭")
});
6.end - 没有更多的数据可读时触发
rs.on('end',()=>{ //文件读取完毕后触发
console.log("读取完毕");
});
//图片读取的很慢,文字读取的很快
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);
2.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);
3.全局对象模块
__filename 表示当前正在执行的脚本的文件名
__dirname 表示当前执行脚本所在的目录。
//单次和多次定时
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)
4.node中常见模块的总结
1.npm的常见命令使用
2.node的模块引入(4种,1个注意点)
3. node中的常用模块
http模块
url模块
fs文件模块
path 路径模块
global 全局模块
5.node中操作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();
})
})
总结
1.node安装
2.模块的导入导出
//a.js
module.exports = {//对象和方法}
//index.js
var m = require('./a.js');
console.log(m.name);
m.run();
3.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 //可以获得用户请求的网址路径
4.url模块
let urlObj=url.parse(请求路径,true); //将参数包装成对象
urlObj.query.username //获得用户名
urlObj.query.password //获得密码
5.热重载工具
nodemon
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.关闭连接
