Iniziare

Per prima cosa assicurati di aver installato MongoDB e Node.js

Successivamente installa Mongoose dalla riga di comando usando npm :

$ npm install mongoose

Ora diciamo che ci piacciono i gattini fuzzy e vogliamo registrare tutti i gattini che incontriamo in MongoDB. La prima cosa che dobbiamo fare è includere mangusta nel nostro progetto e aprire una connessione al database di test sulla nostra istanza in esecuzione locale di MongoDB.

// getting-started.js
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test');

Abbiamo una connessione in sospeso con il database di test in esecuzione su localhost. Ora dobbiamo ricevere una notifica se ci connettiamo correttamente o se si verifica un errore di connessione:

var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  // we're connected!
});

Una volta aperta la connessione, verrà richiamata la nostra chiamata. Per brevità, supponiamo che tutto il codice seguente sia incluso in questo callback.

Con Mongoose, tutto è derivato da uno Schema . Prendiamo un riferimento e definiamo i nostri gattini.

var kittySchema = mongoose.Schema({
    name: String
});

Fin qui tutto bene. Abbiamo uno schema con una proprietà, name , che sarà una String . Il prossimo passo è la compilazione del nostro schema in un Model .

var Kitten = mongoose.model('Kitten', kittySchema);

Un modello è una classe con cui costruiamo i documenti. In questo caso, ogni documento sarà un gattino con proprietà e comportamenti dichiarati nel nostro schema. Creiamo un documento gattino che rappresenta il piccolo ragazzo che abbiamo appena incontrato sul marciapiede esterno:

var silence = new Kitten({ name: 'Silence' });
console.log(silence.name); // 'Silence'

I gattini possono miagolare, quindi diamo un'occhiata a come aggiungere la funzionalità "parla" ai nostri documenti:

// NOTE: methods must be added to the schema before compiling it with mongoose.model()
kittySchema.methods.speak = function () {
  var greeting = this.name
    ? "Meow name is " + this.name
    : "I don't have a name";
  console.log(greeting);
}

var Kitten = mongoose.model('Kitten', kittySchema);

Le funzioni aggiunte alla proprietà methods di uno schema vengono compilate nel prototipo del Model ed esposte in ogni istanza del documento:

var fluffy = new Kitten({ name: 'fluffy' });
fluffy.speak(); // "Meow name is fluffy"

Abbiamo parlato di gattini! Ma non abbiamo ancora salvato nulla su MongoDB. Ogni documento può essere salvato nel database chiamando il suo metodo di save . Il primo argomento del callback sarà un errore se si verifica qualcosa.

fluffy.save(function (err, fluffy) {
  if (err) return console.error(err);
  fluffy.speak();
});

Dire che il tempo passa e vogliamo mostrare tutti i gattini che abbiamo visto. Possiamo accedere a tutti i documenti del gattino attraverso il nostro Model Kitten.

Kitten.find(function (err, kittens) {
  if (err) return console.error(err);
  console.log(kittens);
})

Abbiamo appena registrato tutti i gattini nel nostro db alla console. Se vogliamo filtrare i nostri gattini per nome, Mongoose supporta la sintassi ricca di querying MongoDB.

Kitten.find({ name: /^fluff/ }, callback);

Questo esegue una ricerca per tutti i documenti con una proprietà name che inizia con "Fluff" e restituisce il risultato come una serie di gattini alla richiamata.

Complimenti

Questa è la fine del nostro rapido avvio. Abbiamo creato uno schema, aggiunto un metodo di documento personalizzato, gattini salvati e interrogati in MongoDB usando Mongoose. Vai alla Schema o ai documenti API per ulteriori informazioni.