nvm install 14.7.0 // 安装14.7.0版本的nodejs

nvm use 14.7.0

nvm ls

nvm list

nvm uninstall <version>

nvm list available

nvm -v     // 查看是否安装完成
nvm list available 	// 显示可以安装的node.js版本
nvm install 18.20.1  // 安装node.js的命名18.20.1是版本号
nvm list	// 查看已安装的node.js
nvm use 18.20.1   // 切换到使用指定的node.js版本

root: C:\Users\15241\AppData\Roaming\nvm
path: C:\Program Files\nodejs

node_mirror: http://npmmirror.com/mirrors/node/ 
npm_mirror: http://npmmirror.com/mirrors/npm/

/*
互联网（WAN）就是我们每天上的网，理论上来说互联网就是最大的网络。如果你的计算机接入了网络，从理论上说就是互联网的一部分了。如果断网了，就不属于互联网了。他的信息量十分的巨大。不同国家的互联网可能是通过越洋电缆去连接的。


局域网（LAN）(Local Area Network)就是一个小范围内的网络，可能是10公里以内，也可能是一个公司的网络。特点就是小范围传输的速度特别快。就像我们以前的“CS”、“魔兽世界”。网吧就是一个局域网。而互联网（广域网）就是由一个一个的城域网、小的广域网和局域网组成。
*/

node : 无法将“node”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后再试一次。
所在位置 行:1 字符: 1
+ node -v
+ ~~~~
+ CategoryInfo          : ObjectNotFound: (node:String) [], CommandNotFoundException
 + FullyQualifiedErrorId : CommandNotFoundException

nodemon : 无法加载文件 C:\Users\HP\AppData\Roaming\npm\nodemon.ps1，因为在此系统上禁止运
行脚本。有关详细信息，请参阅 https:/go.microsoft.com/fwlink/?LinkID=135170 中的 about_Execution_Policies。                                                                         脚本。有关详细信息，请参阅 https:/go.microsoft.com/fwlink/?LinkID=135170 中的 about_Execution_Policies。
所在位置 行:1 字符: 1
+ nodemon .\app.js
+ ~~~~~~~
    + CategoryInfo          : SecurityError: (:) []，PSSecurityException
    + FullyQualifiedErrorId : UnauthorizedAccess

// 1. 以管理员的身份运行 PowerShell
输入：（选择 Y 回车）
	set-ExecutionPolicy RemoteSigned

// 2. 查看是否修改成功：
	get-ExecutionPolicy
//  返回 RemoteSigned 即可

// 例如：
// 导入fs模块
const fs = require("fs");

fs.readFile("./01-url.js", "utf-8", (error, data) => {
  // 如果错误
  if (error) console.log("读取失败！！！");
  // 成功
  console.log(data);
});

// 例如：
const fs = require("fs");

fs.writeFile("./test文件夹/写入后的文件.txt", "hello world", (error, data) => {
  if (error) console.log("写入失败");

  console.log(data, "写入成功");
});

// 例如：
// 先导入path模块
const path = require("path");

const str = path.join("/a", "/b/c", "../", "/d", "./", "/e");
// 注意：../会抵消前一个字符串
console.log(str); //打印结果为：\a\b\d\e

const str2 = path.join(__dirname, "./02-读取文件.js");
console.log(str2); //打印结果为：F:\张向阳综合文件\node.js\复习nodejs\01-内置模块\02-读取文件.js

// 1.导入http模块
const http = require("http");

// 2.创建web服务器实例
const server = http.createServer();

// 3.为服务器实例绑定 request 事件
// 	 使用服务器实例的 .on() 方法，为服务器绑定一个 request 事件
server.on("request", (request, response) => {
  console.log(request.socket.remoteAddress); //这个可以获取IP地址（远程 IP 地址的字符串表示形式）
  console.log("someone vist our web server");
  // 只要有客户端来请求我们自己的服务器，就会触发 reques 事件，从而调用这个事件处理函数
});

// 4.启动服务器
//   调用服务器实例的 . listen() 方法，即可启动当前的web服务器实例
//   调用 server.listen(端口号，callback回调)方法，即可启动web服务器
server.listen(8080, () => {
  console.log("http server running at http://127.0.0.1:8080");
});

// 如下：
server.on('request', (request,response) => {
    // 发送的内容中包含中文
    let str = 'url地址为：http://www.baidu.com',

    // 防止中文显示乱码的问题，需要设置响应头 Content-Type 的值为：text/html;charset=utf-8
    response.setHeader('Content-Type','text/html;charset=utf-8')

    //把含有中文的内容，响应给客户端
    response.emd(str)
})

// 例如：
// 加载内置的fs模块
const fs = require("fs");

// 加载用户的自定义模块
const index = require("./index.js"); // 可以省略 .js 的后缀名

// 加载第三方模块
const alt_template = require("alt_template");

// 例如：
// 这是 01-module.exports.js 文件
// 向 module.exports 对象上挂载 userMessage 属性
module.exports.userMessage = "张三是个大帅逼";

// 向 module.exports 对象上挂载 sayHello 方法
module.exports.sayHello = function () {
  console.log("hello world");
};

// 这是 server.js 文件
// 导入自定义模块
const m = require("./01-module.exports.js");
console.log(m); //{ userMessage: '张三是个大帅逼', sayHello: [Function (anonymous)] }

// 向 module.exports 对象上挂载 userName 属性
exports.userName = "李四";

// 向 module.exports 对象上挂载 sayHello 方法
exports.sayHello = function () {
  console.log("hello world");
};

// 导入一个自定义模块
const m = require("./02-exports.js");
console.log(m); //{ userName: '李四', sayHello: [Function (anonymous)] }

// 1.导入exress框架
const express = require("express");

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

// 3.当用户访问 / 地址时就响应内容
app.get("/", (req, res) => {
  res.send("你好 express!!!");
});

// 4.启动web服务器
app.listen(3000, () => {
  console.log("express server running at http://127.0.0.1:3000");
});

// 1.监听GET请求
通过 app.get() 方法，可以监听客户端的 GET 请求，具体的语法格式如下：
app.get('请求URL', function(request,response) {
    /*处理函数*/
})
// 参数一：客户端请求的 URL 地址
// 参数二：请求对应的处理函数
//		  request：请求对象（包含了对请求相关的属性与方法）
// 		  response：请求对象（包含了对响应相关的属性与方法）

// 2.监听POST请求
通过 app.post() 方法，可以监听客户端的 POST 请求，具体的语法格式如下：
app.post('请求URL', function(request,response) {
    /*处理函数*/
})
// 参数一：客户端请求的 URL 地址
// 参数二：请求对应的处理函数
//		  request：请求对象（包含了对请求相关的属性与方法）
// 		  response：请求对象（包含了对响应相关的属性与方法）

// 例如：
const express = require("express");
const app = express();

// 监听GET请求
app.get("/user", (req, res) => {
  res.send({
    name: "张三",
    age: 18,
    gender: "男",
  });
});
// 监听GPOST请求
app.post("/user", (req, res) => {
  res.send("POST请求成功");
});

app.listen(3000, () => {
  console.log("express server running at http://127.0.0.1:3000");
});

app.get("/", (request, response) => {
  // request.query 默认是一个空对象
  // 客户端使用 ?name=zs&age=18&gender=男 这种查询字符串形式，发送到服务器的参数
  // 可以通过 request.query 对象访问到，例如：
  // request.query.name   request.query.age   request.query.gender
  console.log(req.query);
});

//在 URL 地址中,可以通过  :参数名  的形式,匹配到的动态参数
app.get("/user/:id", (request, response) => {
  // request.params 默认是一个空对象
  // 里面存放着通过 : 动态匹配到的参数值
  console.log(request.params);
  response.send(req.params);
});

// 可以有多个动态参数
app.get("/user/:id/:name", (request, response) => {
  console.log(request.params);
});

app.use(express.static("./Static_resources/小米商城首页"));

// 例如
const express = require("express");
const app = express();

app.use(express.static("./Static_resources/小米商城首页")); // 会自动找到./Static_resources/小米商城首页里的index.html文件

app.listen(3000, () => {
  console.log("express http running at http://127.0.0.1");
});

// 例如
const express = require("express");
const app = express();

app.use(express.static("./Static_resources/小米商城首页"));
app.use(express.static("./file"));

app.listen(3000, () => {
  console.log("express http running at http://127.0.0.1");
});

app.use("/api", express.static("./Static_resources/小米商城首页"));

app.method(path, handler);
// method：请求的类型
// path：请求的URL地址
// handler：处理函数

// 最简单的路由用法（这种写法很少用，会导致代码量增多不方便管理与维护）
// 例如：
const express = require("express");

// 创建 web 服务器，命名为 app
const app = express();

// 挂载路由
app.get("/user", (req, res) => {
  res.send("user page");
});
app.post("/user", (req, res) => {
  res.send("post request");
});

// 启动 web 服务器
app.listen(80, () => {
  console.log("Express router at http://127.0.0.1");
});

// 这是创建路由模块

// 1.导入express
const express = require("express");

// 2.创建路由对象
const router = express.Router();

// 3.挂载获取用户列表的路由
router.get("user/list", (req, res) => {
  res.send("GET user list.");
});
// 4.挂载添加新用户的路由
router.post("user/add", (req, res) => {
  res.send("POST new user.");
});

// 向外导出路由对象
module.exports = router;

// 这是注册路由模块

const express = require("express");
const app = express();

// 1.导入路由模块
const userRouter = require("./05-router.js");
// 2.使用app.use() 注册路由模块
app.use(userRouter);

app.listen(80, () => {
  console.log("http://127.0.0.1");
});

// 1.导入路由模块
const userRouter = require("./05-router.js");

// 2.使用app.use() 注册路由模块，并添加统一的访问前缀 /api
app.use("/api", userRouter);

app.get("/", (request, response, next) => {
  next();
});

1. body-parser 中间件作用：解析POST提交的数据
	// 整合 body-parser
    const bodyParser = require('body-parser');
    // 增加 解析 x-www-form-urlencoded 数据的能力
    app.use(bodyParser.urlencoded({ extended: false }));

2. multer 中间件作用：文件上传

3. 对密码进行加密处理
为了保证密码的安全性，不建议在数据库以 ‘明文’ 的形式保存用户密码，推荐对密码进行加密储存

在项目中，使用 bcryptjs 对用户密码进行加密，优点：
  加密之后的密码，无法被逆向破解
  同一明文密码多次加密后，得到的加密结果各不相同，保证了安全性

1. npm i bcryptjs
2. const bcrypt = require('bcrypt')
3. 调用 bcrypt.hashSync(明文密码， 随机盐的长度) 方法，对用户的密码进行加密处理：
password = bcrypt.hashSync(password, 10)

3. nanoid  随机生成id  (是uuid的简化版)

// 账号：root
// 密码：root

mysq命令窗口
// 1. 创建数据库(xiangyang)
create database xiangyang;
// 2. 删除数据库
drop database xiangyang;
// 3. 选择数据库
use xiangyang
//4.

// 实例---以 xiangyang数据库 为例

// 第一步(显示所有数据库)
show databases;
// 第二步(选择数据库)------（有可能不写这步）
select databases;
// 第三步(选择需要操作的那个数据库)------（有可能不写这步）
select xiangyang;
// 第四步(使用数据库)
use xiangyang;
// 第五步(查询这个数据库中hero表的所有数据)
select * from hero;
// 接下来你可以尽情的用SQL语句操控数据库了

1.打开MySQL 8.0 Command Line Client，并输入数据库的初始密码。
2.第二步，输入ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'root';

// 新增操作
// hero是表名
knex("hero")
  .insert({
    // insert写对象即可 key就是字段的名字
    name: "李白",
    title: "诗仙",
  })
  .then((res) => {
    // res 可以获取到 新增数据的 id
    // 数据插入成功之后 执行 then 回调函数
    console.log("res:", res);
  });

//导入模块 并且连接上 本机的数据库
const knex = require("knex")({
  // 操纵的数据库客户端
  client: "mysql",
  // 数据库连接
  connection: {
    // 地址
    host: "127.0.0.1",
    // 用户名
    user: "root",
    // 密码
    password: "root",
    // 库名
    databases: "xiangyang",
  },
});

knex(表名)
  .insert(对象)
  .then((res) => {});

// 示例代码

// 新增操作
// hero是表名
knex("hero")
  .insert({
    // insert写对象即可 key就是字段的名字
    name: "李白",
    title: "诗仙",
  })
  .then((res) => {
    // res 可以获取到 新增数据的 id
    // 数据插入成功之后 执行 then 回调函数
    console.log("res:", res);
  });

// 示例代码

// 查询操作
// hero是表名
knex("hero")
  // select 不给参数 是查询所有字段
  // 设置字段的话 用逗号分隔，类型是字符串
  .select()
  // where 是查询所有信息（不写条件条件必须写个空对象）{}
  // 给具体的对象，是精确匹配
  .where({
    title: "诗仙",
  })
  .then((res) => {
    console.log(res);
  });

knex("表名")
  .where("字段名", "like", "%查询的内容%")
  .then((res) => {});

// 示例代码

// 模糊查询
// hero是表名
knex("hero")
  // where 给空对象是查询所有对象
  // 参数一：字段名
  // 参数二：like 模糊
  // 参数三：查询的内容
  .where("name", "like", "%张%")
  .then((res) => {
    console.log(res);
  });

knex(表名)
  .delete()
  .where({})
  .then((res) => {});

// 示例代码1

// 删除
knex("hero")
  .delete()
  .where({
    name: "张向阳",
  })
  .then((res) => {
    // 删除语句 返回的是 受影响的行数
    console.log(res);
  });

// 示例代码2
// 模糊删除
knex("hero")
  .delete()
  // 一般跟上条件 否则  会删除掉所有  很严重的哦！
  .where("name", "like", "%张%") //name字段内容为长得所有数据
  .then((res) => {
    // 删除语句 返回的是 受影响的行数
    console.log(res);
  });

knex(表名)
  .update({})
  .where({})
  .then((res) => {});

// 示例代码

// 修改
// hero是表名
knex("hero")
  .update({
    title: "职业教育的学生",
  })
  .where({
    name: "赵姐姐",
  })
  .then((res) => {
    console.log(res);
  });

.orWhere() //or连接   （或）
.andWhere() //and连接	 （与）

// 示例代码

// 查询name为 张飞 或者 name为 韩信 的数据
knex("hero")
  .select()
  .where({ name: "张飞" })
  .orWhere({
    name: "韩信",
  })
  .then((data) => {
    console.log(data);
  });
// 查询name为 李白 或者 title为 六合虎拳 的数据
knex("hero")
  .select()
  .where({ name: "李白" })
  .andWhere({
    title: "六合虎拳",
  })
  .then((data) => {
    console.log(data);
  });

// 1.导入用于生成 JWT 字符串的包
const jwt = require("jsonwebtoken");
// 2.导入用于将客户端发送过来的 JWT 字符串，解析还原成 JSON 对象的包
const express_jwt = require("express-jwt");

// 3. secret 密钥的本质： 就是一个字符串
const secretKey = "xiangyang Love you ~_~";

app.post("/api/login", (req, res) => {
  let { username, password } = req.body;
  // 登录失败
  if (username !== "admin" && password !== "123456") {
    return res.send({
      status: 400,
      msg: "登录失败!",
    });
  }
  // 登录成功
  // 在登录成功后，调用 jwt.sign() 方法生成 JWT 字符串。并通过 token 属性发送给客户端
  // 参数1：用户信息对象
  // 参数2：加密的秘钥
  // 参数3：配置对象，可以配置当前 token 的有效期
  const tokenStr = jwt.sign({ username: username }, secretKey, {
    expiresIn: "30s",
  });
  res.send({
    status: 200,
    msg: "登录成功!",
    token: tokenStr, // 要发送给客户端的 token 字符串
  });
});

//4.注册将 JWT 字符串解析还原成 JSON 对象的中间件(unless里都只是不需要访问权限的)
app.use(expressJwt({ secret: secretKey }).unless({ path: [/^\/api\//] }));

// 这是一个有权限的 API 接口
app.get("/admin/getinfo", (req, res) => {
  // 5. 使用 req.user 获取用户信息，并使用 data 属性将用户信息发送给客户端
  console.log(req.user);
  res.send({
    status: 200,
    mag: "获取用户信息成功！",
    data: req.user,
  });
});

// 6.使用全局错误处理中间件，捕获解析 JWT 失败后产生的错误
app.use((err, req, res, next) => {
  // 这次错误是由 token 解析失败导致的
  if (err.name === "UnauthorizedError") {
    return res.send({
      status: 401,
      msg: "无效的token",
    });
  }
  res,
    send({
      status: 500,
      msg: "未知的错误",
    });
});

/*
	os.hostname()
		以字符串的形式返回操作系统的主机名.
	os.networkInterfaces()
		返回一个对象,包含只有被赋予网络地址的网络接口.
	例如：可以接收到访问这个url电脑的ip地址 (address: '172.16.10.188')
	在第一个数组中的第二个对象的address就是ip地址

*/

const express = require("express");

const app = express();
const cors = require("cors");
app.use(cors());

//导入模块 并且连接上 本机的数据库
const knex = require("knex")({
  // 操纵的数据库客户端
  client: "mysql",
  // 数据库连接
  connection: {
    // 地址
    host: "427bd91db99f.c.methodot.com",
    // 端口号
    port: "34337",
    // 用户名
    user: "root",
    // 密码
    password: "自己知道就行（数据库密码(注册账号的时候设置的)）",
    // 库名
    database: "xiangyang",
  },
});

app.get("/user", (req, res) => {
  knex("user") // user：库名里的表名
    .select()
    .then((data) => {
      res.send({
        code: "000000",
        message: "获取数据成功!",
        data,
      });
    });
});

app.listen(3030, () => {
  console.log("express server at running http://127.0.0.1:3030");
});