关于前端:设计用户模块的schema

在计算机科学中，schema 通常指的是 数据结构的 定义 和束缚。

关系型数据库

在关系型数据库中，schema 指的是数据库中所有表格的定义和表格之间的关系束缚，包含每个表格的列名、数据类型、主键、外键等等。

如果要对一个关系型数据库进行查问或批改操作，就必须先定义好相应的 schema。

NoSQL 数据库

在 NoSQL 数据库中，schema 的概念略有不同。

NoSQL 数据库通常分为:

文档型数据库、
键 - 值型数据库、
列族存储型数据库
图形数据库等几种类型

在这些数据库中，schema 能够了解为数据模型的定义。

与关系型数据库相比，NoSQL 数据库更加灵便，容许存储非结构化或半结构化数据，因而其 schema 通常也比拟宽松。

例如，在 MongoDB 中，用于定义模型的工具 Mongoose 提供了对数据模型的定义和束缚，包含汇合（相似于关系型数据库的表）和文档的字段、数据类型、索引等方面的束缚。

MongoDB 是一种非关系型数据库，它没有传统意义上的“schema”概念。

相比于关系型数据库中须要在创立表时定义固定的列（字段）和数据类型，MongoDB 存储的文档能够蕴含各种不同构造的数据，每个文档的字段也能够动静增加或删除。

而在应用 MongoDB 时，咱们通常须要确保应用程序对文档中所需数据存在一些独特的约定，比方应用雷同的字段名、数据类型等，以便于应用程序可能正确地解析和应用这些数据。

这些约定能够称之为 “模型”，这也是在 MongoDB 中最靠近于“schema”的概念。

在 MongoDB 中通常会应用 Mongoose 这样的工具来定义数据模型，其中包含对于汇合（相似于关系型数据库的表）和文档的字段、数据类型、索引等方面的束缚。

然而这些束缚是可选的，同时也能够在运行时进行批改。

因而，MongoDB 更加灵便，实用于须要频繁变动的数据结构或者不确定的数据模型场景。

更多精彩内容，请 微信搜寻“前端爱好者 “， 戳我查看。

下面说过在 MongoDB 中，模型是由 Schema 对象 定义的数据结构。 那么 Schema 到底是什么？

Schema 是一个 JavaScript 对象，定义了文档中字段的类型、验证规定、默认值等属性。

通过定义 Schema，能够为文档指定一组预约义的属性和办法，使文档更加结构化和牢靠。

在创立模型时，咱们须要将定义好的 Schema 作为参数传入 Mongoose 的 model() 办法中，以便 Mongoose 将其编译为模型。

模型能够被视为与数据库交互的对象，能够用来执行 CRUD 操作，查问文档，更新文档等操作。

在应用 MongoDB 和 Mongoose 进行开发时，定义模型并应用它们来操作数据是十分常见的操作。

通常状况下，咱们会依据理论需要定义多个不同的模型，每个模型对应一种数据类型，以便更好地组织和治理数据。

用户模块是指在程序中负责 治理用户信息 和权限 的模块。

该模块通常包含以下性能：

用户注册和登录：容许用户通过输出用户名和明码等信息注册新用户，或应用已有账号进行登录。
用户 信息管理：能够编辑和查看用户信息，例如昵称、邮箱、头像等。
权限治理：对于不同的用户角色，能够管制其所能拜访的页面、性能，以及具体的操作权限。
安全性 治理：爱护用户数据安全，包含避免 SQL 注入、XSS 攻打等攻击方式，并对用户明码等敏感信息进行加密存储。
第三方登录：反对用户通过第三方平台（如微信、QQ、微博）进行快捷登录，并绑定相应账号。
记住明码 和主动登录：能够让用户在下次登录时主动填写用户名和明码，进步用户体验。

在实现用户模块时，须要先设计数据库表构造，包含用户信息表、角色表、权限表、登录日志表等，并依据业务需要实现相应的 API 接口和前端页面。

同时，须要思考到用户数据的安全性和隐衷爱护，例如对明码进行加密存储，采纳 HTTPS 协定传输数据等措施。

上面仅说一下用户信息表的 schema。

开始之前，先介绍 mongoose 创立 schema 中用到的几个 api。

mongoose.Schema()

mongoose.Schema()是 Mongoose 中用于定义 MongoDB 文档构造的构造函数。

通过它，能够创立一个新的 Schema 对象，用于束缚 MongoDB 汇合中文档的构造和属性。

在定义 Schema 时，能够应用各种类型的数据，包含:

字符串
数字
日期等根本类型
嵌套其余 Schema 对象或者数组，
增加虚构属性等。

此外，还能够为每个字段 配置默认值 、 验证规定 、索引等属性，以及自定义实例办法和静态方法。

mongoose.model()

mongoose.model()是 Mongoose 中用于创立数据模型的办法。

数据模型是用来定义 MongoDB 汇合（相似于关系型数据库中的表）中文档构造、字段类型、默认值、验证规定等的约束条件。

应用 mongoose.model()办法，能够将一个 JavaScript 对象转换为 Mongoose 的数据模型。

该办法承受两个参数：

第一个参数为模型名称（对应 MongoDB 汇合名称），
第二个参数为模型定义对象。

其中，模型定义对象通常包含以下属性：

字段名：每个字段都能够指定其类型、默认值、验证规定、索引等属性。
静态方法：在数据模型上定义静态方法，可通过模型名称调用。
实例办法：在数据模型原型上定义实例办法，在每个文档对象上都能够调用。
虚构属性：在文档对象中定义虚构属性，它们不会被存储到数据库中，而是由其余字段计算得出。

第一步：在我的项目根目录新建 models 文件夹用于存储 models 文件

第二步：在 models 文件夹内新建用户模块的 schema — users.js

须要进行上面步骤：

导入 mongoose — let mongoose = require('mongoose')
实例化 Schema — let schema = new mongoose.Schema()
创立模型对象 — let Users = mongoose.model('users', schema) — 第一个参数为模型名称（对应 MongoDB 汇合名称, 第二个参数为模型定义对象(规定)
导出模型对象 — module.exports = Users

全副代码

//  导入 mongoose 
let mongoose = require('mongoose')

// 实例化 Schema
const userSchema = new mongoose.Schema({
    username: String,
    pwd: String
})

// 创立模型对象
const User = mongoose.model('users', userSchema)

// 导出模型对象
module.exports = Users

第三步：在路由中应用用户模块的 schema — users.js

var router = require('koa-router')();

const Users = require('../models/users') // 引入 users modal 

router.prefix('/users');

// 增加零碎用户 
router.post('/add', async (ctx) => {let { username, pwd} = ctx.request.body
  await Users.create({username, pwd}).then(rel => {if (rel) {
      ctx.body = {
        code: 200,
        msg: '增加胜利',
        data: rel
      }
    } else {
      ctx.body = {
        code: 300,
        msg: '增加失败'
      }
    }

  }).catch(err => {
    ctx.body = {
      code: 400,
      msg: '增加时出现异常'
    }
    console.error(err)
  })

})

module.exports = router;

在下面的示例代码中，在路由文件 users 中应用const Users = require('../models/users') , 引入 users modal。

在 增加零碎用户 调用应用 users modal 模块。

实例一

// userSchema
const mongoose = require('mongoose');

// 创立用户 Schema
const userSchema = new mongoose.Schema({
    username: {
        type: String,
        required: true, // 必填项
        unique: true,   // 惟一索引
        lowercase: true // 存入数据库前将其转换为小写
    },
    password: {
        type: String,
        required: true,
        select: false    // 查问时不返回该字段
    },
    email: {
        type: String,
        required: true,
        match: /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/,
        unique: true
    },
    age: {
        type: Number,
        min: 18,         // 最小值
        max: 60          // 最大值
    },
    created: {
      type: Date,
      default: Date.now
    },
    friends: [{
      type: mongoose.Schema.Types.ObjectId,
      ref: 'User'
    }]
});

// 创立虚构属性
userSchema.virtual('fullName').get(function() {return this.firstName + ' ' + this.lastName;});

// 创立实例办法
userSchema.methods.sayHello = function() {console.log(`Hello, ${this.username}!`);
}

// 创立静态方法
userSchema.statics.findByUsername = function(username, callback) {return this.findOne({ username: username}, callback);
}

// 导出用户 Schema
module.exports = userSchema;

在下面的示例代码中，首先创立了一个用户 Schema 对象，并为其定义了 username、password、email、age、created 和 friends 属性。

每个属性都有其特定的类型和属性，如数据类型、是否必填、最大值最小值、正则表达式等。

而后，通过 virtual 办法创立一个 fullName 虚构属性，以及 methods 办法创立一个 sayHello 实例办法，statics 办法创立一个 findByUsername 静态方法。

最初，将该 Schema 对象导出供其余文件应用。

应用 Schema 对象创立 mongoose 数据模型时，须要在第二个参数传入该 Schema 对象，如下所示：

// models/user
const mongoose = require('mongoose');
const userSchema = require('./userSchema');

const User = mongoose.model('User', userSchema);

module.exports = User;

这样，在其余文件中援用此模型即可，如下所示：

const User = require('./models/user');

const user = new User({
  username: 'admin',
  password: '123456',
  email: 'admin@admin.com',
  age: 27
});

user.save(function(err, doc) {if (err) {console.error(err);
  } else {console.log(doc);
  }
});

实例二

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

// 创立用户数据模型
const UserSchema = new Schema({name: { type: String, required: true},
  age: {type: Number, default: 18},
  email: {type: String, required: true},
  password: {type: String, required: true},
  createdAt: {type: Date, default: Date.now}
});

// 创立模型并导出
module.exports = mongoose.model('User', UserSchema);

上述代码中，首先应用 mongoose.Schema()办法定义了一个用户数据模型的构造，并将其存储在 UserSchema 中。

而后应用 mongoose.model()办法，将 UserSchema 转换为一个名为“User”的 model 对象，并导出该对象。

这样，在其余的文件中就能够通过 require()办法来援用该 model 对象，并进行 MongoDB 数据库的操作了。

例如：

const mongoose = require('mongoose');
const User = require('./models/user');

mongoose.connect('mongodb://localhost/test');
const db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {console.log('Connected to MongoDB');

  // 创立一个新用户
  const user = new User({
    name: 'Alice',
    age: 20,
    email: 'alice@example.com',
    password: '123456'
  });

  // 将新用户保留到汇合中
  user.save(function(err, doc) {if (err) return console.error(err);
    console.log(doc);
  });
});

在上述示例代码中，首先应用 mongoose.connect()办法连贯了 MongoDB 数据库，而后应用 require()办法引入了之前定义的 User 模型。

接着创立了一个新用户对象，并调用 save()办法将其保留到数据库中。

正则表达式是一个用于匹配文本的模式，能够应用特定的语法规定来示意各种匹配模式。

在 JavaScript 中，能够应用 RegExp 对象 来创立和操作正则表达式。

正则表达式能够用于各种字符串解决工作，例如搜寻、替换、验证等。

上面是一些根本的正则表达式概念：

字符集：用于匹配一组字符中的任何一个字符。例如，[abc]能够匹配 a、b 或 c，还能够应用范畴表示法 [a-z]、¹ 示意不匹配 a、b 和 c。
元字符：用于示意特殊字符或者非凡的用处。一些常见的元字符包含.、*、+、?、\、|、^、$、(、)等。
量词：用于指定匹配次数。例如，? 示意零次或一次，* 示意零次或屡次，+ 示意一次或屡次，{n}示意恰好匹配 n 次，{n,m}示意匹配 n 到 m 次。
边界匹配符：用于匹配字符串的边界，例如 ^ 示意匹配字符串的结尾，$ 示意匹配字符串的结尾。

上面是一些示例正则表达式及其含意：

/a/：匹配字符串中第一个呈现的字符 a。
/abc/：匹配字符串中间断呈现的字符串 abc。
/\d/：匹配一个数字字符。
/\w/：匹配一个字母、数字或下划线字符。
/^[a-z]+$/：匹配只蕴含小写字母的字符串。
/^\d{3}\-\d{3}\-\d{4}$/：匹配电话号码格局，例如 123-456-7890。

在 JavaScript 中，能够应用 RegExp 对象的构造函数或者字面量语法来创立正则表达式。

例如：

// 通过 RegExp 构造函数创立正则表达式
const pattern1 = new RegExp('ab+c');

// 通过字面量语法创立正则表达式
const pattern2 = /ab+c/;

而后能够应用正则表达式的各种办法，如 test()、exec()等，进行文本匹配和替换操作，

const str = 'Hello, world!';
const pattern = /world/;
console.log(pattern.test(str)); // true
console.log(str.replace(pattern, 'JavaScript')); // Hello, JavaScript!

例如：

const str = 'Hello, world!';
const pattern = /world/;
console.log(pattern.test(str)); // true
console.log(str.replace(pattern, 'JavaScript')); // Hello, JavaScript!

正则表达式是一种弱小的工具，用于解决各种文本匹配、替换、验证等工作。在 JavaScript 中，能够应用 RegExp 对象进行正则表达式操作。

参考文档

abc ↩

关于前端:设计用户模块的schema

schema

MongoDB 中 schema（“模型”)

设计用户模块的 schema

用户模块

设计用户模块的 schema

其余简单实例

每日一课：正则表达式

Just My Socks（注册教程内含优惠码）

关于前端:设计用户模块的schema

schema

MongoDB 中 schema（“模型”)

设计用户模块的 schema

用户模块

设计用户模块的 schema

其余简单实例

每日一课：正则表达式

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）