Mongoose что это
Mongoose представляет специальную ODM-библиотеку (Object Data Modelling) для работы с MongoDB, которая позволяет сопоставлять объекты классов и документы коллекций из базы данных. Грубо говоря, Mongoose работает подобно инструментам ORM. Официальный сайт библиотеки, где можно посмотреть всю необходимую документацию: http://mongoosejs.com
Для работы с Mongoose продолжим работу с проектом из прошлых тем и вначале установим саму библиотеку с помощью команды:
npm install mongoose --save
Далее определим следующий код в файле приложения app.js :
const mongoose = require("mongoose"); const Schema = mongoose.Schema; // установка схемы const userScheme = new Schema(< name: String, age: Number >); // определяем модель User const User = mongoose.model("User", userScheme); // создаем объект модели User const user = new User(< name: "Bill", age: 41>); async function main() < // подключемся к базе данных await mongoose.connect("mongodb://127.0.0.1:27017/usersdb"); // сохраняем модель user в базу данных await user.save(); console.log("Сохранен объект", user); // отключаемся от базы данных await mongoose.disconnect(); >// запускаем подключение и взаимодействие с базой данных main().catch(console.log);
Здесь прежде всего нам надо подключить mongoose:
const mongoose = require("mongoose");
Данные, которые используются в Mongoose, описываются определенной схемой. Например, в прошлых темах мы сохраняли в базу данных объекты с двумя свойствами name и age . Поэтому описываем здесь следующую схему:
const Schema = mongoose.Schema; // установка схемы const userScheme = new Schema(< name: String, age: Number >);
Схема содержит метаданные объектов. В частности, здесь устанавливаем, какие свойства будет иметь объект и какой у них будет тип данных. То есть это схема, которая описывает объект пользователя.
Затем, используя эту схему, создаем модель пользователя:
const User = mongoose.model("User", userScheme);
Первый параметр в методе mongoose.model указывает на название модели. Mongoose затем будет автоматически искать в базе данных коллекцию, название которой соответствует названию модели во множественном числе. Например, в данном случае название модели «User». Во множественном числе в соответствии с правилами английского языка это «users». Поэтому при работе с данными модели User (добавлении, удалении, редактировании и получении объектов) mongoose будет обращаться к коллекции «users». Если такая коллекция есть в бд, то с ней будет идти взаимодействие. Если такой коллекции в базе данных нет, то она будет создана автоматически.
Второй параметр функции mongoose.model — собственно схема.
Далее мы можем создавать объекты этой модели:
const user = new User(< name: "Bill", age: 41 >);
Основная логика сосредоточена в асинхронной функции main. И чтобы работать с бд MongoDB, необходимо к ней подключиться. Для подключения у объекта mongoose вызывается метод mongoose.connect() , в который передается адрес базы данных на сервере mongo:
await mongoose.connect("mongodb://127.0.0.1:27017/usersdb");
Этот метод возвращает объект Promise, поэтому при вызове метода в асинхронном методе можно применить оператор await .
Затем у объекта вызывается метод save . Этот метод определен для всех создаваемых моделей, он сохраняет текущий объект в базу данных:
await user.save(); console.log("Сохранен объект", user);
С помощью метода mongoose.disconnect(); происходит отключение от бд.
Так как метод save возвращает promise, то есть и другая форма сохранения объекта:
await mongoose.disconnect(); >);
Запустим приложение и выполним добавление объекта:
Грабли mongoose
Mongoose — самый популярный модуль для работы с mongodb на javascript. Примеры на сайте позволяют достаточно быстро и успешно начать его использовать, однако mongoose имеет ряд неожиданных особенностей, которые могут заставить программиста начать выдирать волосы на голове. Именно об этих особенностях я и собираюсь рассказать.
1. Именование коллекций
Начну с самой безобидной и легкообнаруживаемой особенности. Вы создаете модель:
var mongoose = require('mongoose'); var User = new mongoose.Schema(< email: String, password: String, data: < birthday: < type: Date, default: Date.now >, status: < type: String, default: 'active', enum: ['active', 'unactive'] >, mix: < type: mongoose.Schema.Types.Mixed, default: <>> > >); module.exports = mongoose.model('User', User); var user = new User(); user.save(ok(function() < console.log('ok'); >)); Если теперь мы выполним в консоли mongodb команду «show collections», то увидим, что была создана коллекция users. Т.е. mongoose при создании коллекций приводит их названия к нижнему регистру и множественному числу.
2. Переопределение метода toJSON()
Пусть нам понадобилось модифицировать наш экземпляр модели, внеся в него атрибут, не описанный в модели:
User.findOne(, ok(function(user) < user.someArea = 'custom value'; console.log(user.someArea); console.log('===='); console.log(user); >)); В консоли мы увидим (вместо console.log может быть использовать res.json):
custom value ==== < __v: 0, _id: 54fc8c22c90fb7dd025eee7c, email: 'test@test.com', password: '12345', data: < mix: <>, status: 'active', birthday: Thu Mar 12 2015 23:46:06 GMT+0300 (MSK) > > Как видно, у объекта есть атрибут someArea, но при дампе в консоль он куда-то внезапно пропал. Все дело в том, что mongoose переопределяет метод toJson и все поля, не описанные в схеме модели выбрасываются. Может возникнуть ситуация, когда мы добавляем в объект атрибут и отдаем его клиенту, но до клиента атрибут ни в какую не доходит. Для того, чтобы он успешно попал на клиент, модифицировать надо не mongoose-объект. Для этих целей у экземпляров моделей есть метод toObject, который возвращает native-Object, который можно как угодно модифицировать и уж из него ничего не потеряется.
3. Сравнение _id
Может показаться, что _id имеет тип String, однако, это совсем не так. _id — объект и сравнивать идентификаторы экземпляров mongoose-моделей надо как объекты. Пример:
User.findOne(, ok(function(user1) < User.findOne(, ok(function(user2) < log(user1._id == user2._id); // false log(user1._id.equals(user2._id)); // true log(user1._id.toString() == user2._id.toString()); // true >)); >)); 4. Сохранение mixed-полей
У нас в схеме есть одно поле с типом mixed, это data.mix. Если мы его изменим, например:
User.findOne(, ok(function(user) < user.data.mix = ; user.save(ok(function() < console.log('ok'); >)); >)); , то изменения успешно попадут в БД.
Однако, если теперь мы выполним изменение внутри data.mix, то изменения в БД не попадут.
User.findOne(, ok(function(user) < user.data.mix.msg = 'Good bye'; user.save(ok(function() < log(user); >)); >)); В консоль выведется объект user, содержащий наши модификацию, а запрос к БД покажет, что пользователь не был изменен. Для того, чтобы изменения попали в БД, нужно перед методом save оповестить mongoose о том, что мы модифицировали mixed-поле:
user.markModified('data.mix'); Эту же операцию необходимо производить и с объектами типа Date при их модификации встроенными методами (setMonth, setDate, . ), об этом сказано в документации
5. Дефолты для массивов
Пусть при описании схемы модели мы решили, что у нас в поле должен лежать массив объектов. Нам необходимо прописать дефолты для самого массива и для всех вложенных в него объектов. В mongoose для этого используется специальный ключ type:
var Lib = new mongoose.Schema(< userId: mongoose.Schema.ObjectId, images: < // правила валидации и дефолты для каждого из полей объекта массива images type: [< uploaded: < type: Date, default: Date.now >, src: String >], // значение по-умолчанию для поля images default: [] > >); module.exports = mongoose.model('Lib', Lib); Аналогично с помощью ключевого слова type мы можем создавать многоуровневые дефолты для объектов.
6. Потоковое обновление
Иногда необходимо выполнить обновление очень большой коллекции из кода. Загружать всю коллекцию — не хватит памяти. Можно вручную выставлять лимиты, загружать документы пачками и обновлять, но в mongoose есть очень удобные для этой операции интерфейсы — stream-ы.
e.m.users.find(<>).stream() .on('data', function(user) < var me = this; me.pause(); // выполняем надо пользователем очень хитрые асинронные манипуляции user.save(function(err) < me.resume(err); >); >) .on('error', function(err) < log(err); >) .on('close', function() < log('All done'); >); (Однако, если мы будем извлекать пользователей пачками, редактировать и сохранять через async.parallel, это будет отрабатывать немного быстрее, но менее читабельным).
7. Отключение автоматического построения индексов
Для обеспечения уникальности полей в mongodb используются уникальные индексы. С помощью mongoose их очень легко создавать. Mongoose вообще создает высокий уровень абстракции при работе с данными. Однако, наши недостатки являются продолжениями наших достоинств и многие забывают отключать в production-режиме автоматическое создание индексов, хотя в официальной документации об этом четко сказано.
В mongoose для этих целей есть даже специальный флаг , который надо указывать при описании схемы данных:
var User = new mongoose.Schema(< email: < type: String, unique: true, required: true >, password: String >, < autoIndex: process.env('mode') == 'development' >); Теперь автоматическое построение индексов будет работать только в режиме development.
8. Не забываем о зарезервированных ключах
Возможно, не все сталкиваются с подобной проблемой, но все же обращу внимание на то, что в объектах mongoose есть набор зарезервированных названий для атрибутов, они приводятся в документации. Приходилось сталкиваться с именованием атрибутов ключами из списка зарезервированных, после чего необходимо было отскребать обращения к этим ключам по всему коду. Mongoose на использование зарезервированных ключей ничуть не ругается. Граблями, на которые наступил я в данном списке ключей, оказался ключ options.
Mongoose с Node.js — моделирование объектных данных
NoSQL привнес гибкость в табличный мир баз данных. В частности, MongoDB стал отличным вариантом для хранения неструктурированных документов JSON. Данные начинаются как JSON в пользовательском интерфейсе и претерпевают очень мало преобразований для сохранения, поэтому мы получаем преимущества от повышения производительности и сокращения времени обработки.
Но NoSQL не означает полного отсутствия структуры. Нам все еще нужно проверить и преобразовать наши данные перед их сохранением, и нам все еще может потребоваться применить к ним некоторую бизнес-логику. Это место, которое заполняет Mongoose.
В этой статье мы узнаем на примере приложения, как мы можем использовать Mongoose для моделирования наших данных и проверки их перед сохранением в MongoDB.
Мы напишем модель для приложения «Генеалогия» — человека с несколькими личными свойствами, включая их родителей. Мы также увидим, как мы можем использовать эту модель для создания и изменения лиц и сохранения их в MongoDB.
Что такое Mongoose?
Как работает MongoDB
Чтобы понять, что такое Mongoose, нам сначала нужно понять в общих чертах, как работает MongoDB. Базовая единица данных, которую мы можем сохранить в MongoDB, — это документ. Несмотря на то, что они хранятся как двоичные, когда мы запрашиваем базу данных, мы получаем ее представление в виде объекта JSON.
Связанные документы могут храниться в коллекциях, подобных таблицам в реляционных базах данных. На этом аналогия заканчивается, поскольку мы определяем, что считать «связанными документами».
MongoDB не навязывает структуру документов. Например, мы можем сохранить этот документ в коллекцию Person :
А затем в той же коллекции мы могли бы сохранить, казалось бы, несвязанный документ без общих свойств или структуры:
В этом заключается новизна баз данных NoSQL. Мы придаем смысл нашим данным и храним их так, как нам кажется лучше. База данных не налагает никаких ограничений.
Цель Mongoose
Хотя MongoDB не навязывает структуру, приложения обычно управляют данными с ее помощью. Мы получаем данные, и нам необходимо их проверить, чтобы убедиться, что мы получили именно то, что нам нужно. Нам также может потребоваться обработать данные каким-либо образом перед их сохранением. Здесь и вступает в игру Mongoose.
Mongoose — это NPM пакет для приложений NodeJS. Он позволяет определять схемы для наших данных, а также абстрагироваться от доступа к MongoDB. Таким образом мы можем гарантировать, что все сохраненные документы имеют общую структуру и содержат необходимые свойства.
Давайте теперь посмотрим, как определить схему.
Установка Mongoose и создание схемы Person
Давайте запустим проект Node со свойствами по умолчанию и схемой Person:
npm init -yПосле инициализации проекта давайте продолжим и установим mongoose , используя npm :
npm install --save mongoosemongoose также автоматически установит NPM модуль mongodb . Вы не будете использовать его напрямую. Этим займется Mongoose.
Чтобы работать с Mongoose, нам нужно импортировать его в наши скрипты:
let mongoose = require('mongoose'); А затем подключитесь к базе данных с помощью:
mongoose.connect('mongodb://localhost:27017/genealogy', ); Поскольку база данных еще не существует, она будет создана. Мы будем использовать последний инструмент для анализа строки подключения, установив значение useNewUrlParser как true а также будем использовать последнюю версию драйвера MongoDB с useUnifiedTopology равным true .
mongoose.connect() предполагает, что сервер MongoDB работает локально на порту по умолчанию и без учетных данных. Один из простых способов заставить MongoDB работать таким образом — это Docker:
docker run -p 27017:27017 mongoСозданного контейнера нам будет достаточно, чтобы попробовать Mongoose, хотя данные, сохраненные в MongoDB, не будут постоянными.
Схема и модель Person
После предыдущих необходимых объяснений мы можем сосредоточиться на написании нашей схемы человека и компиляции из нее модели.
Схема в Mongoose сопоставляется с коллекцией MongoDB и определяет формат для всех документов в этой коллекции. Всем свойствам внутри схемы должен быть назначен SchemaType . Например, имя нашего Person можно определить так:
const PersonSchema = new mongoose.Schema(< name: < type: String>, >); Или еще проще, вот так:
const PersonSchema = new mongoose.Schema(< name: String, >); String является одним из нескольких SchemaTypes , определенных Mongoose. Остальное можно найти в документации Mongoose.
Ссылка на другие схемы
Мы можем ожидать, что все приложения среднего размера будут иметь более одной схемы, и, возможно, эти схемы будут каким-то образом связаны.
В нашем примере, чтобы представить генеалогическое древо, нам нужно добавить в нашу схему два атрибута:
const PersonSchema = new mongoose.Schema(< // . mother: < type: mongoose.Schema.Types.ObjectId, ref: 'Person' >, father: < type: mongoose.Schema.Types.ObjectId, ref: 'Person' >, >); Человек может иметь mother и father . В Mongoose это можно представить, сохранив идентификатор документа, на который есть ссылка mongoose.Schema.Types.ObjectId , а не самого объекта.
ref должно быть название модели, на которую мы ссылаемся. Позже мы узнаем больше о моделях, но пока достаточно знать, что схема относится только к одной модели и Person является моделью PersonSchema .
Наш случай немного особенный, потому что оба mother и father также будут содержать людей, но способ определения этих отношений одинаков во всех случаях.
Встроенная проверка
Все SchemaType идут со встроенной проверкой по умолчанию. В зависимости от выбранного мы можем определить лимиты и другие требования SchemaType . Для того, чтобы увидеть некоторые примеры, давайте добавим surname , yearBorn и notes к нашему Person :
const PersonSchema = new mongoose.Schema(< name: < type: String, index: true, required: true >, surname: < type: String, index: true >, yearBorn: < type: Number, min: -5000, max: (new Date).getFullYear() >, notes: < type: String, minlength: 5 >, >); Все встроенные SchemaType могут быть required . В нашем случае мы хотим, чтобы у всех людей было хотя бы имя. Тип Number позволяет устанавливать мин и максимальными значениями.
Свойство index заставит Mongoose создать индекс в базе данных. Это облегчает эффективное выполнение запросов. Выше мы определили индексы name и surname . Мы всегда будем искать людей по именам.
Пользовательская проверка
Встроенные SchemaType позволяют настраивать собственные проверки. Это особенно полезно, когда у нас есть свойство, которое может содержать только определенные значения. Добавим свойство photosURLs в наш массив URL-адресов их фотографий Person :
const PersonSchema = new mongoose.Schema(< // . photosURLs: [ < type: String, validate: < validator: function(value) < const urlPattern = /(http|https):\/\/(\w+:\w*#)?(\S+)(:[0-9]+)?(\/|\/([\w#. +=&%#!\-/]))?/; const urlRegExp = new RegExp(urlPattern); return value.match(urlRegExp); >, message: props => `$ is not a valid URL` > > ], >); photosURLs это просто массив строк photosURLs: [String] . Что делает это свойство особенным, так это то, что нам нужна настраиваемая проверка, чтобы подтвердить, что добавленные значения имеют формат URL-адреса.
В приведенной выше функции validator() используется регулярное выражение, которое соответствует типичным URL-адресам в Интернете, которые должны начинаться с http(s):// .
Если нам нужен более сложный SchemaType , мы можем создать свой собственный, но нам стоит поискать, возможно он уже существует.
Например, пакет mongoose-type-url, который мы могли бы использовать вместо нашей валидации.
Виртуальные свойства
Виртуальные объекты — это свойства документа, которые не сохраняются в базе данных. Они результат расчета. В нашем примере было бы полезно задать полное имя человека в одной строке, а не разделять name и surname .
Посмотрим, как этого добиться после определения нашей первоначальной схемы:
PersonSchema.virtual('fullName'). get(function() < if(this.surname) return this.name + ' ' + this.surname; return this.name; >). set(function(fullName) < fullName = fullName.split(' '); this.name = fullName[0]; this.surname = fullName[1]; >); Приведенное выше виртуальное свойство fullName делает некоторые предположения для простоты: у каждого человека есть как минимум имя и фамилия. Мы столкнемся с проблемами, если у человека есть отчество, составное имя или фамилия. Все эти ограничения могут быть закреплены внутри get() и set() функции, определенные выше.
Поскольку виртуальные данные не сохраняются в базе данных, мы не можем использовать их в качестве фильтра при поиске людей в базе данных. В нашем случае нам нужно будет использовать name и surname .
ПО промежуточного слоя
Промежуточное ПО — это функции или перехватчики, которые могут выполняться до или после стандартных методов Mongoose, например, таких как save() или find() .
Человек может иметь mother и father . Как мы уже говорили ранее, мы сохраняем эти отношения, сохраняя идентификатор объекта как свойства человека, а не сами объекты. Было бы неплохо заполнить оба свойства самими объектами, а не только идентификаторами.
Это может быть достигнуто как функция pre() , связанная с методом Mongoose findOne() :
PersonSchema.pre('findOne', function(next) < this.populate('mother').populate('father'); next(); >); Вышеупомянутой функции необходимо вызвать функцию next() , полученную в качестве параметра, чтобы продолжить обработку других хуков.
populate() — это метод Mongoose для замены идентификаторов объектами, которые они представляют, и мы используем его для получения родителей при поиске только одного человека.
Мы могли бы добавить этот хук к другим функциям поиска, например find() . Мы могли бы даже найти родителей рекурсивно, если бы захотели. Но мы должны обращаться с populate() осторожно, так как каждый вызов — это выборка из базы данных.
Создайте модель для схемы
Чтобы начать создавать документы на основе нашей схемы Person, последний шаг — это скомпилировать модель на основе схемы:
const Person = mongoose.model('Person', PersonSchema); Первым аргументом будет единственное имя коллекции, о которой мы говорим. Это значение ref , которое мы придали свойствам mother и father . Второй аргумент — это Schema, то что мы определили ранее.
Метод model() делает копию всего что мы определили в схеме. Он также содержит все методы Mongoose, которые мы будем использовать для взаимодействия с базой данных.
Модель — это единственное, что нам теперь нужно. Мы могли бы даже использовать module.exports , чтобы сделать Person доступным в других модулях нашего приложения:
module.exports.Person = mongoose.model('Person', PersonSchema); module.exports.db = mongoose; Мы также экспортировали модуль mongoose . Он понадобится нам для отключения от базы данных до завершения работы приложения.
Мы можем импортировать модуль таким образом:
const = require('./persistence'); Как использовать модель
Модель, которую мы скомпилировали в последнем разделе, содержит все, что нам нужно для взаимодействия с коллекцией в базе данных.
Давайте теперь посмотрим, как мы будем использовать нашу модель для всех операций CRUD.
Создание Person
Мы можем создать Person, просто выполнив:
let alice = new Person(); name это единственное обязательное свойство. Давайте создадим другого человека, но на этот раз с использованием виртуального свойства:
let bob = new Person(); Теперь, когда у нас есть первые два человека, мы можем создать нового со всеми заполненными свойствами, включая родителей:
let charles = new Person(< fullName: 'Charles Brown', photosURLs: ['https://bit.ly/34Kvbsh'], yearBorn: 1922, notes: 'Famous blues singer and pianist. Parents not real.', mother: alice._id, father: bob._id, >); Все значения для этого последнего человека установлены на допустимые, так как проверка выдаст ошибку, как только эта строка будет выполнена. Например, если бы мы установили URL-адрес первой фотографии не на ссылку, мы бы получили ошибку:
ValidationError: Person validation failed: photosURLs.0: wrong_url is not a valid URL Как объяснялось ранее, родители были заполнены идентификаторами первых двух человек, а не объектами.
Мы создали трех человек, но они еще не сохранены в базе данных. Сделаем это дальше:
alice.save(); bob.save(); Операции с базой данных асинхронны. Если мы хотим дождаться завершения, мы можем использовать async / await:
await charles.save(); Теперь, когда все люди будут сохранены в базе данных, мы можем получить их обратно с методами find() и findOne() .
Получить одно или несколько Person
Все методы поиска в Mongoose требуют аргумента для фильтрации поиска. Вернемся к последнему созданному нами человеку:
let dbCharles = await Person.findOne().exec(); findOne() возвращает запрос, поэтому для получения результата нам нужно выполнить его с помощью exec() , а затем дождаться результата с помощью await .
Поскольку мы прикрепили к методу findOne() ловушку для заполнения родителей человека, теперь мы можем обращаться к ним напрямую:
console.log(dbCharles.mother.fullName); В нашем случае мы знаем, что запрос вернет только один результат, но даже если более одного человека соответствует фильтру, будет возвращен только первый результат.
Мы можем получить более одного результата, если воспользуемся методом find() :
let all = await Person.find(<>).exec(); Мы вернем массив, который сможем перебрать.
Обновление Person
Если у нас уже есть Person, так как мы только что его создали или извлекли, мы можем обновить и сохранить изменения, выполнив следующие действия:
alice.surname = 'Adams'; charles.photosURLs.push('https://bit.ly/2QJCnMV'); await alice.save(); await charles.save(); Поскольку оба человека уже существуют в базе данных, Mongoose отправит команду обновления только с измененными полями, а не со всем документом.
Удалить Person
Как и поиск, удаление может быть выполнено для одного или нескольких Person:
await Person.deleteOne(); await Person.deleteMany(<>).exec(); После выполнения этих двух команд коллекция будет пустой.
Вывод
В этой статье мы увидели, как Mongoose может быть очень полезен в наших проектах NodeJS и MongoDB.
В большинстве проектов с MongoDB нам необходимо хранить данные в определенном формате. Приятно знать, что Mongoose предоставляет простой способ моделирования и проверки этих данных.
Источник:
Введение в Mongoose для MongoDB и Node.js
Mongoose — это инфраструктура JavaScript, которая обычно используется в приложении Node.js с базой данных MongoDB. В этой статье я собираюсь познакомить вас с Mongoose и MongoDB, и, что более важно, там, где эти технологии подходят для вашего приложения.
Что такое MongoDB?
Начнем с MongoDB. MongoDB — это база данных, в которой ваши данные хранятся в виде документов. Чаще всего эти документы напоминают JSON-подобную структуру:
firstName: «Jamie»,
lastName: «Munro»
Документ затем помещается в коллекцию. В качестве примера, приведенный выше пример документа определяет user объект. Этот user объект тогда, как правило, будет частью коллекции, называемой users .
Одним из ключевых факторов с MongoDB является его гибкость, когда речь идет о структуре. Несмотря на то, что в первом примере user объект содержал свойства firstName и lastName , эти свойства не требуются в каждом user документе, который является частью коллекции users . Это то, что отличает MongoDB от базы данных SQL, такой как MySQL или Microsoft SQL Server, которая требует строго определенной схемы базы данных каждого объекта, который она хранит.
Возможность создавать динамические объекты, которые хранятся в виде документов в базе данных, — вот где Mongoose вступает в игру.
Что такое мангуст?
Mongoose является картографом объектных документов (ODM). Это означает, что Mongoose позволяет вам определять объекты со строго типизированной схемой, которая сопоставлена с документом MongoDB.
Mongoose предоставляет невероятное количество функций для создания и работы со схемами. В настоящее время Mongoose содержит восемь типов SchemaType, которые сохраняются для свойства, когда оно сохраняется в MongoDB. Они есть:
- строка
- номер
- Дата
- буфер
- логический
- смешанный
- ObjectId
- массив
Каждый тип данных позволяет вам указать:
- значение по умолчанию
- пользовательская функция проверки
- указать поле, обязательное для заполнения
- функция get, которая позволяет вам манипулировать данными, прежде чем они будут возвращены как объект
- функция set, которая позволяет вам манипулировать данными перед их сохранением в базе данных
- создавать индексы, позволяющие быстрее извлекать данные
В дополнение к этим общим параметрам, определенные типы данных позволяют вам дополнительно настраивать, как данные хранятся и извлекаются из базы данных. Например, тип данных String также позволяет указывать следующие дополнительные параметры:
- преобразовать его в нижний регистр
- преобразовать его в верхний регистр
- обрезать данные перед сохранением
- регулярное выражение, которое может ограничивать данные, которые могут быть сохранены в процессе проверки
- перечисление, которое может определить список допустимых строк
Свойства Number и Date поддерживают указание минимального и максимального значения, допустимого для этого поля.
Большинство из восьми разрешенных типов данных должны быть вам знакомы. Однако есть несколько исключений, которые могут ObjectId вас, например, Buffer , Mixed , ObjectId и Array .
Тип данных Buffer позволяет сохранять двоичные данные. Типичным примером двоичных данных может быть изображение или закодированный файл, такой как документ PDF.
Тип данных Mixed превращает свойство в поле «все идет». Это поле напоминает, сколько разработчиков может использовать MongoDB, потому что нет определенной структуры. Будьте осторожны с использованием этого типа данных, поскольку он теряет многие замечательные функции, которые предоставляет Mongoose, такие как проверка данных и обнаружение изменений сущностей, чтобы автоматически узнавать об обновлении свойства при сохранении.
ObjectId данных ObjectId обычно указывает ссылку на другой документ в вашей базе данных. Например, если у вас есть коллекция книг и авторов, документ книги может содержать свойство ObjectId которое ссылается на конкретного автора документа.
Тип данных Array позволяет хранить JavaScript-подобные массивы. С типом данных Array вы можете выполнять над ними обычные операции с массивами JavaScript, такие как push, pop, shift, slice и т. Д.
Быстрый обзор
Прежде чем перейти к созданию кода, я просто хотел вспомнить то, что мы только что узнали. MongoDB — это база данных, которая позволяет хранить документы с динамической структурой. Эти документы сохраняются в коллекции.
Mongoose — это библиотека JavaScript, которая позволяет вам определять схемы со строго типизированными данными. После того, как схема определена, Mongoose позволяет вам создать Модель на основе определенной схемы. Модель Mongoose затем сопоставляется с документом MongoDB через определение схемы модели.
После того, как вы определили свои схемы и модели, Mongoose содержит множество различных функций, которые позволяют вам проверять, сохранять, удалять и запрашивать ваши данные, используя обычные функции MongoDB. Я поговорю об этом подробнее с конкретными примерами кода для подражания.
Установка MongoDB
Прежде чем мы сможем приступить к созданию наших схем и моделей Mongoose, необходимо установить и настроить MongoDB. Я бы предложил посетить страницу загрузки MongoDB . Есть несколько вариантов, доступных для установки. Я связался с Сервером Сообщества. Это позволяет вам установить версию, специфичную для вашей операционной системы. MongoDB также предлагает Enterprise Server и установку поддержки облака. Поскольку целые книги могут быть написаны об установке, настройке и мониторинге MongoDB, я собираюсь придерживаться Сервера совместной работы.
После того, как вы скачали и установили MongoDB для выбранной вами операционной системы, вам нужно будет запустить базу данных. Вместо того, чтобы изобретать велосипед, я бы предложил посетить документацию MongoDB по установке MongoDB Community Edition .
Я подожду здесь, пока вы настроите MongoDB. Когда вы будете готовы, мы можем перейти к настройке Mongoose для подключения к вашей только что установленной базе данных MongoDB.
Настройка мангуста
Mongoose — это фреймворк JavaScript, и я собираюсь использовать его в приложении Node.js. Если у вас уже установлен Node.js, вы можете перейти к следующему шагу. Если у вас не установлен Node.js, я предлагаю вам начать со страницы загрузки Node.js. и выбрать установщик для вашей операционной системы.
С настроенным и готовым к работе Node.js я собираюсь создать новое приложение, а затем установить пакет Mongoose NPM.
В командной строке, в которой вы хотите установить приложение, вы можете запустить следующие команды: