nodejs 学习规划与总结

nodejs定义

• node 是一个用在服务端运行js代码的环境 他是运行在谷歌的v8引擎上的javascript代码
• 他是用I/O模式 非阻塞模式 I => input O => out

nodejs 模块化

导出模块

    function fun() {
    
    
        console.log("这是要导出的内容")
    }
    //导出模块分为两种
    //第一种 如下：
    module.exports = {
    
    
        fun:fun
    }
    //第二种 如下：
    exports.fun = fun

导入模块

var fun = requier('要导入模块的url')

创建服务器

导入http模块

http模块是内置模块，可以直接引入 如下：

    var http = require('http');//导入模块
    //http.createServer：是http模块创建的一种方法 它的参数是一个回调函数 回调函数有两个参数
    // request是客户端请求的所有的信息
    // response是服务器要给客户响应额方法
    http.createServer(function (request, response) {
    
    
        //response.writeHead方法的第一个参数的请求的状态码 200表示请求成功 404表示请求失败；第二盒参数是要配置的编码格式
        // text/plain 文本类型 utf-8 编码格式
        response.writeHead(200, {
    
    'Content-Type': 'text/plain'});
        response.write('Hello World')//写入响应的内容
        response.end();//终止响应
        //8081 是端口号
    }).listen(8081,function(){
    
    
        //服务启动打印的内容
        console.log('Server running at http://127.0.0.1:8081/');
    });

文件系统（fs）

fs模块是nodejs的内置模块 可以直接调用

    var fs = require('fs');//调用模块
    // 没有文件时可以新增文件并且写入内容 如果有文件则覆盖掉原文件的内容
    fs.writeFile('文件路径', "要写入的内容", function(){
    
    })
    // 读取文件内容的方法
    fs.readFile('文件路径', function(err, data) {
    
    
        // err是文件读取失败的错误信息
        console.log(err)
        // data读取成功时读取到的文件内容
        console.log(data)
    })
    // 文件改名的方法
    fs.rename('要改名的文件的路径', "要改成的文件名的路径", function(){
    
    })
    // 删除文件文件的方法
    fs.unlink('要删除的文件的路径', function(){
    
    })
    // 在文件中追加内容的方法
    fs.appendFile('要添加内容的文件路径', "要添加的内容", function() {
    
    })
    // 创建文件夹的方法
    fs.mkdir('要创建的文件夹名称', function(){
    
    })

文件流

• 读流

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

• 写流

    var fs = requier('fs')
    //创建一个写流的方法
    var writeStream = fs.createWriteStream('要写流的文件url')
    var str = "要写入的内容";
    //writeStream.write 第一个参数是要写入的内容  第二个参数是编码格式

    writeStream.write(str,'utf-8')//写入内容
    writeStream.end()//标记写流的结尾
    writeStream.on('finish',function(data){
    
    
        //标记写流完成
    })

• 管道流（拷贝）

    var fs = requier('fs')
    //创建一个写流的方法
    var writeStream = fs.createWriteStream('要写流的文件url')
    //创建一个读流的方法
    var readStream = fs.createReadStream('要读的文件url')
    //利用pipe方法
    readStream.pipe(writeStream);

路由

路由（url）模块是内置模块，可以直接调用

    var url = requier('url');//调用url模块

    //url.parse(req.url) 将获取的url转换为路由对象
    //路由对象
    // {
    
    
    //     protocol: 'https:', 连接中的传输协议
    //     slashes: true,
    //     auth: null,
    //     host: 'www.baidu.com', 连接中的域名
    //     port: null,
    //     hostname: 'www.baidu.com',连接中的域名
    //     hash: '#index?md=mobile', 哈希值
    //     search: null,
    //     query: null,
    //     pathname: '/index.html',
    //     path: '/index.html',
    //     href: 'https://www.baidu.com/index.html#index?md=mobile'
    //   }

    //.pathname获取路由对象中的域名部分（www.baidu.com）
    var pathname = url.parse(req.url).pathname;
    pathname = pathname == '/' ? "默认渲染的HTML文件的url" : pathname

    //nodejs 获取后缀的内置模块
    var path = requier('path');

    //获取文件的扩展名
    var extname = path.extname(pathname);

ejs的使用方法

    // 引入ejs 
    var ejs = requier('ejs');
    var http = require('http');
    http.createServer(function(req,res){
    
    
        ejs.renderFile("要渲染文件的url",{
    
    key:value},function(err,data){
    
    
            res.write(data)
            res.end()
        })
    })

    <!-- ejs模板的使用语法 -->
    <div><%=key%></div>

mime模块

• mime 是第三方模块 需安装

安装命令 npm i mime -S

MIME(Multipurpose Internet Mail Extensions)多用途互联网邮件扩展类型。是设定某种扩展名的文件用一种应用程序来打开的方式类型，当该扩展名文件被访问的时候，浏览器会自动使用指定应用程序来打开。多用于指定一些客户端自定义的文件名，以及一些媒体文件打开方式。

    var mime=require("mime")//引入mime模块
    res.writeHead(200,{
    
    'Content-type':mime.getType(filePath)});    //通过后缀名指定mime类型
    res.end(data);

• 实例

    var http = require('http');
    var mime = require('mime'); 
    var url = require('url');
    var fs = require('fs');
    var path = require('path');
    var ejs = require('ejs');
    http.createServer(function (request, response) {
    
    
        var pathname = url.parse(request.url).pathname 
        pathname = pathname == '/' ? '/index.html' : pathname
        if(pathname == "/login") {
    
    
            ejs.renderFile('./login.html', {
    
    text: "这是登录页面", status: false, arr:[
                {
    
    
                    name: "小鱼人"
                },
                {
    
    
                    name: "儿童劫"
                },
                {
    
    
                    name: "喜之郎"
                }
            ]}, function(err, loginData) {
    
    
                response.write(loginData)
                response.end();
            })
        } else {
    
    
            fs.readFile('.' + pathname, function(err, data) {
    
    
                if(err) {
    
    
                    console.log(err)
                    // renderFile渲染文件
                    ejs.renderFile('./404.ejs', {
    
    
                        text: '哎呀， 页面跑丢了',
                        name: "李狗蛋"
                    }, function(err, errPage) {
    
    
                        response.write(errPage)
                        response.end();
                    })
                } else {
    
    
                    response.writeHead(200, {
    
    'Content-Type': mime.getType(pathname)});
                    response.write(data)
                    response.end();
                }
                
            })
        }
        
    }).listen(8081,()=>{
    
    
        console.log('Server running at http://127.0.0.1:8081/');
    });

express 模块

express 是第三方模块需安装

安装命令npm i express

    var express = requier('express')
    var ejs = requier('ejs')
    var app = express();//调用express
    // engine模板引擎的设置方法 第一个参数是要渲染的文件的类型
    // 第二个参数是使用哪种模板引擎的方法
    app.engine('html',ejs.__express);
    // use是使用中间件的方法 express.static('static')是静态文件中间件
    app.use(express.staic('static'))
    // 模板引擎默认识别的是views文件夹中的文件
    app.set('view engine','html')]
    //修改模板引擎默认识别的文件夹，这里是将默认的views文件 改为public文件夹
    app.set(views,__dirname + 'public')
    //默认加载的内容  localhost:3000
    app.get('/',function(erq,res){
    
    
        res.send('这是默认页面')
    })
    //localhost:3000/login
    app.get('/login',function(erq,res){
    
    
        res.send('这是登录页面')
    })
    //localhost:3000/news/任意
    app.get('/news/:id',function(erq,res){
    
    
        res.send('详情页')
    })

    //向服务器发送一个get请求  第一个参数是'localhost:3000/index' 第二个参数是一个回调函数
    app.get('/index',function () {
    
    
        //向客户端响应的内容 render是一个渲染函数
        //第一个参数是文件的名称 第二个参数的眼要传的数据
        res.render('index',{
    
    key:"这里可以传参数"})
    })


    app.listen(3000,()=>{
    
    
        console.log('ok')
    })

mysql模块 和 body-parser模块

• mysql模块 和 body-parser模块 都是第三方模块 需下载

在此模块中配置MySQL文件

    //引入MySQL模块
    var mysql = requier('mysql');

    var connection = mysql.createConnection({
    
    
        host:'localhost',//链接域名
        user:'root',//超级管理员
        port:'0415',//端口号
        password:'0415',//数据库密码
        database:'user'//数据库名称
    })
    //导出MySQL模块
    exports.db = connection;

导入mysql模块 和 body-parser模块

    var {
    
     db } = requier('./db/db')
    //使用'body-parser'解析 application/x-www-from-urlencoded 类型的数据
    var bodyparser = requier('body-parser');
    //urlencoded:解析 application/x-www-from-urlencoded 类型的数据的方法
    //extended: false作用是解析 string 和 Array 类型的数据 ；true解析任意类型的数据
    var urlencodePaeser = bodyparser.urlencoded({
    
    extended:true});

mysql的增删改查基础语句

    //查
    "select * from 表名 where name = '**'"
    //增
    'insert into 表名 （列一，列二 ···）values (值一，值二 ···)'
    //改
    'updata 表名 set 列=“新值” where 列="条件"'
    //删
    'delete from 表名 where 删除条件'

• 实例

    <!-- footer.html -->
    <ul>
        <li></li>
        <li></li>
        <li></li>
        <li></li>
        <li></li>
    </ul>

    <!-- index.html -->
    <h2>页面提交到这里</h2>

    <!-- login.html -->
    <!-- 登录页面 -->
    <form action="/dologin" method="post">
        账号：<inpur type="text" name="username">
        密码：<inpur type="password" name="psw">
        <input type="submit" value="登录">
    </form>
    <!-- 通过ejs模板可以将一段HTML代码片段加入当前文件中 -->
    <%- include('footer.html')%>

    var express = requier('express')
    var app = express();
    var ejs = requier('ejs');
    var {
    
     db } = requier('./db/db');
    app.engine('html',ejs.__express);
    app.use(express.staic('static'));
    app.set('view engine','html')];
    app.set(views,__dirname + 'public');
    var urlencodePaeser = bodyparser.urlencoded({
    
    extended:true});
    app.get('/login',function(req,res){
    
    
        res.render('login',{
    
    });
    })
    app.get('/index',function(req,res){
    
    
        res.render('index',{
    
    });
    })
    app.post('/dologin',urlencodePaeser,function(req,res){
    
    
        var sql = `select * from users where name=${
      
      req.body.username} && password=${
      
      req.body.psw}`;
        db.qurey(sql,function(err,data){
    
    
            if(err){
    
    
                conlose.log(err)
            }else{
    
    
                var result = data;
                res.render('index',result[0])
            }
        })
    })
    app.listen(3000,()=>{
    
    
        console.log('ok')
    })

cookie模块

cookie 是第三方模块 需下载 ====》 命令 npm i cookie-parser -S

• 安装cookie中间件 cookie是一种存储数据的方法 使用cookie可以将数据存储起来 他可以在客户端和服务端穿梭的数据

    var ejs = requier('ejs')
    var express = requier('express')
    var app = express();
    app.set('view engine','html')
    app.engine('html',ejs.__express)
    //引入cookie中间件
    var cookie = requier('cookie-parser')
    //使用中间件
    app.use(cookie())
    //假如加载localhost:3000时 存入cookie数据
    app.get('/',function(req,res){
    
    
        //res.cookie方法：第一个参数是存储数据的名字 第二个参数是储存的内容
        //如两个名字一样 则会覆盖上一次储存的数据
        // res.cookie("name","要储存的数据") //两个参数时

        //三个参数时 第三个参数为一个数组  
        res.cookie('name','要储存的数据',{
    
    
            maxAge:6000,//规定储存数据有效时间
            expires: new Data(2020-07-31 11:45:00),//规定储存数据的过期时间
            domain:'www.fang.com', //设置公用的cookie第二域名
            signed:'true',//储存的数据是否加密
            //设置加密是中间价里面要传入一个String  app.use(cookie('aaa'))
            path:'index.html'//设置能够获取cookie数据的地址
        })
        res.render('index',{
    
    })
    })
    //进去其他页面获取cookie数据
    app.get('/list',function(req,res){
    
    
        // 第一种获取方式 没有加密的情况下
        // var txt = req.cookies.name;
        // 第二种获取方式 加密的情况下
        var txt = req.sigendCookies.name;

        res.render('list',{
    
    txt:txt})
    }
     app.listen(3000,()=>{
    
    
        console.log('ok')
    })

web储存

    //localStorage 的空间有5mb 左右   数据不会丢失
    //.setItem  储存数据
    localStorage.setItem('name','要储存的数据')
    var jsonData = JSON.stringify(obj);
    var obj = {
    
    
        name:'狗子',
        age:18
    }
    localStorage.setItem('obj', jsonData)

    //.getItem 取数据
    localStorage.getItem('name')
    localStorage.getItem('obj')
    console.log(JSON.parse(localStorage.getItem('obj')))

    //另一种储存方式  sessionStorage
    //储存的数据在标签页或者浏览器关闭的时候就清除了 
    function fun(){
    
    
        sessionStorage.setItem('name','要储存的数据')
        console.log(seccionSturage.get('name'))
    }

Express 应用程序生成器

npm install -g express-generator (安装)

express --view=pug myapp （生成）

set DEBUG=myapp:* & npm start （启动）

路由的拆分

这是要拆分的路由

    var express = requier('express')
    var router = experss.Router()
    router.get('/',function(req.res){
    
    
        res.send('你好，世界')
    })
    module.exports = {
    
    
        router
    }

主项目中

    var express = requier('express')
    app.express();
    var user = requier('路由拆分文件所在地址')
    app.use('/',user.router)
    app.listen(3000,()=>{
    
    
    console.log('ok')
    })

浏览器中localhost:3000

结果为“你好，世界”

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()
    })