Nodejs讲解：

文丁响

已于 2022-11-27 21:42:06 修改

阅读量361

点赞数

文章标签： javascript 前端开发语言

于 2022-11-24 22:48:17 首次发布

本文链接：https://blog.csdn.net/wdx1641670284/article/details/128028044

版权

1.Nodejs介绍：

nodejs 可以开发后端代码，可以用JavaScript(不包括dom bom 存储)处理逻辑，连接数据库等操作

wimdow+r 输入 cmd 输入node 验证nodejs安装成功

2.如何创建web服务：

//如何使用node创建一个web服务器

//1.引入node的内置模块 http
const http = require('http');
//2.创建server服务
const server = http.createServer();
//3.监听请求参数
server.on('request',(req,res) => {
    //响应 utf-8格式
    res.setHeader('content-type','text/html;charset=utf-8');
    //4.监听完请求，返回指定参数
    res.end('<h1>中文</h1>')
})

//5.启动web服务
//server.listen(端口号,callback(成功之后的参数))
server.listen(8080,'127.0.0.1',() => {
    console.log('服务启动成功，地址是:http://127.0.0.1:8080/');
})

3.npm应用场景：

可从NPM服务器下载别人编写的第三方包到本地使用。

可从NPM服务器下载并安装别人编写的命令行程序到本地使用。

可将自己编写的包或命令行程序上传到NPM服务器供别人使用。

4.npm init 初始化：

npm init 命令初始化项目, 生成package.json文件

npm init

vscode形成的package.json文件内容：

5.安装模块：

npm install 命令用于安装某个模块

方法：npm install 模块包名

package-lock.json文件会添加dependencies：

6.使用mysql模块，连接mysql数据库：

require(模块)引入路径的规则：

1.首先先查看node有没有这个内置模块>再去找package.json看dependencies里面有没有配置这个模块没有的话直接报错如果package.json里面配置了，但是node_module里面没有这个包，也会报错

2.如果模块的名字是绝对或者相对文件的路径，会按照js的路径查找规则找到他;

// 1.引入mysql模块
const mysql = require('mysql');
// 2.创建mysql连接
var con = mysql.createConnection({
    // 数据库信息参数
    // 数据库的地址
    host: "localhost",
    // 数据库名
    database: "web2208",
    // 数据库用户名
    user: "wdx",
    // 数据库密码
    password: "a1641670284"
})
// 3.连接数据库
con.connect((err) => {
    // err 代表的是 是不是失败了 err = false  连接成功 否则就是失败了
    if(err){
        console.log('数据库连接失败');
    }else{
        console.log('数据库连接成功');
    }
})

7.使用sql语句查询数据库:

方法：con.query(sql语句字符串,回调函数)

// node 没有 mysql的内置模块 
// 需要下载(安装) 
// npm install 模块包名
// require(模块)引入路径的规则;
// 1.首先先查看node有没有这个内置模块>再去找package.json看dependencies里面有没有配置这个模块没有的话直接报错
// 如果package.json里面配置了，但是node_module里面没有这个包，也会报错
// 2.如果模块的名字是绝对或者相对文件的路径，会按照js的路径查找规则找到他;


// 1.引入mysql模块
const mysql = require('mysql');
// 2.创建mysql连接
var con = mysql.createConnection({
    // 数据库信息参数
    // 数据库的地址
    host: "localhost",
    // 数据库名
    database: "web2208",
    // 数据库用户名
    user: "wdx",
    // 数据库密码
    password: "a1641670284"
})
// 3.连接数据库
con.connect((err) => {
    // err 代表的是 是不是失败了 err = false  连接成功 否则就是失败了
    if(err){
        console.log('数据库连接失败');
    }else{
        console.log('数据库连接成功');
    }
})
//4.使用sql语句查询数据库
//con.query(sql语句字符串,回调函数)
con.query('select * from user',(error,res) => {
    //error 为 null的时候 证明sql语句执行成功了 否则就是失败了
    //如果error不为空 则error回调的消息 就是sql语句的错误
    if(error == 'null'){
        console.log(error);
    }else{
        console.log(res);
    }
    // 执行完sql语句要断开sql连接
    con.end();
})

输出结果：

8.使用http+mysql模块将浏览器和数据库建立连接：

//1.引入http模块
const http = require('http');
//2.创建server服务
const server = http.createServer();
//3.监听请求
server.on('request',(req,res) => {
    //响应格式
    res.setHeader('content-type','text/html;charset=utf-8');
    //每次请求都访问数据库
    // 3.1引入数据库模块
    const mysql = require('mysql');
    // 3.2创建mysql连接
    const con = mysql.createConnection({
        host: "localhost",
        database: "web2208",
        user: "wdx",
        password: "a1641670284"
    })
    //3.3启动连接
    con.connect();
    //3.4查询sql语句
    con.query('select * from result',(error,result) => {
        if(error){
            res.end('数据库启动失败原因：' + error);
        }else{
            //返回参数
            res.end(`
                function jsonpCallBack(){
                    return ${JSON.stringify(result)}
                }
            `);
        }
    })
    
})
//4.启动web服务
server.listen(8080,'127.0.0.1',() => {
    console.log('服务启动成功，地址是:http://127.0.0.1:8080/');
})

输出结果：

9.jsonp解决跨域：

9.1同源策略：

IP相同端口号同一浏览器三统一，才不会出现跨域问题;

只有浏览器才会出现跨域问题, 因为在浏览器请求任何地址的时候，都会把请求的敏感信息，暴露在浏览器上;这个时候，浏览器出于对网站信息的保护，会默认不让不同源的地址，有交互情况;

如果需要让不同源的地址交互，需要请求的源地址，同意请求才行，也就是服务端需要同意跨域访问;

9.2jsonp形式：

原理:

是前端使用script的src属性进行创建标签,这个是不存在跨域的，但是并不能够通过前端技术拿到数据;

// 1.动态创建 script标签
        let script = document.createElement('script');
        // 2.指定请求路径使用script标签的src属性
        script.src = 'http://127.0.0.1:8080/?call=jsonpCallBack';
        // 3.将创建的script加入到body里面
        document.body.appendChild(script);
        // 4.当script数据请求完成
        script.onload = function (){
            // 5.加载完成之后调用后端返回的jsonpCallBack函数
            // 如果后端返回了jsonpCallBack函数，在前端的window里面能够找到jsonpCallBack
            // var 数据变量 = window.jsonpCallBack();
            var data = window.jsonpCallBack();
            // 打印数据
            console.log(data);
        }

9.2.1jsonp的后端配置：

// 1.引入http模块
const http = require('http');
// 2.创建server服务
const server = http.createServer();
// 3.监听请求
server.on('request',(req,res) => {
    // 相应格式
    res.setHeader('content-type','text/html;charset=utf-8');
    // 每次请求都访问数据库
    // 3.1引入mysql数据库模块
    const mysql = require('mysql');
    // 3.2创建mysql连接
    const con = mysql.createConnection({
        // 数据库地址
        host: 'localhost',
        // 数据库名称
        database:'web2208',
        // 数据库用户名
        user:'wdx',
        // 数据库密码
        password:'a1641670284'
    })
    // 3.3 启动连接
    con.connect();
    // 3.4 查询sql语句
    con.query('select * from result',(error,result)=>{
        if(error){
            res.end('数据库查询失败原因:' + error);
        }else{
            // 返回jsonpCallBack函数
            res.end(`
                function jsonpCallBack(){
                    return ${JSON.stringify(result)}
                }
            `);
        }
        // 关闭数据库连接
        con.end();
    })
})

// 4.启动服务
server.listen(8080,'127.0.0.1',()=>{
    console.log('服务启动成功,地址是http://127.0.0.1:8080/');
})

9.1输出结果：

10.后端允许所有的跨域：

<script>
        let ajax = new XMLHttpRequest();
        ajax.open('get','http://127.0.0.1:8080/');
        ajax.send();
        ajax.onreadystatechange = function (res){
            if(res.currentTarget.readyState = 4 && res.currentTarget.status == 200){
                // 参数处理
                try{
                    // 尝试运行try里面的代码，如果出现语句报错，会把错误抛出去
                    // 抛到catch的(这个形参里面)
                    let data = JSON.parse(res.currentTarget.response);
                    console.log(data);
                }catch(error){
                    console.log(res.currentTarget.response);
                }
            }
        }
</script>

后端配置：

// 1.引入http模块
const http = require('http');
// 2.创建server服务
const server = http.createServer();
// 3.监听请求
server.on('request',(req,res) => {
    // 相应格式
    res.setHeader('content-type','text/html;charset=utf-8');
    /* 
        writeHead(响应的状态码200代表成功,相应的头部)
    */
    res.writeHead(200, {
        // cors头,允许跨域，放行所有请求
        /* 
            *代表允许所有的ip跨域请求
        */
        // "access-control-allow-origin":"http://127.0.0.1:5500"

        "access-control-allow-origin":"*"
    })
    // 每次请求都访问数据库
    // 3.1引入mysql数据库模块
    const mysql = require('mysql');
    // 3.2创建mysql连接
    const con = mysql.createConnection({
        // 数据库地址
        host: 'localhost',
        // 数据库名称
        database:'web2208',
        // 数据库用户名
        user:'wdx',
        // 数据库密码
        password:'a1641670284'
    })
    // 3.3 启动连接
    con.connect();
    // 3.4 查询sql语句
    con.query('select * from result',(error,result)=>{
        if(error){
            res.end('数据库查询失败原因:' + error);
        }else{
            // 返回参数
            res.end(JSON.stringify(result));
        }
        // 关闭数据库连接
        con.end();
    })
})

// 4.启动服务
server.listen(8080,'127.0.0.1',()=>{
    console.log('服务启动成功,地址是http://127.0.0.1:8080/');
})

输出结果：

11.通过不同接口访问不同方法：

let http = require('http');
let server = http.createServer();
server.on('request',(req,res) => {
    res.setHeader('content-type','text/html;charset=utf-8')
    //允许跨域
        res.writeHead(200, {
            "access-control-allow-origin":"*"
        })
    if(req.url.indexOf('register') != -1){
        let url = req.url;
        url = url.split('?')[1];
        url = url.split('&');
        let obj = {};
        url.forEach(item =>{
            obj[item.split('=')[0]] = item.split('=')[1]
        });
        res.end(
            '前端发送的参数是:'+JSON.stringify(obj)
        )
    }else{
        res.end('访问了查询接口')
    }
});
server.listen('8080','127.0.0.1',() =>{
    console.log('服务启动成功,地址是:http://127.0.0.1:8080/');
})

输出结果：

12.GET请求：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
       /* 
         get请求需要把前端要发送给后端的参数，写在请求的地址里面
            地址/接口路径?参数1=参数值1&参数2=参数值2&参数3=参数值3...
            例如:
                http://127.0.0.1/register?userName=admin123&userPassword=admin123
        但是get请求的缺点是:
            会把请求的参数暴漏在请求的路径/地址栏里面(不安全)
        get请求的应用场景:
            1.ajax的get请求，
            2.跨域处理方式jsonp;script的src属性,
            3.在浏览器的地址栏里面直接输入请求的路径
       */
       let ajax = new XMLHttpRequest();
        ajax.open('get','http://127.0.0.1:8080/register?userName=admin888&userPassword=admin888&nickName=易潇潇大哥&sex=男');
        ajax.send();
        ajax.onreadystatechange = function ({currentTarget}){
            if(currentTarget.readyState == 4 && currentTarget.status == 200){
                try{
                    let data = JSON.parse(currentTarget.response);
                    console.log(data);
                }catch(error){
                    console.log(currentTarget.response);
                }
            }
        }
    </script>
</body>
</html>

输出结果：

13.将前端发送的参数存在数据库里面：

// 引入http模块
let http = require('http');
// 创建srever
let server = http.createServer();
// 监听请求
server.on('request', (req,res)=>{
    // 相应格式
    res.setHeader('content-type','text/html;charset=utf-8');
    // 允许跨域
    res.writeHead(200, {
        // cors头,允许跨域，放行所有请求
        "access-control-allow-origin":"*"
    })
    if(req.url.indexOf('register') != -1){
        let url = req.url;
        url = url.split('?')[1];
        url = url.split('&');
        let obj = {};
        url.forEach(item => {
            // decodeURIComponent  中文被编码转换为中文
            obj[item.split('=')[0]] = decodeURIComponent(item.split('=')[1])
        });
        
        // 引入mysql模块
        const mysql = require('mysql');
        // 创建数据库连接
        const con = mysql.createConnection({
            host: 'localhost',
            database: 'web2208',
            user: 'wdx',
            password: 'a1641670284'
        })
        // 打开连接
        con.connect();
        // 查询ssql语句
        let sql = `insert into user (userName,userPassword,userTel,sex,userHead,usertime) values("${obj.userName}","${obj.userPassword}","${obj.userTel}","${obj.sex}","null","${Date.now()}")`
        // 运行sql语句
        con.query(sql,(error,result)=>{
            if(error){
                res.end('语句执行失败，原因'+error)
            }else{
                res.end(
                    JSON.stringify(result)
                )
            }
            // 每次都要关闭数据库连接
            con.end();
        })
    }else{
        res.end('访问了查询接口')
    }
})
// 启动服务
server.listen('8080','127.0.0.1',()=>{
    console.log('服务启动成功,地址是:http://127.0.0.1:8080/');
})

输出结果：