Ora che abbiamo imparato a conoscere il driver nodo MongoDB, il modulo nodo,
che consente alla nostra applicazione nodo di essere in grado di interagire
con un server MongoDB, in questo esercizio,
useremo il modulo nodo e utilizzare i vari metodi che sono
supportati dal modulo nodo per fornire introduzione con il nostro server MongoDB.
Per iniziare, vai
alla cartella NodeJS che hai utilizzato per memorizzare tutti i tuoi esempi
e quindi crea una nuova cartella lì denominata node-mongo.
In questa cartella, svilupperemo
l'applicazione NodeJS che interagisce con il nostro server MongoDB.
Ora, assicurati che il tuo server MongoDB sia attivo e funzionante,
quindi nell'esercizio precedente abbiamo già visto come il nostro server MongoDB può essere avviato.
Quindi, mantenere il server MongoDB attivo e in esecuzione e in
altra finestra del terminale o scheda terminale o finestra di comando,
andare alla cartella node-mongo che hai appena
creato e inizializzare un'applicazione nodo qui.
Quindi, lasciami digitare npm init e
chiameremo l'applicazione come Node-Mongo e versione,
descrizione Nodo MongoDB Esempio,
e il punto di ingresso,
e l'autore, proprio come abbiamo compilato gli esercizi precedenti.
Quindi, una volta inizializzato il file package.json,
aprilo nell'editor di tua scelta.
Ora andando nel file package.json,
lasciami introdurre un altro script qui proprio come abbiamo fatto in precedenza, quindi,
diremo «start»: «node index» e salvare le modifiche.
Tornando al terminale,
installiamo il modulo nodo MongoDB.
Quindi, digita npm install mongodb @3 .0.10 —save.
Installeremo anche il modulo nodo assert, quindi,
diremo npm install assert @1 .4.1 —save.
Il modulo assert ci permette di utilizzare l'asserzione
per verificare la verità o i valori falsi all'interno della nostra applicazione,
e vedrete me usarlo più tardi.
Ora che abbiamo installato questi moduli nodo,
creiamo la nostra applicazione nodo che interagisce con il server MongoDB.
Tornando all'editor,
nella cartella del progetto,
creare un file chiamato index.js,
ed è qui che creeremo
l'applicazione nodo che interagisce con il nostro server MongoDB.
Quindi, in questa applicazione,
scriviamo const Mongoclient,
e poi diranno,
require (`mongodb`), il modulo nodo MongoDB che abbiamo già installato,
e quindi questo ci fornirebbe
il MongoClient che ci permette di connetterci al server MongoDB.
Inoltre, richiedere il modulo assert.
Ora, per avviare una connessione al server MongoDB,
creiamo un URL di nome costante che sarà l'URL in cui è possibile
accedere al server MongoDB e l'accesso bambino questo è
dicendo mongodb: //localhost: 27017/.
Ricordiamo che questo è il numero di porta in cui il tuo server MongoDB sta
eseguendo 27017 const dbname=,
e poi diremo Confusione.
Ricordiamo che abbiamo creato
il database Confusione nel nostro server MongoDB nell'esercizio precedente,
quindi, stiamo andando ad accedere che il database Confusione che abbiamo creato in precedenza.
Ora, per accedere al server, diremo MongoClient.connect.
Quindi, il metodo di connessione ci permette di connetterci al MongoClient dal nostro server MongoDB,
e poi diremo che questo prende l'URL come primo parametro,
l'URL del server MongoDB come primo parametro.
Il secondo parametro è una funzione di callback.
Quindi, la funzione di callback ha due parametri, il valore di errore,
e client, che possiamo quindi utilizzare
per connettersi al nostro database e quindi eseguire varie operazioni.
Quindi, all'interno di questa funzione di callback, la
prima cosa che faremo è controllare per assicurarsi che l'errore non sia nullo.
Quindi, l'asserzione controllerà per vedere se l'errore è uguale a null,
quindi la funzione assert ci consente di eseguire vari controlli sui valori.
Quindi, controlliamo per assicurarci che l'errore non
sia, se non è nullo,
allora ciò significa che c'è un errore e quindi mostreremo l'errore sullo schermo.
Quindi, questo è l'uso della funzione assert qui.
Ora, se ciò non accade,
allora ciò significa che ci siamo collegati correttamente al server,
quindi diremo `connesso correttamente al server`
const db= client.db (dbname) per connettersi al database,
allora possiamo dire const collection db. ,
quindi il db ci fornirà vari metodi che ci permettono di
interagire con il server, quindi diremo db.collection (`dishes`) Quindi,
cercheremo di accedere alla raccolta di piatti all'interno di questo database.
Ora, la prossima cosa che cercheremo di fare è
collection.insertone quindi cercheremo di inserire un oggetto nella raccolta,
e questo oggetto sarebbe con
il nome e la descrizione, «test».
Quindi, questa raccolta fornisce questo metodo chiamato
InsertOne, che ci permette di inserire un documento in questa raccolta,
e il documento è il primo argomento di questo metodo qui.
Il secondo argomento del metodo è una funzione di callback
e la funzione di callback accetta due parametri, errore e risultato.
Quindi, all'interno di questa funzione di callback,
se si ottiene il risultato,
allora siamo in grado di accedere alla raccolta e quindi eseguire ulteriori operazioni.
Quindi, qui, la prima cosa che faremo è controllare per assicurarsi che l'errore non sia nullo.
Quindi, faremo un'affermazione lì,
e poi qui possiamo dire, «Dopo l'inserimento».
Quindi, dopo aver inserito, vediamo che
otteniamo il valore del risultato che viene restituito lì, quindi questo risultato.
Questo risultato fornirà anche
questa proprietà OPS che indica quante operazioni sono state eseguite con successo.
Quindi, questo è quello che ho intenzione di stampare.
Quindi, dirà che il numero inserito è uno.
Quindi, il che significa che questo particolare documento è stato inserito nel database.
Quindi, questo è quello che confermeremo qui.
Quindi, dopo di che, eseguiremo un'altra opzione,
un'operazione sulla raccolta, e diciamo
, raccolta trova, e cercheremo di cercare tutti i record nella raccolta.
Quindi, qui, forniremo una stringa JSON vuota o corrispondente oggetto JavaScript livello.
Quindi, cercherà tutto quello che c'è nella collezione,
e poi, ci fornirà questo.
Quindi, questo può essere convertito in un array di oggetti JSON.
Quindi, questo è il motivo per cui chiamiamo il toArray,
e questo prende una funzione di callback come parametro.
Il primo parametro ovviamente è il valore di errore, quindi ancora una volta,
controlliamo per assicurarci che l'errore non sia nullo.
Quindi diremo, console.log trovato,
e poi stampare tutto ciò che è stato trovato,
e diremo console.log.
Quindi, il secondo parametro qui, documenti,
restituirà tutti i documenti di questa raccolta
che corrispondono a qualsiasi criterio specificato qui.
Poiché questo è vuoto,
allora ciò significa che tutti i documenti nella raccolta verranno restituiti a noi.
È possibile specificare un filtro qui,
dicendo che nome è uguale a un valore,
e quindi verranno recuperati solo i documenti che corrispondono a tale valore.
Quindi qui, lasciami stampare i documenti qui,
per indicare che questo elemento è
stato inserito nella raccolta e quindi verrà recuperato,
e poi lo stamperemo solo per assicurarci che il documento che abbiamo appena
inserito nell'operazione precedente sia effettivamente nella raccolta,
e quindi lo stamperemo qui.
Ora dopo questo, allora useremo
il metodo DropCollection qui.
Quindi, DropCollection rilascerà la raccolta specificata qui.
Quindi, diremo piatti DropCollection,
quindi ho intenzione di rimuovere la collezione di piatti dal mio database.
Quindi, sto solo andando a pulire il database e poi
lasciarlo con un database vuoto in modo che possiamo andare
al prossimo esercizio in cui possiamo nuovamente
eseguire operazioni simili per controllare questo.
Questo prende, come secondo parametro,
una funzione di callback che restituisce un errore o un risultato.
All' interno di questo, controlleremo e faremo in modo che l'affermazione non sia nullo,
e poi diremo, client.close.
Quindi chiuderemo la connessione al database sul posto.
Quindi con questo, questo semplice insieme di metodi ci permettono di interagire con il nostro server,
e anche ci dimostra come possiamo comunicare con il server utilizzando
i metodi che sono disponibili attraverso questo modulo nodo MongoDB o il driver MongoDB.
Quindi, qui, vedi che per prima cosa eseguiamo un'operazione di inserimento.
Quindi, dopo l'operazione di inserimento, si noti che,
stiamo facendo la seconda operazione all'interno della funzione di callback.
Quindi, questo assicura che questa operazione sia stata completata prima di eseguire quella successiva.
Quindi, questa è una seconda chiamata che è racchiusa all'interno della prima funzione di callback,
e quindi corrispondentemente, all'interno di quella.
Stiamo ancora chiamando i metodi qui e dentro lì.
Quindi, vedi che c'è un nidificazione di queste chiamate,
una dentro l'altra.
Nota la struttura perché ho intenzione di tornare per
spiegare qualcosa su questo in uno degli esercizi successivi.
Quindi, nota che, nidificazione di queste chiamate uno all'interno dell'altro.
Salviamo le modifiche
e quindi vediamo cosa fa questa applicazione quando la eseguiamo.
Tornando al terminale, di nuovo,
assicurati che il tuo server MongoDB sia attivo e funzionante, e così,
quando è in esecuzione, stamperà molti messaggi di registro sulla console.
Possiamo ignorare quei messaggi di registro per ora.
Eseguiamo l'applicazione nodo.
Quindi, diremo, npm start,
e quando viene eseguita l'applicazione nodo,
si nota cosa fa l'applicazione nodo.
Così dice, collegato correttamente al server, Dopo inserire,
poi mostra che
questo particolare documento è stato inserito nel nostro MongoDB e il nodo in particolare,
l'ID fornito qui.
Quindi, nota che questo non dice che questo è un ID oggetto.
Questo ID viene inserito automaticamente
dal driver Mongo nodo nel loro documento quando
si tenta di inserirlo nel server MongoDB qui.
Questo formato è esattamente lo stesso dell'ID oggetto che abbiamo visto.
Successivamente, abbiamo eseguito un'operazione di ritrovamento.
Quindi, questo viene trovato,
e poi stampa questo oggetto qui.
Si noti che dall'esercizio precedente,
avevamo lasciato nel documento precedente che avevamo inserito nell'esercizio precedente.
Quindi, questo è ancora visto nella raccolta qui,
e il nuovo documento che abbiamo appena inserito qui.
Questo documento è visto proprio sotto quello qui,
ma si noti che questi due hanno due ID diversi.
Questo ID corrisponde all'ID del documento appena inserito.
Quindi, questo è un residuo dell'esercizio precedente.
Dopo questo, ovviamente lasciamo cadere la collezione in modo che
tutto questo insieme di documenti e la collezione di piatti verrà rimosso dal nostro database.
Quindi, ora il nostro database sarà pulito e vuoto.
Quindi, questo dimostra a voi come possiamo usare
il driver MongoDB per comunicare dalla nostra applicazione nodo con il server.
Ora che abbiamo la nostra applicazione,
lasciami introdurre un file.gitignore
qui e poi inserire i moduli del nodo in.gitignore,
e capisci rapidamente perché sto facendo questo.
Poi, torneremo indietro e inizializzeremo il repository Git e poi faremo un commit git.
Tornando al terminale,
lasciami inizializzare il repository Git,
e poi, controlliamo lo stato Git e vedi che ci sono alcuni file non impegnati.
Quindi lasciami controllare e poi fare un commit git con il messaggio,
Node MongoDB Esempio uno.
Questa è la parte uno dell'esercizio,
quindi controlleremo solo gli elementi nel nostro repository git.
Questo completa questo esercizio.
In questo esercizio, abbiamo visto come installiamo il modulo nodo,
il driver MongoDB, quindi,
siamo stati in grado di comunicare con il nostro server MongoDB dall'interno della
nostra applicazione nodo utilizzando i metodi che sono forniti dal driver MongoDB.
Continueremo con questo esercizio nella prossima parte
dell'esercizio dove esploreremo alcuni altri metodi del driver MongoDB.