nodejs 知识总结集合

最新推荐文章于 2024-05-26 23:20:38 发布

置顶 alvxx

最新推荐文章于 2024-05-26 23:20:38 发布

阅读量605

点赞数 2

文章标签： nodejs mysql

本文链接：https://blog.csdn.net/qq_44728447/article/details/107707422

版权

模块化

node 的模块化使用的是 commonjs 的模块化系统

导出方法

1、module.exports = {} 对象中是导出的函数或者属性
2、exports.要导出的模块 = 要导出的逻辑或者属性方法

function fun() {
  console.log("来根华子");
}
module.exports = {
  fun,
};
exports.fun = fun;
exports.fun = function () {
  console.log("来根华子");
};

导入方法

//导入文件不要求模块必有导出，如果没有导出则会直接运行导入的文件
var str = require("要导入的文件路径");

创建服务器

//http是超文本协议  他是nodejs的一个内置模块 可以直接使用
var http = require("http");
createServer(function (request, response) {
  //request 是客户端请求的所有信息
  //response 是服务器要给客户响应的方法
  //text/plain 文本类型 utf-8 编码格式
  response.writeHead(200, { "Content-Type": "text/plain;charset-='utf-8;'" });
  response.write("向客户端输出的信息");//写入响应的信息
  response.end();//终止响应
}).listen(8081,function() {
  //8081 表示端口号 function服务器启动时的回调函数
});

文件系统

  //读取文件 他也是nodejs的一个内置模块 可以直接使用
  var fs = require('fs')
  //没有文件夹时可以新增文件夹并写入内容,如果有文件则会覆盖原文件夹的内容
  fs.writeFile('文件路径','要写入的内容',function() {})
  //读取文件夹内容的方法
  fs.readFile('文件路径',function(err,data) {
      //err 是读取失败的错误信息
      //data 读取成功时读取到的内容
  })
  //文件改名的方法
  fs.rename('要改名的文件的路径','要改成的文件的路径',function() {})
  //删除文件夹的方法
  fs.unlink('要删除的文件的路径',function() {})
  //在文件中追加内哦扔的方法,和writeFile的区别是这个是追加writeFile是覆盖掉原文件夹的内容
  fs.appendFile('要添加内容的文件路径','要添加的内容',function() {})
  //创建文件夹的方法
  fs.mkdir('文件路径','要写入的内容',function() {})

文件流

  //读取文件 他也是nodejs的一个内置模块 可以直接使用
  var fs = require('fs')
  // 创建一个写流的方法 createWriteStream 写流的方法
  var writeStream = fs.createWriteStream('创建的文件.txt');
  //开始写入内容 第一个参数是写入的内容,第二个是编码格斯
  writeStream.write('要写入的内容','utf-8')
  //标记写流结束
  writeStream.end()
  //标记写流完成
  writeStream.on('finish',function() {})

  readStream.on('error', function(err) {})

  var num = 0;
 
  // 创建一个读流的方法 createReadStream 读流的方法
  var readStream = fs.createReadStream('创建的文件.txt')
  // 监听读流的过程
  readStream.on('data', function(err, data) {
    num++
  })
  // 读流结束
  readStream.on('end', function() {
    console.log(num)
  })
  // 监听读流过程中发生的错误
  readStream.on('error', function(err) {})


  //利用管道流复制内容
  readStream.pipe(writeStream)

路由一些值

了解理由的

   var url = require('url')//内置模块 可以直接使用
   var path = 'https:www.baidu.com/index.html#index?md=mobile'
   var path1 = 'https:www.baidu.com/index.html?md=mobile'
   //url地址中#后面的值是哈希值 hash
   //url地址?后面的值交search值 一般是key=value的形式这种形式的参数叫query参数
   var pathname = url.parse(path)
   var pathname2 = url.parse(path2)
   console.log(pathname,pathname2)//结果如下
   Url {
  // protocol: 'https:', 连接中的传输协议
  // slashes: null,     
  // auth: null,        
  // host: null,        
  // port: null,        
  // hostname: null,
  // hash: '#index?md=mobile',  哈希值
  // search: null,
  // query: null,
  // pathname: 'www.baidu.com/index.html',
  // path: 'www.baidu.com/index.html',
  // href: 'https:www.baidu.com/index.html#index?md=mobile'
}
Url {
  // protocol: 'https:',
  // slashes: null,
  // auth: null,
  // host: null,
  // port: null,
  // hostname: null,
  // hash: null,
  // search: '?md=mobile', 连接中?及后面的部分
  // query: 'md=mobile',
  // pathname: 'www.baidu.com/index.html', 地址名称
  // path: 'www.baidu.com/index.html?md=mobile',
  // href: 'https:www.baidu.com/index.html?md=mobile'
}

路由的写法

   var http = require('http');
    var fs = require('fs');
    var url = require('url');
    var path = require('path');
    http.createServer(function(req, res) {
        // 获取路由对象中的pathname值
        var pathname = url.parse(req.url).pathname;

        // 获取文件的扩展名
        var extname = path.extname(pathname);
        pathname = pathname == '/' ? '默认渲染的html文件的地址' : pathname

        function getExtType (ext) {
            var str = ''
            switch (ext) {
                case '.html':
                    str = "text/html"
                break;
                case '.css':
                    str = "text/css"
                break;
                case '.js':
                    str = "text/javascript"
                break;
            }
            return str
        }
        var type = getExtType(extname)

        fs.readFile('./static' + pathname, function(err, data) {
            if(err) {
                fs.readFile('要渲染的错误文件的文件地址', function(err, errPage) {
                    res.writeHead(404, {"Content-type": `${type};charset=utf-8`})
                    res.write(errPage)
                    res.end()
                })
            } else {
                res.writeHead(200, {"Content-type": `${type};charset=utf-8`})
                res.write(data)
                res.end()
            }
        })

    }).listen(3000, function() {

    })

http、fs、url合用创建服务

举例说明

  //引入模块
   var http = require('http');
   var fs = require('fs');
   var url = require('url');
   //创建服务器
   http.createServer(function (request, response) {
     //获取路有对象中的pathname值，就是客户端输入的
    var pathname = url.parse(request.url).pathname
    pathname = pathname == '/' ? './index.html' : pathname
    if(pathname === "/index.html") { //"/index.html"自己创建的文件路径
        //readFile 读取文件fs的内置方法
        fs.readFile('./index.html', function(err, data) {
            if(err) {
                console.log(err)
            } else {
                response.writeHead(200, {'Content-Type': 'text/html;'});
                response.write(data)
                response.end();
            }
        })
    } else if(pathname === "/login.html") { //"/login.html"自己创建的文件路径
        fs.readFile('./login.html', function(err, data) {
            if(err) {
                console.log(err)
            } else {
              //获取url变成路有对象的query值
                var user = url.parse(request.url, true).query
                var list = [
                    {
                        name: "李狗蛋",
                        sex: "女",
                        tel: '110',
                        age: 45,
                        job: "吹牛"
                    },
                    {
                        name: "王粪球儿",
                        sex: "女",
                        tel: '110',
                        age: 45,
                        job: "吹牛"
                    }
                ]
                var obj = {}
                list.forEach(function(item, index) {
                    console.log(item)
                    if(item.name == user.username) {
                        obj = item
                    }
                })
                response.writeHead(200, {'Content-Type': 'text/html'});
                response.write(data)
                response.write(JSON.stringify(obj))
                response.end();
            }
        })
    }
}).listen(8081,function () {
  console.log('Server running at http://127.0.0.1:8081/');
});

引入第三方模块

创建出项目文件夹

引入第三方模块需要先初始化出package.json文件初始化命令 npm init 该命令需要一步步键入自己对项目的说明也可以使用 npm init -y 可以跳过键入阶段全部采用默认配置直接生成json文件

安装第三方模块的命令正常都是 npm install 要安装的模块名称（–save） --save如果不加则安装的依赖不会再json文件中列出来反之会列出来

–save的好处是如果删除了node_modules文件夹直接使用 npm install 命令即可安装列表中的依赖

在所有的终端命令中 install 可以简写 =》 i --save命令可以简写 =》 -S

    // 例如安装mime
    npm install mime --save => npm i mime -S
    {
        "name": "lol", // 包的名称 不能使用中文
        "version": "1.0.0", // 包的版本号
        "description": "'project'", // 对项目的描述
        "main": "index.js", // 项目的入口文件 配置了入口文件后在模块中引入该包的时候回直接加载该js文件
        "scripts": {
            "test": "echo \"Error: no test specified\" && exit 1"
        },
        "author": "wang", // 包作者
        "license": "ISC", // 证书 会自动生成
        "dependencies": { // 依赖清单 npm install 会按照该清单安装所需要的依赖
            "mime": "^2.4.6"
        }
    }

引入ejs模板

引入的命令 npm install ejs --save npm 是安装命令也可以使用cnpm命令 install意思是安装 ejs是指的要安装的包的名称 --save是可选项（ --save如果不加则安装的依赖不会再json文件中列出来反之会列出来）

使用ejs模板的方法

    var http = require('http');
    // 在要使用ejs模板的模块中引入ejs
    var ejs = require('ejs');
    // 在需要使用模板的地方使用ejs语法
    // 在模块中写入 renderFile是ejs渲染文件的方法 他渲染的文件可以是ejs文件也可以是html文件
    http.createServer(function(req, res) {
        ejs.renderFile('要渲染的文件的路径', {
            key:'要渲染的值', 
            status: true, 
            arr: [
                '你是个麻瓜', '你才是个麻瓜', '彼此彼此'
            ],
            user: {
                name: "劫",
                hit: "叉子"
            }
        }, function(err, data) {
            res.write(data)
            res.end()
        })
    })

<!-- ejs模板语法 -->
    <body>
        <!-- 渲染变量值得办法 -->
        <div><%=key%></div>
        <!-- ejs的判断语法 -->
        <%if(status) {%>
            <div>这实力status是true的时候要显示的内容</div>
        <%} else if(判断条件) {%>
            <div>这里是status是false并且判断条件是true的时候显示的内容</div>
        <%} else {%>
            <div>其他内容</div>
        <%}%>
        <!-- ejs列表渲染语法 -->
        <ul>
            <%for(var i = 0; i<arr.length; i++){%>
                <li><%=arr[i]%></li>
            <%}%>
        </ul>

        <!-- 渲染对象的值 -->
        <div><%=user.name%></div>
    </body>

express

  var express = require('express');
  var app = express();
  // express要渲染模板文件必须设置模板引擎
  // express的模板引擎默认渲染views文件夹中的文件
  app.set('view engine', 'ejs');
  app.get('/', function(req, res) {
      res.send('hello world')
  })
  app.get('/login', function(req, res){
      res.send('登录接口')
      // res.render('login.ejs', {})
  })
  app.get('/news', function(req, res) {
      res.send('新闻列表页')
  })
  app.get('/news/app', function(req, res) {
      res.send('新闻app页面')
  })
  // 这种:id的形式叫做动态路由 :后面的字面量是自定义的 没有固定要求 但是不能使用中文
  app.get('/news/:aaa', function(req, res) {
      res.send('新闻详情页')
  })

  app.listen(3000)



  var express = require('express');
  var ejs = require('ejs');

  var app = express();

  // engine模板引擎的设置方法 第一个参数是要渲染的文件的类型
  // 第二个参数是使用哪种模板引擎的方法
  app.engine('html', ejs.__express);
  // use是使用中间件的方法 express.static('static')是静态文件中间件
  app.use(express.static('static'))
  // 模板引擎默认识别的是views文件夹中的文件
  app.set('view engine', 'html');

  // 默认加载的内容
  app.get('/', function(req, res) {
      // res.send('hello world')
      // render 是一个渲染函数
      res.render('index', {name: "张三", tel: 110, score: 61})
  })
  // 加载login.html页面
  app.get('/login', function(req, res) {
      res.render('login', {})
  })
  app.post('/doLogin', function(req, res) {
      console.log(req.body)
  })
  exports.app = app //导出

express、get请求,post请求

  var express = require('express');
  var ejs = require('ejs');

  var app = express();

  // engine模板引擎的设置方法 第一个参数是要渲染的文件的类型
  // 第二个参数是使用哪种模板引擎的方法
  app.engine('html', ejs.__express);
  // use是使用中间件的方法 express.static('static')是静态文件中间件
  app.use(express.static('static'))
  // 模板引擎默认识别的是views文件夹中的文件
  app.set('view engine', 'html');

  // 默认加载的内容
  app.get('/', function(req, res) {
      // res.send('hello world')
      // render 是一个渲染函数
      res.render('index', {name: "张三", tel: 110, score: 61})
  })

  // 加载login.html页面
  app.get('/login', function(req, res) {
      res.render('login', {})
  })

  app.post('/doLogin', function(req, res) {
      console.log(req.body)
  })
  exports.app = app //导出 其他文件接启动即可

在js文件中

    var express = require('express');
    var app = express();
    // 考虑到post的请求的参数在请求体内 req.body 所以要安装body-parser来解析请求体中的数据
    // 安装body-parser的命令 npm install body-parser --save
    var bodyparser = require('body-parser');

    // 已解析表单提交数据为例 application/x-www-form-urlencoded
    // extended: false 值是false时解析值是“String”或“Array” 值是true的时候可以解析任意类型的数据
    var urlencodeParser = bodyparser.urlencoded({extended: false})


    app.post('/doLogin', urlencodeParser, function(req, res) {
        // 这时通过 req.body就可以拿到请求体中的数据了
    })


    app.listen(3000)

    <!-- 这里是客户端的post请求 action="/doLogin"请求地址  method="post"请求方式 -->
    <form action="/doLogin" method="post">
        账号: <input type="text" name="username">
        <br>
        <br>
        密码: <input type="text" name="psw">
        <br>
        <br>
        <input type="submit" value="登录">
    </form>

sql语句增删改查

增 INSERT INTO 表名称 (列1, 列2 …) VALUES (值1, 值2 …)
insert into 意思是插入 VALUES值
删 DELETE FROM 表名称 where 删除条件
改 UPDATE 表名称 SET 列=“新值” where 列=“条件”
查 SELECT * FROM 表名称 where 条件（可以通过&&设置多个条件）（*表示查询所有列） SELECT 列名 FROM 表名称 where 条件

nodejs连接数据库的方法

安装mysql
命令 npm install mysql --save

    var mysql = require('mysql');
    var db = mysql.createConnection({
        host: "localhost", // 连接域名
        port: "3306", // 端口号
        user: "root", // 超级管理员
        password: "123456", // 数据库密码
        database: "test" // 数据库名称
    })
    db.connect();
    db.query('sql语句', function(err, data) {
        if(err) {
            console.log(err)
        } else {
            // sql执行成功后获取到的数据
            var result = data
        }
    })

登录注册为例

  var express = require('express');
  var ejs = require('ejs');
  var { db } = require('./database/db');
  var bodyparser = require('body-parser');
  // 导入cookie
  var cookieParser = require('cookie-parser');
  var encodepaser = bodyparser.urlencoded({extended: false})
  var app = express();
  // 设置模板引擎渲染html文件 第二个参数是说明用ejs的表达式来渲染html文件
  app.engine('html', ejs.__express);
  // 设置渲染引擎为渲染html文件
  app.set('view engine', 'html');
  // 设置静态文件目录
  app.use(express.static('static'));
  // 使用cookie中间件
  app.use(cookieParser())
  //连接数据库
  db.connect()
  app.get('/', function(req, res) {
      // res.send('hello world')
      // res.render是一个渲染函数 第一个参数是要渲染的页面 第二个参数是要传入页面的数据
      res.render('login', {})
  })
  // 进入注册页面的路由
  app.get('/register.html', function(req, res) {
      res.render('register', {})
  })
  // 注册登录接口
  app.post('/index.html',encodepaser, function(req, res) {
      var sql = `select * from users where name='${req.body.name}'`
      db.query(sql, function(err, data) {
          if(err) {
              console.log(err)
          } else {
              // console.log(data)
              // var result = data
              if(data.length === 0) {
                  res.send("用户不存在")
              } else if(data[0].password !== req.body.psw){
                  res.send("账号或密码错误")
              } else {
                  // 设置cookie的方法 第一个参数是要设置的cookie的名字 第二个参数是要设置的cookie的值
                  res.cookie('name', req.body.name)
                  res.cookie('text', "容易胖,容易老, 容易头发边稀少")
                  res.render('index', {
                      userInfo: data[0]
                  })
              }
          }
      })
  })
  // 注册注册账号接口
  app.post('/register', encodepaser, function(req, res) {
      var data = req.body;
      if(data.psw == data.confirmPsw) {
          var sql = `insert into users (name, password) values ('${req.body.name}','${req.body.psw}')`
          db.query(sql, function(err, data) {
              if(err) {
                  console.log(err)
              } else {
                  // console.log(data)
                  // var result = data
                  res.render('login', {})
              }
          })
      } else {
          res.send('两次密码不相同')
      }
  })
  // 进入index.html
  app.get('/index.html', function(req, res) {
      // 获取存储的cookie信息 cookies是所有cookie的集合
      console.log(req.cookies)
      var sql = `select * from users where name='${req.cookies.name}'`;
      db.query(sql, function(err, data) {
          if(err) {
              console.log(err)
          } else {
              // console.log(data)
              res.render('index', {userInfo: data[0], key: req.cookies.text})
          }
      })
  })
  module.exports = {
      app
  }

cookie

安装 npm install cookie-parser --save

   // 引入cookie-parser
   var express = require('express');
   var app = express();
   var ejs = require('ejs');
   var cookieParser = require('cookie-parser');
   //使用cookieParser中间件
   app.use(cookieParser(aaa));//传入的参数作用加密模式使用
   app.engine('html',ejs.__express);
   app.set('view engine','html');
   app.get('/',function(req,res) {
       //设置cookie
       res.cookie('text','your name',{
           maxAge:1000*3  //设置cookie的储存时间(毫秒数)
           path:path:'/index.html' //用来设置能够获取cookie的连接地址
           domain:domain:'.aaa.com' //设置共用cookie的第二域名
           singed:true // 是否加密 设为 true 会对这个 cookie 签名，这样就需要用res.signedCookies 访问它,前提需要设置上面中间件app.use传参
           expires:new Data(2020-20-20)// 在设置的时间点后就会失效
       })
   })
   app.get('/index.html',function(req,res) {
       res.text = req.cookies.text;//没加密
       res.text = req.signedCookies.text;// 加密
       res.render('text',{})
   })
   module.exports = {app}//导出

web储存

设置存储的数据的方法第一个参数是要存储的数据的名称-名称可以自定义第二个参数是要存储的数据
当存储的数据的数据类型是引用类型时要使用json的形式保存数据

localStorage 储存空间只有5兆左右
localStorage 存储没有时间限制除非自己手动清除

   //localStorage是window的方法所以可以省略window
   localStorage.setItem('name','你是个麻瓜');
   // 获取localStorage的数据的方法 参数是要获取的存储数据的名称
   // 当要获取的数据还未存储时获取到的值是null
   console.log(localStorage.getItem('name'))

sessionStorage 储存的数据在标签页或者浏览器关闭的时候就自动清除

   sessionStorage.setItem('name','要储存的数据')
   // sessionStorage 参数是要获取的存储数据的名称
   // 当要获取的数据还未存储时获取到的值是null
   console.log(sessionStorage.getItem('name'))
   //其他页面获取直接console.log(sessionStorage.getItem('name'))

   //web储存存储引用类型的时候要把数据转换为json数据在存储,这样可以保留引用数据的类型
   var obj = {
       name:'赵信',
       age:20
   }
   var jsonData = JSON.stringify(obj)
   localStorage.setItem('name',jsonData)
   //获取存储的数据
    var str = JSON.parse(localStorage.getItem('name'))
    console.log(str)

手动清除的方法

   localStorage.clear() //这种方法会把储存的数据全部清除
   //制定清楚的储存数据,参数是要清楚的储存数据名称
   localStorage.removeItem('text')

三者的区别

cookie 储存空间只有4k cookie储存的数据可以在服务端和客户端来回穿梭而且cookie可以设置要使用的路径、过期时间、能使用cookie的域名
localStorage 储存空间较大有5兆左右储存的数据没有时间限制除非手动清除他是用于客户端
sessionStorage 储存的数据会在浏览器关闭或者当前页签关闭时清除储存空间相对较大也有5兆左右

拆分路由

这是要拆分的路由

    var express = require('express');
    var router = express.Router();
    router.get('/', function(req, res) {
        res.send('hello world')
    })

    module.exports = {
        router
    }

在项目主文件中

    var express = require('express');
    var app = express()
    var user = require('路由拆分文件所在的地址')
    // 这里写使用拆分的路由
    app.use('/', user.router)
    app.listen(3000, function() {
        console.log('serve is running')
    })

    // 在浏览器输入localhost:3000 就会显示hello world

express 生成器

安装生成器的命令 npm install -g express-generator

然后通过 express --view=ejs app
运行 npm install 安装依赖
启动 set DEBUG=app:* & npm start

AJAX 请求


   var ajax = new XMLhttpRequest(); // 实例化一个ajax请求的对象

    ajax.open(method, url, false) // 开启一个ajax请求 第一个参数是请求的方式 可以是get/post 第二个参数是请求的地址 第三个参数是否发送同步请求

    ajax.send() // 向服务器发送ajax请求

    // 获取ajax请求的响应数据

    ajax.onreadystatechange = function() {
        // readystate的状态变化
        // 0: 请求未初始化
        // 1: 服务器连接已建立
        // 2: 请求已接收
        // 3: 请求处理中
        // 4: 请求已完成，且响应已就绪
        // status 200 表示请求成功 404 表示页面丢失 请求地址错误
        if(ajax.readystate === 4 && ajax.status === 200) {
            // 记录响应数据
            var data = JSON.parse(ajax.responseText);
            console.log(data) // 就是服务返回的数据
        }
    }

ajax 请求封装

    // options 调用ajax请求是传递过来的参数
    function ajax(options) {
        var ajax = new XMLhttpRequest();

        ajax.open(options.method, options.url, false)

        ajax.send()

        ajax.onreadystatechange = function() {
            var data = JSON.parse(ajax.responseText);
            if(ajax.readystate === 4 && ajax.status === 200) {
                // 传递出响应的数据
                options.success(data)
            } else if(ajax.readystate === 4 && ajax.status !== 200) {
                options.fail(data)
            }
        }
    }
    ajax({
        method: "get" || "post",
        url: '你的请求地址',
        success: function(res) {
            // res就是响应的数据了
        },
        fail: function(err) {

        }
    })

请求头方法解决express跨域问题

    var express = require('express');
    var router = express.Router();

    router.all('*', function(req, res, next) {
        // 设置允许跨域的域名 * 表示允许所以的域名跨域请求
        res.header('Access-Control-Allow-Origin', '*');
        // 设置允许跨域请求的请求方式 * 表示允许所以的请求方式可以跨域
        res.header('Access-Control-Allow-Methods', '*')

        next()
    })

alvxx

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
nodejs 知识总结集合

模块化node 的模块化使用的是 commonjs 的模块化系统导出方法1、module.exports = {} 对象中是导出的函数或者属性2、exports.要导出的模块 = 要导出的逻辑或者属性方法function fun() { console.log("来根华子");}module.exports = { fun,};exports.fun = fun;exports.fun = function () { console.log("来根华子");};
复制链接

扫一扫