node.js 总结

node.js总结

模块的引入

const module = require("模块名称")

fs模块

• 文件的异步读取

//fs.readFile('地址',回调函数)

 fs.readFile("./html/index.html","utf-8",(err,data)=>{
   console.log("err",err)    //如果文件读取成功，err就是null
    console.log("data",data)  //data就是读取后的文件内容
 })
 

• 文件同步读取

//fs.readFileSync 

let data = fs.readFileSync("./html/index.html")
console.log("data",data)  
console.log("我要成功了！")

• try - catch - finally

try{
    let data = fs.readFileSync("./html/indexa.html")
    console.log("data",data)  
}catch(e){  //e代表事件对象
    //处理错误 
    console.log("e",e)
}
console.log("我要成功了")

• 给文件改名

fs.rename('改前','改后',err=>{})
fs.renameSync("改前","改后")
fs.renameSync("./html/index.html","./html/about.html")

• 删除文件

fs.unlickSync("文件路径")

• 删除目录

 fs.rmdir("./html",err=>{
    console.log("html目录以及被删除了哦....")    
 })

http模块

const = require("http")
const http = http.createServer((req,res)=>{
	//req 相当于请求报文 
	//res 相当于响应报文
	//后端需要设置响应头 后端设置的权重高
	res.writeHead(200,{"Content-Type":"text/html;charset=utf-8"})
	res.write("hello world")
	res.end() //后端需要结束响应 必须写
	
})

app.listen(8000,()=>{
	console.log("server in running...")
})

url模块

//let obj = url.parse(str) 返回值是个对象 数据如下

protocol: 'http:',	协议
slashes: true,	双斜杠
auth: null,   作者
host: 'localhost:8002',  主机
port: '8002',	端口
hostname: 'localhost',  baidu
hash: '#title',	哈希（锚)	search: '?username=sdfsdf&content=234234',	查询字符串
query: 'username=sdfsdf&content=234234',	数据
pathname: '/aaa',	文件路径
path: '/aaa?username=sdfsdf&content=234234',	文件路径
href: 'http://localhost:8002/aaa?username=sdfsdf&content=234234#title'

• 第一种用法

let str = "http://www.baidu.com:80/app/html/index.html?a=1&b=2#title" 
let obj = url.parse(str)
let josn = {}
let query = obj.query
let queryArr = query.split
query.forEach(v =>{
	let vArr = v.split("=")
	json[vArr[0]] = vArr[1]
})
console.log(json)

• 第二种用法

let str = "http://www.baidu.com:80/app/html/index.html?a=1&b=2#title" 
let obj = url.parse(str,true) //可以直接将字符串转换为对象 
url.format(obj) //可以将对象转换为url字符串

querystring模块

let querystring = require("querystring")

//处理查询字符串，地址栏的形式传参    
let str = "a=1&b=2&c=3"
querystring.parse(str) //直接将字符串转换为对象

资源托管 处理接口

//引入响应的原生模块
const http = require("http")
const fs = require("fs")
const url = require("url")
const querystring = require("querystring")

//实例化http对象 
const app = http.createServer((req, res) => {
    //排除 /favicon.ico的请求
    if (req.url.indexOf("/favicon.ico") === -1) {
        //判断读取的是动态资源 还是静态资源 
        if (req.url.indexOf("/api") !== -1) {//处理接口
            //处理地址栏的数据
            let urlObj = url.parse(req.url, true)
            console.log(urlObj.query)


            //处理非地址栏的数据
            let noAddressDate = ""
            req.on("data", chunk => {
                noAddressDate += chunk
                //chunk代表抓取的一片数据 data事件内部会频繁触发
            })
            req.on("end", () => {
                      console.log(querystring.prase(noAddressDate))
            })

        } else {//处理静态资源
            try {
   let path = req.url === "/" ? "/index.html" : req.url
   let html = fs.readFileSync("./www" + path)
   res.write(html)
            } catch (error) {
   let html = fs.readFileSync("./www/nopage.html")
     res.write(html)
            }
        }
    }
    res.end()
})
//监听端口
app.listen(3000)

模块化 commonJS

commnJs 是一个我规范 主要为了js在后端的表现而制定

注意 ：commonJS是nodejs默认模块管理方式 不支持es6的模块化管理方式 但是支持所有es6+语法

node.js 的模块主要分为三种 ：
内置模块 node本身自带的模块
第三方模块 别人封装好的模块 需要用 (npm install -g 模块名)下载到项目中
自定义模块 自己封装的模块

• 自定义模块

exports.自定义属性 = 值
批量输出 都是属性 可输出多次

// a.js 文件内容
let aa = 100;
let bb = 200;
exports.aa = aa;
exports.bb = bb;

//b.js文件内容 
let b = require("./a.js");
console.log(b) //结果如下
{ aa: 100, bb: 200 }

module.exports = 值
只输出一次

//a.js文件内容
let a = 10
let b = "bmw"
let fn = ()=>{
    console.log("函数")
}
class Person{
    constructor(){
        console.log("这是Person的构造函数")
    }
    show(){
        console.log("这是show方法...")
    }
}

module.exports = {
    a,b,fn,Person2:Person
}

//b.js文件内容
let a1 = require("./mod/b")
console.log(a1)//结果如下
{ a: 10, b: 'bmw', fn: [Function: fn], Person2: [Function: Person] }

npm

npm 包管理工具 node下载自带
作用 ：安装及管理包

• 安装到全局环境

安装   npm i 包名 -g 
写在  npm uninstall -g 
g : global 全局的意思

• 安装到项目环境
• 初始化项目环境

方法1
npm init  
需要 自己配置一些参数 
方法2 
npm init -y 
参数自动生成  但是目录名必须是英文 

初始化完成会生成两个文件
package.json 管理包的文件
package-lock.json 文件用来固化依赖

{
  "name": "npm",	//项目名称
  "version": "0.0.1",	//版本
  "description": "test and play",	//描述
  "main": "index.js", //入口文件
  "dependencies": {  //项目依赖  上线也要用
    "jquery": "^3.2.1"
  },
  "devDependencies": { //开发依赖 上线就不用
    "animate.css": "^3.5.2"
  },
  "scripts": {	//命令行
    "test": "命令行",
  },
  "repository": {	//仓库信息
    "type": "git",
    "url": "git+https://github.com/alexwa9.github.io/2017-8-28.git"
  },
  "keywords": [  //关键词
    "test",'xx','oo'
  ],
  "author": "wan9",
  "license": "ISC",	//认证
  "bugs": {
    "url": "https://github.com/alexwa9.github.io/2017-8-28/issues"//问题提交
  },
  "homepage": "https://github.com/alexwa9.github.io/2017-8-28#readme"//首页
}

• 下载项目依赖包
  只能在当前项目使用 上线了也需要依赖 --save

//安装
npm i 包名 --save 
npm install 包名 -S 
npm install 包名@x.x.x -S

//卸载
npm uninstall 包名  --save
npm uninstall 包名  -S

• 下载开发依赖包

在写项目的时候使用 项目上线就不需要了 --save-dev

npm install 包名 --save-dev
npm install 包名 -D

• 查看包

npm list 列出所有已安装包 
npm outdated 版本对比(安装过的包)
npm info 包名  查看当前包的概要信息 
npm view 包名 versions 查看包历史版本列表

• 安装所有依赖包

npm install   //安装package.json里面指定的所有包  

• 版本约束

^x.x.x   约束主版本，后续找最新
~x.x.x   保持前两位不变，后续找最新
*		 装最新
x.x.x 	 定死了一个版本

选择源

安装选择镜像源的工具包 npm install nrm -g
查看所有源 nrm ls
测试所有源 nrm test
切换源 nrm use 源名

• 安装卡顿的解决方法

ctrl + c -> npm uninstall 包名  ->  npm cache verify 清除缓存 -> 换4g网络 -> npm install 包名 

发布包

• 在npm官网注册一个账户
  

• 登录

  在命令行输入 npm login 登录
  然后一次输入 user/password/email

• 创建包

  npm init -y

  创建入口文件 index.js

  编写输出
  举例如下 ：

//sum.js文件
const sum = (a,b) => {
    return a + b
}

module.exports = sum;

//index.js 文件
const sum = require("./sum")
module.exports = {
    sum
}

//package.json文件
{
  "name": "gengwentuo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "nodemon index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

• 发布

npm publish
注意：要检查package.json文件name的值 在npm官网是否存在

• 迭代

意思就是 你上传的包修改后
在发布时 要把package.json文件里面的版本号更改一下

• 删除

npm unpublish

包的发布 迭代 删除 需要在包目录下进行
删除包 有时需要发送邮件

bower

• 全局安装bower
  

bower i 包名 -g （安装）
bower uninstall 包名 -g （卸载）

• 初始化项目环境

bower init
生成 bower.json 第三方包管理配置文件

• 下载项目依赖

//安装
bower install 包名#x.x.x -S （指定版本使用#）
//卸载
bower uninstall 包名

• 下载开发依赖

bower install 包名 -D

yarn

• 建议去官网下载 yarn

• 初始化项目

yarn init

• 下载包

yarn add 包名
yarn add 包名@x.x.x -S //下载项目依赖包
yarn add 包名@x.x.x -D  // 下载开发依赖包

• 删除包

yarn remove 包名

• 安装项目的全部包

yarn  或者  yarn install 

• 使用yarn安装全局

yarn gloabal add 包名
yarn gloabal remove 包名

express

• 二次封装 非侵入式 增强型

• 搭建web服务器

let express = require("express")
let server = require()
server.listen(端口,地址,回调)

• 静态资源托管

server.use(express.static("./www"))

• 接口响应

server.get(url,(req,res,next)=>{})
server.post(url,(req,res,next)=>{})

• req 请求体

req.query //获取地址栏数据 
req.body //获取非地址栏数据 
req.params //如果是动态接口时 监听动态的那个目录名
req.method //获取前端的提交方式

• res 响应体

res.send() //返回给前端任意格式的数据 
res.json() //只能返回给前端json格式的数据 
res.status(404).send({error:1}) //当请求出错时返回给前端信息
res.sendFile(path.resolve("pubilc/error.html"))//渲染纯HTML文件 依赖path第三方模块 

​ 测试代码如下：

const express = require("express")

//引入中间件  body-parser (作用：增加一些功能)
const bodyParser = require("body-parser")

const path = require("path")

//创建服务器 
const app = express();

//监听端口 

app.listen(3000,"localhost",()=>{
    console.log("3000正在监听")
})

//通过app.use()  使用body-parser中间件 (作用:增加一些功能)
app.use(bodyParser())

app.get("/api/goods",(req,res)=>{
    // console.log(req.body) //依赖中间件body-parser  获取非地址栏的数据
    // console.log(req.query) //req.query 接收前端传递过来的数据 获取的是地址栏的数据
    // res.send("hello world")  //返回给前端数据 任意格式
    // res.json({a:1,b:2}) //只能返回给前端json格式的数据
    //res.status(404).send({error:1}) //请求出错 返回给前端信息 
    // res.sendFile(path.resolve('public/index.html'))//渲染纯 HTML 文件
})



//监听动态接口 :id 表示动态的目录名 
// app.get("/api/goods/:id",req=>{
//     console.log("详情...",req.params.id) //用         req.params.id 可以获取动态的接口名 
//     console.log(req.method) //req.method 可以本次请求的方式 
// })

• jsonp 响应

server.set('jsonp callback name','cb')  //设置函数名 默认时callback
server.get('/jsonp接口',(req,res) => res.jsonp)

代码如下

app.get("/api/home",(req,res)=>{
    console.log("jsonp来的数据",req.query) //获取前端传递来的参数
    res.jsonp({err:0,data:{a:1,b:2}}) //返回一个结果，调用客户端传递来的callback=jsonp_XXXXX方法调用执行，传递参数给他
})

//具体响应流程
前端发送请求(ajax jsonp) -> 后端接收请求(根据前端传递来的数据 向数据库获取数据 然后用res.jsonp返回给前端数据 -> 前端接收数据)  

• 处理一部分接口

共有业务逻辑 在一起给处理了
server.all(“admin/*”,(req,res,next)=>{})
all 不管时get 还是post 都可以响应
若下面还有接口响应 需要next 延续

next() 管道函数

代码如下

app.get("/api/*",(req,res,next)=>{
    console.log("a,b的所有的公共的业务逻辑...")
    next()  //使得后续得以运行
})

app.get("/api/a/*",(req,res,next)=>{
    console.log("/api/a的数据请求....")
    next()
})
app.get("/api/a/aa",(req,res)=>{
    console.log("/api/a/aa的数据请求....")
})

• use

默认use不写地址就是截获了根路径   app.use("/",callback)
app.use((req,res,next)=>{
    console.log("进入app.use了哦...")
    next() //向下延续
})

app.use("/api/*",(req,res,next)=>{  //类似 all   
    console.log("进入app.use了哦...")
    next() //向下延续
})

• next 管道函数

app.use((req,res,next)=>{
    req.query = "abcdefg"
    next()
})

app.get("/api/home",(req,res,next)=>{
   //可以获取上面设置的req.query 
    console.log("进入了/api/home....",req.query)
})

• 中间件 （如body-parser）

中间件 需要依赖use来使用
app.use(bodyParser())

**举例 **

npm i body-parser -S //安装包
let bodyParser=require('body-parser')//引入中间件
server.use(bodyParser())//安装中间件

• 后端跳转

res.redirect(url)

let abc;
app.get("/api/old",(req,res,next)=>{
   //res.redirect(地址)
   abc = req.query
   res.redirect("http://localhost:3000/api/new") //后端跳转
})

app.get("/api/new",(req,res,next)=>{
    console.log("进来了哦.....",abc)
    res.end()
}) */

• 封装body-parser中间件

//bdparser.js  文件 (封装)
const querystring = require("querystring");

module.exports = {
    urlencoded:(options) => {
        options = options || {}
        options.limit = options.limit || 102400
        return (req,res,next) => {
            let str = " "
            req.on("data",chunk => str+=chunk)
            req.on("end",()=>{
                if(str.length>options.limit){
                    throw new Error()
                }else{
                req.body = querystring.parse(str)
                    next()
                }

            })
        }
    }
}



//body-parser.js文件  (引用上面的封装)

const express = require("express");

const bodyParser = require("./middleware/bdParser.js")

const app = express();

app.listen(3000)

// app.use(bodyParser())
app.use(bodyParser.urlencoded({
    limit:102400  //设置获取前端数据的长度
}))

app.post("/api/old",(req,res,next) => {
    console.log(req.body)
    res.end()
})

cookie-session

• 思想

1、客户端用户名跟密码请求登录
2、服务端收到请求，去库验证用户名与密码
3、验证成功后，服务端种一个cookie或发一个字符到客户端，同时服务器保留一份session
4、客户端收到 响应 以后可以把收到的字符存到cookie
5、客户端每次向服务端请求资源的cookie会自动携带
6、服务端收到请求，然后去验证cookie和session，如果验证成功，就向客户端返回请求的库数据

• 安装引入cookie-session

let cookieSession = require("cookie-session")

• 配置中间件

app.use(cookieSession({
	name:"保存到服务器的session的名字",
	keys:[必选参数，代表加密层级],
	maxAge:1000 //保留cookie的时间
}))

• 设置客户端cookie 及 备份服务端session

req.session.key = value

• 读cookie对比session

req.session.key  返回true

具体操作代码如下

const express = require("express")

const cookieSession = require("cookie-session")

const app = express();

//静态资源托管
app.use(express.static("./public"))


app.listen(3000,()=>{
    console.log("正在监听3000端口")
})


//配置中间件
app.use(cookieSession({
    name:"myCookie",
    keys:['aa','bb','cc'],
    // maxAge:1000*300
}))


//验用户身份 
app.get("/api/login",(req,res)=>{
    //1.验证客户端传递来的用户名和密码和数据库中密码是否一致 
    //2.给客户端设置cookie 并且同时r服务端备份session
    req.session.username ="geng"
    //后端设置完cookie后 就可以返回给前端数据了 
    res.send({
        err:0,
        msg:"登录成功"
    })
})

//验证用户身份 
app.get("/api/user",(req,res)=>{
    const pass = req.session.username; //返回布尔值 若为true说明用户在登录状态
    if(pass){
        res.send({
            err:0,
            data:"ok"
        })
    }else{
        res.send({
            err:1,
            data:"用户未登录"
        })
    }
    res.end()
})

//注销登录 
app.get("/api/logout",(req,res)=>{
    //删除服务端session 和客户端的cookie
    req.session.username = undefined
    res.end()
})

token

思想

在服务端不需要存储用户的登录记录，全部发给客户端有客户端自己存(cookie,local)

1、客户端使用用户名跟密码请求登录
2、服务端收到请求，去验证用户名与密码
3、验证成功后，服务端会签发一个 Token（加了密的字符串），再把这个 Token 发送给客户端
4、客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里
5、客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
6、服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据

具体实现代码如下

let express = require("express")
let app = express()
let bodyParser = require("body-parser")

//引入jsonwebtoken模块
let jwt = require("jsonwebtoken")

app.listen(3000,()=>console.log("3000端口正在监听中..."))

app.use(bodyParser())

//请求登录，服务端生成token令牌
app.get("/api/login",(req,res)=>{
    //1.获取username,password 进行数据库的验证
    //2.生成token令牌
    let token = jwt.sign({
        username:req.query.username
    },"nz1906",{
        expiresIn:60 //过期时间，按照秒算
    })
    // console.log(token)
    //3. 将token和库信息返回给前端
    res.send({
        err:0,
        msg:"用户登录成功了..",
        data:"库数据",
        token
    })
})

//校验token
app.get("/api/user",(req,res)=>{
    //1.获取客户端传递来的token
    let token = req.query.token || req.body.token || req.headers.token;
    //2.校验token 
    jwt.verify(token,"nz1906",(err,decode)=>{
        // console.log("err",err) //null就代表没有报错
        console.log("decode",decode) 
        if(err){ //一旦报错了，说明用户信息校验失败
            res.send({ 
                err:1,
                msg:"当前登录失败，token失效了！"
            })
        }else{ //校验成功
            //3.数据返回给前端
            res.send({
                err:0,
                msg:"成功！",
                data:"库数据"
            })
        }
    })
})

token的删除是由客户端 负责删除

文件上传

• path内置模块

API

• 磁盘路径解析

path.parse("c:\\wamp\\xx.png") string -> object
返回结果如下：
{
root:"c:\\",盘符
dir:"c:\\wamp", 目录
base:"xx.png", 文件名
ext:".png",  扩展名
name:"xx" 文件。不含扩展名
}

• 片段合并(join)

path.join('磁盘路径1',"磁盘路径2","磁盘路径3")

__dirname 魔术变量 返回当前文件所在的磁盘路径

• 片段合并resolve

path.resolve("磁盘路径1","磁盘路径n")

合并磁盘片段,从右到左找到根目录,从左到右拼接,若没有找到根目录，就以当前文件所在目录为根目录

• multer中间件

multer接受form-data编码数据 所有要求前端携带时注意一下 如：

let multer = require("multer")

let objMulter = multer({dest:'./upload'})//指定保存到服务端的位置
//安装中间件
app.use(objMulter.any())//允许上传什么类型文件 any代表任何类型

//中间件扩展了req请求体req.files
app.get("/api/reg",(req,res)=>{
	req.files ///返回一个对象 数据如下
})

fieldname: 表单name名
originalname: 上传的文件名
encoding： 编码方式
mimetype: 文件类型
buffer: 文件本身
size：尺寸
destination: 保存路径
filename： 保存后的文件名 不含后缀
path： 保存磁盘路径+保存后的文件名 不含后缀

具体代码操作如下

const express = require("express")

const fs = require("fs")

const path = require("path")

const multer = require("multer")

const app = express()

app.listen(3000,()=>{
    console.log("正在监听3000端口")
})
//静态资源托管 客户端可以通过地址直接访问文件
app.use(express.static("./public"))

//实例化 nulter
 let objMulter = multer({
     dest:'./public/upload'
 })

//使用中间件 来增添req.files的功能 

//  app.use(objMulter.image())//表示只能上传 图片
 app.use(objMulter.any()) //表示能上传任意类型的文件

 app.get("/api/reg",(req,res) => {
     console.log(req.files)
     console.log(req.files[0].path)//图片上传后在服务端的位置 及名字 
    //上传到服务端的文件没有后缀名 不能正常使用 
    //通过下面操作给文件添加后缀名
     let  oldFile = req.files[0].path 
     //利用path获取文件的后缀名 然后进行拼接 
     let newFile = req.files[0].path + path.parse(req.files[0].originalname).ext
     fs.renameSync(oldFile,newFile) //更改文件名字
     res.send({ //图片地址返回给客户端
         err:0,
         url:"http://localhost:3000/upload/"+req.files[0].filename + path.parse(req.files[0].originalname).ext
     })

 })

后端渲染

通常前端根据后端返回的json数据,然后来生成html被称为前端渲染 而后端渲染是把后端json和html结合渲染好后返回到浏览器 没前端什么事情

下面介绍两种后端渲染页面的方法

• jade

1.要新建一个jade文件 在里面编写 html
2.新建一个js文件 在文件中引入jade第三方模块
3.再用jade.renderFile(“jad的文件地址”) 引入jade文件
4.然后返回给浏览器
具体操作代码如下 e

//index.jade  (在views/jade文件夹下)
html
    head
    body
        div
            ul
                li
                    a(href="http://baidu.com")百度
        div 
            h1 #{data}

//jade.js  (与vives文件夹同级)
const express = require("express")

const jade = require("jade")

const app = express() 

app.listen(3000,()=>{
    console.log("3000端口正在监听")
})

app.get("/",(req,res)=>{
    // jade.renderFileFile("jade文件地址",[数据])
    let html = jade.renderFile("./views/jade/index.jade",{
        pretty:true,data:"你好"
    })
    res.send(html)
})

• ejs

const ejs = require("ejs")
ejs.renderFile("ejs模板文件",{数据},(err,data)=>{})
//err 错误 返回null 代表没有错误 
//data 渲染后的字符\流
//ejs模板 表示后缀名为ejs的html文件 

• ejs模板文件语法

ejs 结构就是html
输出: <%= 数据名|属性名|变量名 + 表达式 %>
语句： <% 语句 %> 需要被<% %> 包裹
非转义输出: <%- 数据名|变量名 + 表达式 %>
载入公共：<%- include(’./hd.ejs’,{数据}) %>

路由

由于在一个文件中写多个接口比较繁琐 由此诞生了路由
对于后端来说 路由可以理解为是一个子服务器
一个路由就是一个小的服务器（server/app） 处理一个接口

• 路由的配置及使用

//index.js 文件 (与router同级)
const express = require("ex文件夹press")

const app = express()

app.listen(3000,()=>{
    console.log("3000端口正在监听")
})
//安装路由
app.use("/api/user",require("./router/a"))

//创建路由 
//a.js文件 (在router文件夹下)

const express = require("express")
//创建路由
const router =  express.Router()

//http://localhost:300/api/user 
//通过这个地址就可以响应这个接口
router.get("/",(req,res)=>{
    console.log("你好")
    res.end()
})

//在子路由里安装路由
router.use("/b",require("./b.js"))

//导出路由
module.exports = router

//文件b.js (在router文件夹下 与a.js同级)

const express = require("express")

const router =  express.Router()

router.get("/",(req,res,next)=>{
    console.log("这是b.js文件里面的/api/a/b哦....")
    res.end()
})
//导出路由
module.exports = router

router.all("*",当前路由下的验证工作)
//截获当前路由下的部分公共业务 （需要next延续）

mysql

node.js操作mysql数据库

//1引入mysql客户端的包
var mysql = require("mysql")
var express = require("express")
var app = express()
app.listen(3000)

//2创建库的链接
var connection = mysql.createConnection({
    host     : 'localhost',  //mysql的服务器地址
    user     : 'root',     //用户名
    password : 'root', //密码
    database : '2020-03-13'  //数据库名
});

//3链接
connection.connect()

//4查询
let str4 = `SELECT * FROM user`

//表相关的操作
// connection.query('sql语句', function (error, results, fields) {})

//前端请求将数据返回给前端
 app.get("/api/user",(req,res,next)=>{
    connection.query(str4, function (error, results, fields) {
         // console.log("error",error)
         // console.log("results",results)//返回一个对象
         // console.log("fields",fields)

        res.send({err:0,data:results})
        //5关闭库
       connection.end();
     })
 })

mongodb

mongodb非关系型数据库 又叫nosql 缓存型 使用场景多是解决大规模数据集合多重数据种类

下载 安装(必须安装在英文目录下)

为了从命令提示符下运行MongoDB服务器，你必须从MongoDB目录的bin目录中执行mongod.exe文件。
或者将bin配置到环境变量path中。
mongod --dbpath F:\MongoDB\data\db

1.配置数据文件存储位置:
找到安装目录\Server\4.0\bin\ -> cmd回车-> mongod 回车->mongod --dbpath c:\data\db
data和db目录需要手动创建

2.服务器启动
找到安装目录 \server\4.0\bin\ ->cmd回车->mongo回车

3.客户端启动
找到安装目录 \server\4.0\bin\ -cmd 回车-> mongo回车

4.环境变量
把安装目录添加到环境变量

• 库的操作

查所有库:show dbs
查看当前数据库 : db
创建库:use 库名 （没有此库就是新建库 有就切换）

删除库 db.dropDatabase() 删除当前库

• 集合的操作

创建集合: db.createCollection(“集合名”,{配置})
配置:{size:文件大小,capped:true,max:条数|文档数 }capped定量
db.表(集合).isCapped() 返回true/false 是否是定量

查询集合: show collections 或者 db.getCollectionNames()

删除集合: db.集合名.drop()

对集合的增删改查

• 增

db.集合.save({}) //添加一条
db.集合.insert({}) //添加一条
db.insertOne({}) //添加一条
db.集合.save([{ },{ }]) //添加多条
db.集合.insert([{},{}]) //添加多条

注意：insert 不会替换相同ID save会

• 删

db.集合.deleteOne({要删除数据条件描述}) //删除一条
db.集合.remove({},true) //删除一条
db.集合.remove({要删除数据条件描述})//删除多条
db.集合.remove({}) //清空集合

• 改

db.集合.udpate({查询条件},{替换条件},插入boolean,全替换boolean)

查询条件：
{age:22} age == 22
{age:{KaTeX parse error: Expected 'EOF', got '}' at position 6: gt:22}̲} age > 22 {a…lt:22}} age < 22
{age:{KaTeX parse error: Expected 'EOF', got '}' at position 7: gte:22}̲} age>=22 {ag…lte:22}} age<=22
{age:{$lte:122,$gte:22}} age<=122 && age>=22
{$or:[{age:22},{age:122}]} 22 or 122
{key:value,key2,value2} value && value2
{name:/正则/}

• 查

所有：db.集合.find(条件)
条数: db.集合.find().count()
去重：db.集合.distinct(key)

db.集合.find({条件},{指定要显示列区域})

指定要显示列区域
username:1 显示这个区域，其他不显示
username:0 不显示这个区域，其他显示
_id 是默认显示

• 排

db.集合.find().sort({key:1,key2:-1}) //升
db.集合.find().sort({key:-1}) //降

• 限定

db.集合.find().limit(number) //限定
db.集合.find().skip(number) //跳过
db.集合.findOne()//找第一个
db.集合.find().limit(1) //查询第一条