ExpressJS - baza danych
Ciągle otrzymujemy prośby, ale nigdzie ich nie przechowujemy. Potrzebujemy bazy danych do przechowywania danych. W tym celu wykorzystamy bazę danych NoSQL o nazwieMongoDB.
Aby zainstalować i przeczytać o Mongo, kliknij ten link.
Aby używać Mongo z Expressem, potrzebujemy klienta API dla node. Jest dla nas wiele opcji, ale w tym samouczku będziemy trzymać się mangusty . Mongoose jest używany dodocument Modelingw Node dla MongoDB. Do modelowania dokumentów tworzymy plikModel (podobnie jak class w programowaniu zorientowanym na dokumenty), a następnie produkujemy documents używając tego modelu (tak jak tworzymy documents of a classw OOP). Całe nasze przetwarzanie zostanie wykonane na tych „dokumentach”, a na końcu zapiszemy te dokumenty w naszej bazie danych.
Konfigurowanie Mongoose
Teraz, gdy zainstalowałeś Mongo, pozwól nam zainstalować Mongoose, w ten sam sposób, w jaki instalowaliśmy nasze inne pakiety węzłów -
npm install --save mongooseZanim zaczniemy używać mangusty, musimy stworzyć bazę danych za pomocą powłoki Mongo. Aby utworzyć nową bazę danych, otwórz terminal i wpisz „mongo”. Uruchomi się powłoka Mongo, wprowadź następujący kod -
use my_dbZostanie utworzona nowa baza danych. Za każdym razem, gdy otworzysz powłokę mongo, będzie ona domyślnie „testować” bazę danych i będziesz musiał przejść do bazy danych za pomocą tego samego polecenia, co powyżej.
Aby korzystać z Mongoose, będziemy go potrzebować w naszym index.js plik, a następnie połącz się z mongodb usługa działa mongodb://localhost.
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');Teraz nasza aplikacja jest połączona z naszą bazą danych, stwórzmy nowy Model. Ten model będzie działał jako zbiór w naszej bazie danych. Aby utworzyć nowy Model, użyj następującego kodu, przed zdefiniowaniem jakiejkolwiek trasy -
var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);Powyższy kod definiuje schemat osoby i służy do tworzenia trybu Mongoose Person.
Zapisywanie dokumentów
Teraz utworzymy nowy formularz html; ten formularz pomoże Ci uzyskać dane osoby i zapisać ją w naszej bazie danych. Aby utworzyć formularz, utwórz nowy plik widoku o nazwieperson.pug w katalogu widoków z następującą zawartością -
html
head
   title Person
   body
      form(action = "/person", method = "POST")
      div
         label(for = "name") Name: 
         input(name = "name")
      br
      div
         label(for = "age") Age: 
         input(name = "age")
      br
      div
         label(for = "nationality") Nationality: 
         input(name = "nationality")
      br
      button(type = "submit") Create new personDodaj również new get route w index.js renderować ten dokument -
app.get('/person', function(req, res){
   res.render('person');
});Iść do "localhost:3000/person”, aby sprawdzić, czy formularz wyświetla poprawne dane wyjściowe. Zwróć uwagę, że to tylko interfejs użytkownika, który jeszcze nie działa. Poniższy zrzut ekranu przedstawia sposób wyświetlania formularza -
 
                Teraz zdefiniujemy procedurę obsługi trasy pocztowej pod adresem '/person' który obsłuży to żądanie
app.post('/person', function(req, res){
   var personInfo = req.body; //Get the parsed information
   
   if(!personInfo.name || !personInfo.age || !personInfo.nationality){
      res.render('show_message', {
         message: "Sorry, you provided worng info", type: "error"});
   } else {
      var newPerson = new Person({
         name: personInfo.name,
         age: personInfo.age,
         nationality: personInfo.nationality
      });
		
      newPerson.save(function(err, Person){
         if(err)
            res.render('show_message', {message: "Database error", type: "error"});
         else
            res.render('show_message', {
               message: "New person added", type: "success", person: personInfo});
      });
   }
});W powyższym kodzie, jeśli otrzymamy puste pole lub nie otrzymamy żadnego pola, wyślemy odpowiedź o błędzie. Ale jeśli otrzymamy dobrze sformułowany dokument, utworzymy pliknewPerson dokument z modelu Person i zapisz go w naszej bazie danych przy użyciu rozszerzenia newPerson.save()funkcjonować. Jest to zdefiniowane w Mongoose i akceptuje wywołanie zwrotne jako argument. To wywołanie zwrotne ma 2 argumenty - błąd i odpowiedź. Te argumenty spowodują, że plikshow_message widok.
Aby wyświetlić odpowiedź z tej trasy, będziemy również musieli utworzyć plik show_messagewidok. Utwórz nowy widok z następującym kodem -
html
   head
      title Person
   body
      if(type == "error")
         h3(style = "color:red") #{message}
      else
         h3 New person, 
            name: #{person.name}, 
            age: #{person.age} and 
            nationality: #{person.nationality} added!Po pomyślnym przesłaniu pliku form(show_message.pug) -
 
                Mamy teraz interfejs do stworzenia persons.
Pobieranie dokumentów
Mongoose zapewnia wiele funkcji do pobierania dokumentów, skupimy się na 3 z nich. Wszystkie te funkcje również przyjmują wywołanie zwrotne jako ostatni parametr i podobnie jak funkcja save, ich argumentami są błąd i odpowiedź. Te trzy funkcje są następujące -
Model.find (warunki, wywołanie zwrotne)
Ta funkcja znajduje wszystkie dokumenty pasujące do pól w obiekcie warunków. Te same operatory używane w Mongo działają również w przypadku mangusty. Na przykład,
Person.find(function(err, response){
   console.log(response);
});Spowoduje to pobranie wszystkich dokumentów z kolekcji osoby.
Person.find({name: "Ayush", age: 20}, 
   function(err, response){
      console.log(response);
});Spowoduje to pobranie wszystkich dokumentów, w których nazwa pola to „Ayush”, a wiek to 20 lat.
Możemy również dostarczyć potrzebną nam projekcję, czyli potrzebne nam pola. Na przykład, jeśli chcemy tylkonames osób, których nationalityjest „indyjski” , używamy -
Person.find({nationality: "Indian"}, "name", function(err, response){
   console.log(response);
});Model.findOne (warunki, wywołanie zwrotne)
Ta funkcja zawsze pobiera pojedynczy, najbardziej odpowiedni dokument. Ma te same dokładne argumenty, coModel.find().
Model.findById (id, wywołanie zwrotne)
Ta funkcja przyjmuje rozszerzenie _id(zdefiniowane przez mongo) jako pierwszy argument, opcjonalny łańcuch projekcji i wywołanie zwrotne do obsługi odpowiedzi. Na przykład,
Person.findById("507f1f77bcf86cd799439011", function(err, response){
   console.log(response);
});Utwórzmy teraz trasę, aby wyświetlić wszystkie rekordy osób -
var express = require('express');
var app = express();
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');
var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);
app.get('/people', function(req, res){
   Person.find(function(err, response){
      res.json(response);
   });
});
app.listen(3000);Aktualizacja dokumentów
Mongoose zapewnia 3 funkcje do aktualizacji dokumentów. Funkcje opisano poniżej -
Model.update (stan, aktualizacje, oddzwonienie)
Ta funkcja przyjmuje warunki i aktualizuje obiekt jako dane wejściowe oraz stosuje zmiany do wszystkich dokumentów pasujących do warunków w kolekcji. Na przykład poniższy kod zaktualizuje narodowość „amerykańską” we wszystkich dokumentach osoby -
Person.update({age: 25}, {nationality: "American"}, function(err, response){
   console.log(response);
});Model.findOneAndUpdate (stan, aktualizacje, wywołanie zwrotne)
Znajduje jeden dokument na podstawie zapytania i aktualizuje go zgodnie z drugim argumentem. Jako ostatni argument przyjmuje również callback. Wykonajmy następujący przykład, aby zrozumieć funkcję
Person.findOneAndUpdate({name: "Ayush"}, {age: 40}, function(err, response) {
   console.log(response);
});Model.findByIdAndUpdate (identyfikator, aktualizacje, wywołanie zwrotne)
Ta funkcja aktualizuje pojedynczy dokument identyfikowany przez jego identyfikator. Na przykład,
Person.findByIdAndUpdate("507f1f77bcf86cd799439011", {name: "James"}, 
   function(err, response){
      console.log(response);
});Stwórzmy teraz trasę do aktualizacji ludzi. To będziePUT trasa z identyfikatorem jako parametrem i szczegółami w ładunku.
var express = require('express');
var app = express();
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');
var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);
app.put('/people/:id', function(req, res){
   Person.findByIdAndUpdate(req.params.id, req.body, function(err, response){
      if(err) res.json({message: "Error in updating person with id " + req.params.id});
      res.json(response);
   });
});
app.listen(3000);Aby przetestować tę trasę, wprowadź następujące polecenie w swoim terminalu (zamień id na identyfikator z utworzonego people) -
curl -X PUT --data "name = James&age = 20&nationality = American
"http://localhost:3000/people/507f1f77bcf86cd799439011Spowoduje to zaktualizowanie dokumentu związanego z identyfikatorem podanym w trasie o powyższe szczegóły.
Usuwanie dokumentów
Omówiliśmy Create, Read i Update, teraz zobaczymy, do czego można przyzwyczaić Mongoose Deletedokumenty. Mamy tutaj 3 funkcje, dokładnie takie jak aktualizacja.
Model.remove (warunek, [wywołanie zwrotne])
Ta funkcja przyjmuje obiekt warunku jako dane wejściowe i usuwa wszystkie dokumenty spełniające warunki. Na przykład, jeśli musimy usunąć wszystkie osoby w wieku 20 lat, użyj następującej składni -
Person.remove({age:20});Model.findOneAndRemove (warunek, [wywołanie zwrotne])
Ta funkcja usuwa plik single, najbardziej odpowiedni dokument według warunków obiektu. Wykonajmy następujący kod, aby zrozumieć to samo.
Person.findOneAndRemove({name: "Ayush"});Model.findByIdAndRemove (id, [wywołanie zwrotne])
Ta funkcja usuwa pojedynczy dokument określony przez jego identyfikator. Na przykład,
Person.findByIdAndRemove("507f1f77bcf86cd799439011");Stwórzmy teraz trasę do usuwania osób z naszej bazy danych.
var express = require('express');
var app = express();
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');
var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);
app.delete('/people/:id', function(req, res){
   Person.findByIdAndRemove(req.params.id, function(err, response){
      if(err) res.json({message: "Error in deleting record id " + req.params.id});
      else res.json({message: "Person with id " + req.params.id + " removed."});
   });
});
app.listen(3000);Aby sprawdzić dane wyjściowe, użyj następującego polecenia curl -
curl -X DELETE http://localhost:3000/people/507f1f77bcf86cd799439011Spowoduje to usunięcie osoby o podanym identyfikatorze i wyświetlenie następującego komunikatu -
{message: "Person with id 507f1f77bcf86cd799439011 removed."}To podsumowuje, jak możemy tworzyć proste aplikacje CRUD przy użyciu MongoDB, Mongoose i Express. Aby dokładniej poznać Mongoose, przeczytaj dokumentację interfejsu API.