la base de datos MongoDB para explicar
¿Por qué utilizar una base de datos?
Sitio web en Internet Hay dos categorías principales, tanto estática como dinámica y un sitio web estático en Huelga decir que el llamado sitio web dinámico es que se pueden obtener diferentes resultados en función de la solicitud correspondiente, lo que significa este, se puede sentir usted, usted sólo necesita saber el sitio web dinámico estándar actual es alejarse
¿Por qué utilizamos MongoDB? MySQL de acuerdo? Por supuesto, no hay problema. Pero! Aprendizaje MongoDB costes de aprendizaje son más bajos, ¿qué significa eso? Es decir, debido a que la interfaz de desarrollo de base de datos MongoDB es una sintaxis js, así como el formato de almacenamiento interno es JSON todo lo que particularmente fácil de usar,
MongoDB es un software para descargarlo ejemplares jóvenes de
Debe haber dos software es un software de base de datos en sí, no es un software de base de datos visuales
Baidu haga clic en Descargar para escapar! Creo que tengo no hay necesidad de enseñar cómo instalar el software,
una cosa debe tenerse en cuenta, lo que necesita saber acerca de estas dos carpetas para la solución de problemas más adelante
cómo ver su MongoDB se ha instalado correctamente? De hecho, este software se abrirá un puerto del ordenador
localhost: 27017, no hay ningún error si se visita, significa que se ha instalado correctamente el software
Fundamentos de bases de datos
- almacén de datos, base de datos de
llamada de almacenamiento de datos se refiere a una base de datos de software que proporciona servicios a múltiples sitios, cada sitio tiene su propio almacén de datos correspondiente, almacén de datos es el contenido de este sitio - Collection, Colección
colección es en un almacén, una colección de datos, puede ser entendida como una matriz js - Documento, documento
conjunto a continuación el documento, el documento es un de datos específico, un objeto es similar a js - Campo, campo de
la documentación que tiene campos que corresponden a los datos, lo que es el campo? Js equivalentes a los valores clave de la clave, por supuesto, también se puede entender como un objeto de propiedad
Un poco borrosa? No importa. Mira esta tabla a continuación, usted se sentirá más fresco
Utilizando una base de datos (a)
-
En primer lugar, abrimos nuestro software. No es necesario hacer ningún cambio, simplemente haga clic en el enlace para escapar.
-
En segundo lugar, nos fijamos en lo que está dentro del administrador de base de datos nota aquí también hay locales de configuración no se mueven! ! !
Haga clic en Crear para crear un almacén, creamos un nombre llamado API del almacén
-
Y entonces se crea un almacén, la siguiente es mi base de datos, y dentro de todas las cosas creadas aquí es muy sencilla, ya que el software proporciona una representación visual, por lo que la operación es muy fácil
-
Entonces probablemente deprimido, guau hay tantos datos de campo, charla de la ciudad, que me deja una obra de teatro? ¿Quieres comer pedo,
no importa! Usted sabe que ah perezoso, que puede importar directamente de la siguiente manera los datos existentes, prestar atención a, ah, aquí antes de software ya no uso interfaz gráfica de usuario, y cambiar el software que tomó años de desarrollo en los que había, MongoBooster,
instrucciones de uso: sólo tiene que Baidu en ello, muy fácil de usar! archivo JSON puede ser arrastrado de nuevo para completar la importación de una base de datos
Utilizar base de datos (dos)
Usted pensó que se saldría con una interfaz gráfica de usuario? ? No no no no, usted es un programador, hermano! Es necesario utilizar el código! ! !
- En una descarga Nodo NPM dependiente instalar mangosta, por lo que se puede manipular la base de datos por nodo
- En MongoDB iniciar el equipo, utilice los dos comandos. Iniciar el servicio: net start mongodb cerrar el servicio: net stop MongoDB
- Enlazar a su propio nodo de base de datos en la
sintaxis:
// 注意我们的返回的是一个promise对象
// 引入mongoose第三方模块 用来操作数据库
const mongoose = require('mongoose');
// 数据库连接
//这个是返回一个promise对象，（异步，
//这个地方没有playground也是ok的，如果没有他会自己帮我创建这个数据库
// { useNewUrlParser: true }这个参数不用管你加上就完事
mongoose.connect('mongodb://localhost/playground', { useNewUrlParser: true })
// 连接成功
.then(() => console.log('数据库连接成功'))
// 连接失败
.catch(err => console.log(err, '数据库连接失败'));
Uso de base de datos (aumento III)
Orientación: Si nuestra biblioteca no crea automáticamente una biblioteca,
Con la biblioteca, podemos crear el siguiente nivel de la biblioteca: una colección de
- La primera manera de crear
- Paso 1: Establecer un conjunto de reglas
const mongoose = require('mongoose');
//对集合设定规则
// 设定集合规则
const courseSchema = new mongoose.Schema({
name: String,
author: String,
isPublished: Boolean
});
// 创建集合并应用规则
- Paso 2: Crear una colección para obtener una colección en nombre del constructor de la colección actual, esta colección es muy importante constructor
const Course = mongoose.model('Course', courseSchema); // Course就是集合的名字。注意这里你需要给一个大写，
//返回一个构造函数，然后我们拿东西去接过来就完事
- El tercer paso es lanzar algo dentro de la base de datos
//5.注意你需要插进数据，要不然它不会创建出来
// 6.把集合实例创建出来,并且把数据传入，于是乎你就有了一个数据对象,也就是创建文档
let coures = new Course({
name: 'node教程',
author: '老李',
isPublished: true
})
// 7.调用集合对象下的方法 插入数据
coures.save()
- Todavía tenemos una manera de
// 第一个是数据库。第二个回调函数
//Course是之前的的构造函数
Course.create({name: 'JavaScript基础', author: '老李', isPublish: true}, (err, doc) => {
// 错误对象
console.log(err)
// 当前插入的文档
console.log(doc)
});
//有回调函数的时候基本上都是异步的api，Course.create()返回promise对象
Course.create({name: 'Node基础', author: '老李', isPublish: true})
.then(doc => console.log(doc))
.catch(err => console.log(err))
- Importación de datos a través de código existente
La sintaxis se basa - en la línea de comandos. Esto no es un código de comando:
mongoimport –d 数据库名称 –c 集合名称 –file 要导入的数据文件
Precaución: En general, si se va a añadir algunos sistemas de ventanas de comandos que necesita para que parezca establecer un mismo
MongoDB encontrar la base de datos del directorio de instalación, el directorio bin de la instalación en el directorio colocado en una variable de entorno.
mongoimport -d -c parque usuarios -FILE. \ user.json
Utilizar base de datos (IV suprimido)
Tenga en cuenta que el funcionamiento de todo nuestro API de datos están bajo coures constructor de colección, quiero decir: Antes de decir que los constructores conjunto, muy importante!
删除文档的语法:注意，他们都是返回promise对象，then之后都是拿到的被删除的文档，{}里卖是丢查询条件
// 删除单个
Course.findOneAndDelete({}).then(result => console.log(result))
// 删除多个 返回，一个对象ok:1表示操作成功。n:表示删除四个
User.deleteMany({}).then(result => console.log(result))
Utilizar base de datos (Cinco, modificar)
Tenga en cuenta que el funcionamiento de todo nuestro API de datos están bajo coures constructor de colección, quiero decir: Antes de decir que los constructores conjunto, muy importante!
De hecho, la operación de cambio ah es una operación de actualización
sintaxis básica:
// 更新单个
User.updateOne({查询条件}, {要修改的值}).then(result => console.log(result))
// 更新多个
User.updateMany({查询条件}, {要更改的值}).then(result => console.log(result))
demostración de combate:
// 找到要删除的文档并且删除
// 返回是否删除成功的对象
// 如果匹配了多条文档, 只会删除匹配成功的第一条文档
// User.updateOne({name: '李四'}, {age: 120, name: '李狗蛋'}).then(result => console.log(result))
// 找到要删除的文档并且删除
// 如果传递的是一个{} 表示修改所有的
User.updateMany({}, { age: 300 }).then(result => console.log(result))
Utilizar base de datos (seis cheque)
Tenga en cuenta que el funcionamiento de todo nuestro API de datos están bajo coures constructor de colección, quiero decir: Antes de decir que los constructores conjunto, muy importante!
Es aquí
const Course = mongoose.model('Course', courseSchema); // Course就是集合的名字。注意这里你需要给一个大写，
//返回一个构造函数，然后我们拿东西去接过来就完事
Mira cómo lo hacemos consulta
sintaxis:
// 根据条件查找文档（条件为空则查找所有文档）
当前的集合构造函数.find().then(result => console.log(result))
注意它的返回值：数组，如果查询的数据不存在就会返回一个空数组
+++
// 引入mongoose第三方模块 用来操作数据库
const mongoose = require('mongoose');
// 数据库连接
mongoose.connect('mongodb://localhost/playground', { useNewUrlParser: true })
// 连接成功
.then(() => console.log('数据库连接成功'))
// 连接失败
.catch(err => console.log(err, '数据库连接失败'));
// 创建集合规则
const userSchema = new mongoose.Schema({
name: String,
age: Number,
email: String,
password: String,
hobbies: [String] //这个是一个数组，数组里面是字符串
});
// 使用规则创建集合
const User = mongoose.model('User', userSchema); //返回是一个集合的构造函数
// 查询文档
// 查询用户集合中的所有文档
// User.find().then(result => console.log(result)); //find方法。返回的总是一个文档的集合（数组，需要说明的是，.then是promise对象的方法，这个返回的是程序的结果
// 通过_id字段查找文档
// User.find({ _id: '5c09f267aeb04b22f8460968' }).then(result => console.log(result))
// findOne方法返回一条文档 默认返回当前集合中的第一条文档
// User.findOne({ name: '李四' }).then(result => console.log(result))
// 查询用户集合中年龄字段大于20并且小于40的文档
// User.find({ age: { $gt: 20, $lt: 40 } }).then(result => console.log(result)) //这里有一些转意字符，你需要了解$gt = >号，$lt = <号
// 查询用户集合中hobbies字段值包含足球的文档，可以用于实现网站的搜索功能
// User.find({hobbies: {$in: ['足球']}}).then(result => console.log(result)) //$in是包含的意思
// 选择要查询的字段
// User.find().select('name email -_id').then(result => console.log(result))
// 根据年龄字段进行升序排列，可以用来实现价格的查询等等操作
// User.find().sort('age').then(result => console.log(result))
// 根据年龄字段进行降序排列
// User.find().sort('-age').then(result => console.log(result))
// 查询文档跳过前两条结果 限制显示3条结果，这个可以实现分页功能
User.find().skip(2).limit(3).then(result => console.log(result))
User.find().skip(2).limit(3).then(result => console.log(result))
skip(2)跳过前两个文档
limit(3)只想要三个
+++
总结：
// 返回的都是文档
find()是返回这个东西
[{
_id: 5c0917ed37ec9b03c07cf95f,
name: 'node.js基础',
author: 'laoli'
},{
_id: 5c09dea28acfb814980ff827,
name: 'Javascript',
author: 'laoli'
}]
findOne()返回是这个东西
{
_id: 5c0917ed37ec9b03c07cf95f,
name: 'node.js基础',
author: 'laoli'
}
verificación
Lo anterior significa? Se refiere a la fijación de normas de introducción de un campo, verificarla y ver su carácter de campo no cumple con mis reglas, si cumplen permite al usuario insertar campo
Requisitos: Por ejemplo, aquí creamos una colección de artículos
// 引入mongoose第三方模块 用来操作数据库
const mongoose = require('mongoose');
// 数据库连接
mongoose.connect('mongodb://localhost/playground', { useNewUrlParser: true })
// 连接成功
.then(() => console.log('数据库连接成功'))
// 连接失败
.catch(err => console.log(err, '数据库连接失败'));
//这里是做一些mongodb的验证，注意啊这里的规则可以是对象类型
const postSchema = new mongoose.Schema({
title: {
type: String,
// 必选字段
required: [true, '请传入文章标题'],
// 字符串的最小长度
minlength: [2, '文章长度不能小于2'],
// 字符串的最大长度
maxlength: [5, '文章长度最大不能超过5'],
// 去除字符串两边的空格
trim: true
},
age: {
type: Number,
// 数字的最小范围
min: 18,
// 数字的最大范围
max: 100
},
publishDate: {
type: Date,
// 默认值
default: Date.now //这个是会传出一个日期,这个是默认的传入的
},
category: {
type: String,
// 枚举 列举出当前字段可以拥有的值，这个是枚举，
// 所谓的枚举 就是一个一个举例验证出来
enum: {
values: ['html', 'css', 'javascript', 'node.js'],
message: '分类名称要在一定的范围内才可以'
}
},
author: {
type: String,
//我们程序员自定义的验证规则
validate: {
validator: v => { //v是形参，是当前用户插入的值
// 返回布尔值
// true 验证成功
// false 验证失败
// v 要验证的值
//短路运算
return v && v.length > 4
},
// 自定义错误信息
message: '传入的值不符合验证规则，最少是4个以上1'
}
}
});
const Post = mongoose.model('Post', postSchema);
//需求：如何一次性的把所有的不符合验证规则的错误信息都获取出来
Post.create({ title: 'aa', age: 60, category: 'java', author: 'bd' })
.then(result => console.log(result))
.catch(error => {
// 获取错误信息对象，这个获取过来的其实就是报错的信息
const err = error.errors;
// 循环错误信息对象
for (var attr in err) { //注意一下这个地方的for遍历循环的操作要点
// 将错误信息打印到控制台中
console.log(err[attr]['message']);
}
})
colección asociada - MongoDB avanzada
Esto es más difícil
requisitos: en una de datos incluye otros datos.
Existe una relación entre los diferentes conjuntos de datos en general, por ejemplo, la información del artículo y la información del usuario almacenada en diferentes colecciones, pero el artículo se publica por un usuario, artículos de toda la información a ser consultados publicados incluyen los usuarios, es necesario utilizar un conjunto de asociaciones.
ID asociado con el uso de la colección de
métodos de recogida de consultas asociadas utilizando populate
Sintaxis Especificación:
// 用户集合
const User = mongoose.model('User', new mongoose.Schema({ name: { type: String } }));
// 文章集合
const Post = mongoose.model('Post', new mongoose.Schema({
title: { type: String },
// 使用ID将文章集合和作者集合进行关联,是一个id的类型mongoose.Schema.Types.ObjectId，固定死的，第二个参数就是关联谁
author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
}));
//联合查询
Post.find()
.populate('author')
.then((err, result) => console.log(result));
Código de ejemplo:
// 引入mongoose第三方模块 用来操作数据库
const mongoose = require('mongoose');
// 数据库连接
mongoose.connect('mongodb://localhost/playground', { useNewUrlParser: true })
// 连接成功
.then(() => console.log('数据库连接成功'))
// 连接失败
.catch(err => console.log(err, '数据库连接失败'));
// 用户集合规则
const userSchema = new mongoose.Schema({
name: {
type: String,
required: true
}
});
// 文章集合规则
const postSchema = new mongoose.Schema({
title: {
type: String
},
author: {
type: mongoose.Schema.Types.ObjectId, //注意一下 mongodb的id是有一种特殊类型的，这个就是那个类型
ref: 'User' //ref就是关联的意思！指定关联另外一个集合
}
});
// 用户集合
const User = mongoose.model('User', userSchema);
// 文章集合
const Post = mongoose.model('Post', postSchema);
// 创建用户
User.create({ name: 'itheima' }).then(result => console.log(result));
// 创建文章
Post.create({ titile: '123', author: '5c0caae2c4e4081c28439791' }).then(result => console.log(result));
//查询作者
Post.find().populate('author').then(result => console.log(result))