node.js 入门级基础应用

概要

1. Node.js基础类型
   • Number（数字类型）
     • 在Node.js中，Number类型用于表示数字，可以是整数或浮点数。例如：

let integerNumber = 5;
let floatingPointNumber = 3.14;

• Number类型有许多内置的方法，如toFixed()用于将数字转换为指定小数位数的字符串。例如：

let num = 3.14159;
console.log(num.toFixed(2));//输出3.14

• String（字符串类型）
  • 字符串是用于存储文本数据的类型。可以使用单引号或双引号来定义字符串。例如：

let str1 = 'Hello';
let str2 = "World";

• 字符串有很多操作方法。比如concat()方法用于连接字符串，substring()方法用于提取子字符串。例如：

let str3 = str1.concat(' ', str2);
console.log(str3); //输出Hello World
let subStr = str3.substring(0, 5);
console.log(subStr); //输出Hello

• Boolean（布尔类型）
  • Boolean类型只有两个值：true和false。它通常用于条件判断。例如：

let isTrue = true;
let isFalse = false;
if (isTrue) {
    console.log('This is true');
}

• Object（对象类型）
• 对象是一种复杂的数据类型，它可以包含多个属性和方法。属性是键 - 值对的形式。例如：

let person = {
    name: 'John',
    age: 30,
    sayHello: function() {
        console.log(`Hello, my name is ${this.name}`);
    }
};
console.log(person.name);
person.sayHello();

• 可以通过点语法（如person.name）或方括号语法（如person['name']）来访问对象的属性。
  • Array（数组类型）
    • 数组用于存储一组有序的数据。例如：

let fruits = ['apple', 'banana', 'cherry'];
console.log(fruits[0]); //输出apple
fruits.push('date');
console.log(fruits); //输出["apple", "banana", "cherry", "date"]

• 数组有许多实用的方法，如push()用于添加元素，pop()用于删除最后一个元素，map()用于对数组中的每个元素进行映射操作等。
  • Function（函数类型）
• 函数是一段可重复使用的代码块。例如：

function add(a, b) {
    return a + b;
}
console.log(add(2, 3)); //输出5

• 函数还可以作为参数传递给其他函数或者作为返回值返回，这是函数式编程的重要特性。
  • null和undefined
    • null表示一个空值，通常用于表示一个对象不存在。undefined表示一个变量已经声明但未赋值。例如：

let emptyObject = null;
let unassignedVariable;
console.log(emptyObject);
console.log(unassignedVariable);

2. Node.js框架介绍
   • Express.js
     • 概述：Express是一个简洁而灵活的Node.js Web应用框架，它基于Node.js的http模块构建，提供了一种简单而有效的方式来构建Web应用程序和API。
     • 特点：
       • 路由系统：Express具有强大的路由系统，可以方便地定义不同URL路径对应的处理函数。例如：

const express = require('express');
const app = express();
app.get('/', function(req, res) {
    res.send('Hello, World!');
});

• 中间件支持：中间件是Express的核心概念之一。中间件函数可以在请求处理过程中执行一些额外的操作，如日志记录、请求验证等。例如，使用morgan中间件进行日志记录：

const morgan = require('morgan');
app.use(morgan('dev'));

• 模板引擎集成：它可以方便地与各种模板引擎（如EJS、Pug等）集成，用于生成动态HTML页面。例如，使用EJS模板引擎：

app.set('view engine', 'ejs');
app.get('/user', function(req, res) {
    res.render('user', {name: 'John'});
});

• Koa.js
  • 概述：Koa是由Express团队打造的一个新的Web框架，它的设计理念是更加精简和优雅，基于ES6的async/await语法，使异步代码编写更加容易。
  • 特点：
    • 异步流程控制：Koa大量使用async/await，使得异步操作的代码看起来像同步代码，提高了代码的可读性和可维护性。例如：

const Koa = require('koa');
const app = new Koa();
app.use(async (ctx, next) => {
    await next();
    console.log('After next');
});
app.use(async ctx => {
    ctx.body = 'Hello, Koa!';
});

• 洋葱模型中间件：Koa的中间件采用洋葱模型，请求进入时，依次经过多个中间件，在中间件内部可以执行异步操作，最后响应时再按照相反的顺序经过这些中间件。这种模型可以方便地对请求和响应进行处理。
  • Nest.js
    • 概述：Nest是一个用于构建高效、可扩展的Node.js服务器端应用程序的框架。它基于Express，但增加了更多的面向对象编程（OOP）和函数式编程（FP）的概念。
    • 特点：
      • 模块化和依赖注入：Nest采用模块化的架构，通过依赖注入（DI）来管理组件之间的关系。例如，创建一个简单的模块：

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
@Module({
    controllers: [CatsController],
    providers: [CatsService],
})
export class CatsModule {}

• 支持多种类型的应用：Nest可以用于构建RESTful API、GraphQL API、微服务等多种类型的应用，并且提供了很好的工具和架构来支持这些应用的开发。

node.js koa 框架应用实例

以下是一个使用Koa框架简单实现与数据库（以MySQL为例）连接，并进行接口增删改查操作的示例代码，整体示例包含以下几个部分：

1. 项目初始化与依赖安装

首先创建一个项目文件夹，在命令行进入该文件夹后执行以下命令初始化项目并安装所需依赖：

npm init -y
npm install koa koa-router mysql2

koa是我们使用的Web框架，koa-router用于定义路由来处理不同的接口请求，mysql2则用于连接和操作MySQL数据库。

2. 数据库连接配置（创建 db.js 文件）

const mysql = require('mysql2/promise');

// 数据库配置信息，根据实际情况修改
const dbConfig = {
    host: 'localhost',
    user: 'your_username',
    password: 'your_password',
    database: 'your_database_name'
};

// 创建数据库连接池
const pool = mysql.createPool(dbConfig);

module.exports = pool;

这里配置了连接MySQL数据库的基本信息，如主机地址、用户名、密码和数据库名等，并创建了一个连接池，后续通过连接池来获取数据库连接进行操作，这样可以更高效地管理数据库连接资源。

3. 创建Koa应用及路由（创建 app.js 文件）

const Koa = require('koa');
const Router = require('koa-router');
const pool = require('./db.js');

const app = new Koa();
const router = new Router();

// 新增数据接口
router.post('/create', async (ctx) => {
    const { name, age } = ctx.request.body;
    try {
        const connection = await pool.getConnection();
        const query = 'INSERT INTO users (name, age) VALUES (?,?)';
        const [result] = await connection.execute(query, [name, age]);
        connection.release();
        ctx.body = { success: true, message: '数据插入成功', 
        insertedId: result.insertId };
    } catch (error) {
        ctx.body = { success: false, message: '数据插入失败', error: error.message };
    }
});

// 查询数据接口
router.get('/read', async (ctx) => {
    try {
        const connection = await pool.getConnection();
        const query = 'SELECT * FROM users';
        const [rows] = await connection.execute(query);
        connection.release();
        ctx.body = { success: true, data: rows };
    } catch (error) {
        ctx.body = { success: false, message: '查询数据失败', 
        error: error.message };
    }
});

// 更新数据接口
router.put('/update', async (ctx) => {
    const { id, name, age } = ctx.request.body;
    try {
        const connection = await pool.getConnection();
        const query = 'UPDATE users SET name =?, age =? WHERE id =?';
        const [result] = await connection.execute(query, [name, age, id]);
        connection.release();
        ctx.body = { success: true, message: '数据更新成功', 
        affectedRows: result.affectedRows };
    } catch (error) {
        ctx.body = { success: false, message: '数据更新失败', 
        error: error.message };
    }
});

// 删除数据接口
router.delete('/delete', async (ctx) => {
    const { id } = ctx.request.body;
    try {
        const connection = await pool.getConnection();
        const query = 'DELETE FROM users WHERE id =?';
        const [result] = await connection.execute(query, [id]);
        connection.release();
        ctx.body = { success: true, message: '数据删除成功',
         affectedRows: result.affectedRows };
    } catch (error) {
        ctx.body = { success: false, message: '数据删除失败',
         error: error.message };
    }
});

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

以下是对上述代码的详细说明：

• 新增数据接口（/create）：

  • 从请求体 ctx.request.body 中获取要插入的数据（这里假设是 name 和 age）。
  • 通过连接池获取数据库连接，执行 INSERT 语句将数据插入到名为 users 的表中（表结构需要提前创建好，包含 id（一般为自增主键）、name 和 age 等字段）。
  • 根据插入操作的结果返回相应的响应信息给客户端，包含操作是否成功以及插入数据后的自增 id 值等。

• 查询数据接口（/read）：

  • 获取数据库连接后，执行 SELECT 语句查询 users 表中的所有数据。
  • 将查询到的数据以合适的格式返回给客户端，如果查询过程出现错误则返回错误信息。

• 更新数据接口（/update）：

  • 从请求体中获取要更新的数据（id 用于定位要更新的记录，以及新的 name 和 age 值）。
  • 执行 UPDATE 语句对数据库中对应 id 的记录进行更新操作，并返回更新操作影响的行数等相关信息给客户端。

• 删除数据接口（/delete）：

  • 从请求体获取要删除数据的 id 值。
  • 执行 DELETE 语句删除数据库中对应 id 的记录，然后向客户端反馈删除操作的结果，比如是否成功以及影响的行数等情况。

最后，启动Koa应用监听在 3000 端口，这样就可以通过相应的接口来对数据库中的数据进行增删改查操作了。

请注意，上述代码中的数据库表结构、字段等都是示例性质的，你需要根据实际的业务需求和数据库设计来进行调整和完善，同时还可以进一步添加诸如输入数据验证、错误处理优化等功能来增强应用的健壮性。

MySQL 数据库基础知识 以及 连接应用

1. MySQL数据库基础知识
   • 数据库和表的概念
     • 数据库（Database）：是一个存储数据的仓库，它可以包含多个表、视图、存储过程等对象。例如，你可以创建一个名为mydb的数据库来存储公司员工信息、产品信息等相关数据集合。
     • 表（Table）：是数据库中最基本的存储单元，用于存储具有相同结构的数据。例如，在员工信息数据库中，可以有一个名为employees的表，用于存储员工的姓名、年龄、职位等信息。表由行（Row）和列（Column）组成，每行代表一条记录，每列代表记录中的一个属性。
   • 数据类型
     • 数值类型：
       • INT（整数型）：用于存储整数，如员工的年龄、产品的数量等。例如，age INT可以定义一个存储年龄的列。
       • DECIMAL（小数型）：用于存储精确的小数，如商品的价格。它可以指定精度和标度，例如price DECIMAL(10,2)表示可以存储最多10位数字，其中小数点后有2位数字的小数。
     • 字符串类型：
       • VARCHAR（可变长字符串）：用于存储长度可变的字符串，如员工的姓名、地址等。例如name VARCHAR(50)表示可以存储最长为50个字符的姓名。
       • TEXT（文本类型）：用于存储较长的文本内容，如产品的详细描述。
     • 日期和时间类型：
       • DATE（日期型）：存储日期，格式为YYYY - MM - DD，如员工的入职日期。
       • DATETIME（日期时间型）：存储日期和时间，格式为YYYY - MM - DD HH:MM:SS，如订单的创建时间。
   • SQL基本操作语句
     • 创建数据库（CREATE DATABASE）：

CREATE DATABASE mydb;

• 创建表（CREATE TABLE）：

CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50),
    age INT,
    hire_date DATE
);

• 插入数据（INSERT INTO）：

INSERT INTO employees (name, age, hire_date) 
VALUES ('John Doe', 30, '2024-01-01');

• 查询数据（SELECT）：

SELECT * FROM employees;
SELECT name, age FROM employees WHERE age > 25;

• 更新数据（UPDATE）：

UPDATE employees SET age = 31 WHERE name = 'John Doe';

• 删除数据（DELETE）：

DELETE FROM employees WHERE id = 1;

2. MySQL连接应用
   • 使用Node.js连接MySQL（以mysql2库为例）
     • 安装依赖：在Node.js项目目录下，通过命令npm install mysql2安装mysql2库。
     • 连接数据库代码示例（创建db.js文件）：

const mysql = require('mysql2/promise');
// 配置数据库连接信息
const connectionConfig = {
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'mydb'
};
// 建立连接
const connect = async () => {
    try {
        const connection = await mysql.createConnection(connectionConfig);
        console.log('数据库连接成功');
        return connection;
    } catch (error) {
        console.error('数据库连接失败:', error);
        throw error;
    }
};
module.exports = {
    connect
};

• 执行查询操作（在app.js文件中）：

const { connect } = require('./db.js');
const express = require('express');
const app = express();
app.get('/employees', async (req, res) => {
    try {
        const connection = await connect();
        const [rows] = await connection.execute('SELECT * FROM employees');
        res.json(rows);
    } catch (error) {
        res.status(500).json({ error: '查询数据失败' });
    }
});
app.listen(3000, () => {
    console.log('服务器运行在3000端口');
});

nodejs 的作用

1. 构建Web服务器
   • 作用：Node.js可以用于创建高性能的Web服务器，能够高效地处理大量并发请求。它基于事件驱动和非阻塞I/O模型，使得服务器在处理多个请求时不会因为某个请求的I/O操作（如读取文件、数据库查询等）而阻塞，从而提高了服务器的响应速度和吞吐量。
   • 应用实例：
     • 使用Express.js框架创建一个简单的Web服务器。首先安装Express：npm install express。然后创建一个server.js文件，内容如下：

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.send('Hello, World!');
});

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

• 这个服务器监听在3000端口，当用户访问根路径/时，返回Hello, World!。通过Express的路由机制，可以轻松地定义不同路径对应的响应内容，并且可以添加中间件来处理请求，如日志记录、请求体解析等。

2. 命令行工具开发
   • 作用：Node.js可以用于创建命令行工具，方便开发者自动化各种任务，如代码格式化、项目构建、文件处理等。通过在package.json文件中定义命令脚本，可以让用户在命令行中执行自定义的Node.js程序。
   • 应用实例：
     • 创建一个简单的命令行工具来统计文件中的行数。首先创建一个lineCounter.js文件，内容如下：

const fs = require('fs');
const path = require('path');

const fileToRead = process.argv[2];
if (!fileToRead) {
    console.error('请指定要统计行数的文件');
    process.exit(1);
}

const fullPath = path.resolve(fileToRead);
fs.readFile(fullPath, 'utf8', (err, data) => {
    if (err) {
        console.error('读取文件出错:', err);
        process.exit(1);
    }
    const lines = data.split('\n').length;
    console.log(`文件 ${fileToRead} 中的行数为: ${lines}`);
});

• 然后在package.json文件的scripts部分添加一个命令：

{
    "name": "line-counter",
    "version": "1.0.0",
    "description": "统计文件行数的命令行工具",
    "scripts": {
        "count-lines": "node lineCounter.js"
    },
    "author": "Your Name",
    "license": "MIT"
}

• 现在可以在命令行中使用npm run count - lines [文件名]来统计指定文件的行数。

3. 实时应用开发（如聊天应用、实时数据更新）
   • 作用：Node.js的事件驱动和异步特性使其非常适合开发实时应用。它可以轻松地处理多个客户端的实时连接，通过WebSocket等协议实现服务器和客户端之间的双向实时通信。
   • 应用实例：
     • 使用Socket.io库（基于Node.js）创建一个简单的实时聊天应用。首先安装Socket.io：npm install socket.io。然后创建一个chatServer.js文件，内容如下：

const express = require('express');
const app = express();
const http = require('http');
const server = http.createServer(app);
const { Server } = require('socket.io');
const io = new Server(server);

app.get('/', (req, res) => {
    res.sendFile(__dirname + '/index.html');
});

io.on('connection', (socket) => {
    console.log('有新用户连接');
    socket.on('chat message', (msg) => {
        console.log('收到消息:', msg);
        io.emit('chat message', msg);
    });
    socket.on('disconnect', () => {
        console.log('用户断开连接');
    });
});

const port = 3000;
server.listen(port, () => {
    console.log(`聊天服务器运行在端口 ${port}`);
});

• 同时创建一个简单的HTML文件index.html作为客户端界面，内容如下：

<!DOCTYPE html>
<html>

<head>
    <title>实时聊天应用</title>
    <style>
        #messages {
            list-style-type: none;
            margin: 0;
            padding: 0;
        }
    </style>
</head>

<body>
    <ul id="messages"></ul>
    <form id="chat-form">
        <input id="m" autocomplete="off" /><button>发送</button>
    </form>
    <script src="/socket.io/socket.io.js"></script>
    <script>
        var socket = io();
        var form = document.getElementById('chat-form');
        var input = document.getElementById('m');
        var messages = document.getElementById('messages');
        form.addEventListener('submit', function (e) {
            e.preventDefault();
            if (input.value) {
                socket.emit('chat message', input.value);
                input.value = '';
            }
        });
        socket.on('chat message', function (msg) {
            var item = document.createElement('li');
            item.textContent = msg;
            messages.appendChild(item);
        });
    </script>
</body>

</html>

• 当用户在浏览器中访问服务器地址时，可以在页面上输入消息并发送，消息会实时广播给所有连接的用户。

4. 后端服务开发（如API开发）
   • 作用：Node.js可以用于构建后端服务，为前端应用提供数据接口（API）。它可以与各种数据库（如MySQL、MongoDB等）集成，实现数据的存储、查询、更新和删除操作，并且能够方便地处理HTTP请求和响应，返回JSON格式的数据等。
   • 应用实例：
     • 以构建一个简单的用户管理API为例，使用Express.js和MongoDB（通过Mongoose库连接）。首先安装相关库：npm install express mongoose。然后创建一个userAPI.js文件，内容如下：

const express = require('express');
const mongoose = require('mongoose');
const app = express();
const port = 3000;

// 连接MongoDB
mongoose.connect('mongodb://localhost:27017/userdb', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});
const userSchema = new mongoose.Schema({
    name: String,
    age: Number
});
const User = mongoose.model('User', userSchema);

app.use(express.json());

// 创建用户
app.post('/users', async (req, res) => {
    const newUser = new User(req.body);
    try {
        const savedUser = await newUser.save();
        res.status(201).json(savedUser);
    } catch (err) {
        res.status(400).json({ error: err.message });
    }
});

// 获取所有用户
app.get('/users', async (req, res) => {
    try {
        const users = await User.find();
        res.json(users);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 获取单个用户
app.get('/users/:id', async (req, res) => {
    try {
        const user = await User.findById(req.params.id);
        if (!user) {
            res.status(404).json({ error: '用户不存在' });
        } else {
            res.json(user);
        }
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 更新用户
app.put('/users/:id', async (req, res) => {
    try {
        const updatedUser = await User.findByIdAndUpdate(req.params.id, req.body, {
            new: true
        });
        if (!updatedUser) {
            res.status(404).json({ error: '用户不存在' });
        } else {
            res.json(updatedUser);
        }
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 删除用户
app.delete('/users/:id', async (req, res) => {
    try {
        const deletedUser = await User.findByIdAndDelete(req.params.id);
        if (!deletedUser) {
            res.status(404).json({ error: '用户不存在' });
        } else {
            res.json({ message: '用户已删除' });
        }
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.listen(port, () => {
    console.log(`用户管理API服务器运行在端口 ${port}`);
});

• 这个API提供了用户的创建、读取、更新和删除（CRUD）功能。通过不同的HTTP方法（POST、GET、PUT、DELETE）和路径（/users和/users/:id）来操作User模型对应的数据库记录，返回的数据格式为JSON，方便前端应用进行数据处理。

5. 构建自动化构建工具和任务运行器
   • 作用：Node.js可以用于构建自动化构建工具，如Gulp和Grunt的替代品。它可以执行诸如文件压缩、代码编译、测试运行等任务，并且可以根据文件变化自动触发任务重新执行，提高开发效率。
   • 应用实例：
     • 创建一个简单的自动化构建工具来压缩CSS文件。首先安装相关库：npm install clean - css - cli。然后创建一个build.js文件，内容如下：

const { exec } = require('child_process');
const path = require('path');

const inputCssPath = path.resolve('styles', 'main.css');
const outputCssPath = path.resolve('dist', 'main.min.css');

exec(`cleancss -o ${outputCssPath} ${inputCssPath}`, (err, stdout, stderr) => {
    if (err) {
        console.error(`压缩CSS出错: ${err.message}`);
        return;
    }
    if (stderr) {
        console.error(`压缩CSS错误信息: ${stderr}`);
        return;
    }
    console.log(`CSS文件已成功压缩到 ${outputCssPath}`);
});

• 在package.json文件的scripts部分添加一个命令：

{
    "name": "build-css",
    "version": "1.0.0",
    "scripts": {
        "build-css": "node build.js"
    },
    "author": "Your Name",
    "license": "MIT"
}

• 当运行npm run build - css时，会将styles目录下的main.css文件压缩为dist目录下的main.min.css文件。如果结合文件系统监控库（如chokidar），还可以实现当main.css文件发生变化时自动重新压缩的功能。

原文地址：https://blog.csdn.net/m0_51244077/article/details/143808906

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！