In questo esercizio, continueremo con l'esercizio precedente in cui abbiamo
sviluppato l'interazione tra l'applicazione nodo e il server MongoDB.
In questo esercizio, ho intenzione di incapsulare alcune
delle operazioni di database in un modulo nodo a sé stante,
un modulo nodo basato su file,
e quindi utilizzarlo all'interno della mia applicazione nodo per interagire con il server.
Allo stesso tempo, eseguiremo diverse operazioni
sul server per dimostrare che saremo in
grado di interagire con il server utilizzando la nostra applicazione nodo e il driver MongoDB nodo.
Per iniziare, andiamo al nostro progetto
e quindi creare un nuovo file denominato operations.js.
Questo file incapsulerà tutte quelle operazioni del database,
le quattro operazioni che eseguirò inserendo,
trovando, rimuovendo e aggiornando un documento nel mio database.
Ora, questo sarà organizzato come un modulo nodo basato su file,
che poi lo farò uso nella mia applicazione nodo per accedere al server.
Quindi, per iniziare,
fammi prima richiedere asserire,
in questo modulo nodo,
e poiché questo sembra essere un modulo nodo,
esporteremo diversi metodi dal modulo nodo.
Il primo metodo sarebbe inserire il documento ovviamente come ci si aspetterebbe,
e questo richiederà quattro parametri DB,
il MongoDB, connessione al database all'interno della mia applicazione nodo,
che otterrò all'interno dell'applicazione nodo.
Poi il secondo è il documento che voglio inserire.
Il terzo parametro è la raccolta in cui voglio inserire il documento.
L' ultima è una funzione di callback,
che verrà richiamata una volta completata l'operazione.
Quindi chiudiamo la funzione qui,
e questo essenzialmente incapsula il metodo di inserimento del documento qui.
Quindi, questa è una funzione che viene esportata da questo modulo nodo qui.
Ora, ho intenzione di incorporare anche alcuni altri metodi qui.
Il secondo sarebbe trovare documenti.
Non solo uno, ma diversi documenti.
Questo vorrei cercare la collezione e trovare tutti i documenti che si trovano nella raccolta.
Quindi, ecco perché sto prendendo solo il database
e la raccolta come i due parametri insieme al callback.
La terza funzione che ho intenzione di implementare un'esportazione da qui è il removedocument.
Questo supporta l'operazione di eliminazione,
e quindi il nome del documento prenderà il database, il documento,
la raccolta e la richiamata come i quattro parametri,
e chiameremo la richiamata al termine dell'operazione.
L' ultimo ovviamente è quello di aggiornare il documento.
Ora, naturalmente, non devi necessariamente farlo in questo modo.
Ho appena sentito che questo sarebbe stato un altro modo per illustrare come è possibile
incapsulare tali funzioni nel proprio modulo nodo.
Questo è solo riorganizzare il codice in un modo più facile da usare.
Quindi, per le esportazioni,
per il documento di aggiornamento prende il DB,
un modo per identificare il documento come secondo parametro.
Il terzo parametro è l'aggiornamento
e il quarto parametro è la raccolta in cui
esiste questo documento e il callback.
Quindi, quattro funzioni da esportare dal file operations.js.
Ora, all'interno di queste funzioni,
implementiamo uno per uno.
Nel documento di inserimento,
la prima cosa che ho intenzione di fare è dire
const collection e dirà DB collection,
e il parametro è la raccolta.
Quindi, cercheremo la collezione lì.
Ora, questo deve essere eseguito in tutti e quattro i metodi.
Quindi, ho intenzione di andare e incollare questo codice in tutti e quattro i metodi qui,
perché questa è una funzione di cui ho bisogno in tutti loro.
Quindi, una volta entrato in possesso della collezione,
come ricordi dall'esercizio precedente,
posso eseguire operazioni sulla collezione.
Quindi, dirò collection, insert,
e questo prende come primo parametro il documento da inserire,
e il secondo parametro è il callback con l'errore e quel risultato.
Quindi, ora quando questo documento
viene inserito chiamando il metodo insert sulla raccolta di database,
il metodo insert lascia che ti ricordi,
è supportato dal driver MongoDB.
Quindi, questo è il metodo che stiamo usando qui,
o questa è la funzione che stiamo usando qui.
Ora, la prima cosa che ho intenzione di controllare per questo, assertequal err, null.
Quindi, voglio assicurarmi di non avere un errore.
Quindi voglio assicurarmi che l'errore sia nullo.
Se non è nullo,
questo stamperà le informazioni e quindi chiuderà l'applicazione.
In questo momento, sento che va bene gestirlo che in seguito,
vedremo come possiamo avere un modo globale di gestire tutti gli errori quando
implementiamo nella prossima lezione un altro modo di accedere al database MongoDB.
Ora, dopo averlo fatto,
ho intenzione di implementare,
ho intenzione di registrare semplicemente queste informazioni.
Quindi dirò, registro della console e inserirlo.
Quindi, questa informazione verrà stampata sullo schermo qui, inserita.
Ora di nuovo, ricorda i punti e virgola e tutto ciò che
è importante non dimenticarli quando stai digitando il tuo codice.
Quindi, dirò risultato inserito.
Questo oggetto risultato che viene restituito,
avrà su di esso una proprietà denominata proprietà result
e questa proprietà conterrà un valore.
Questa proprietà risultato è anche un oggetto JavaScript,
e questo conterrà una proprietà n che ci dice quanti documenti sono stati inseriti.
Quindi questa è l'informazione che sto per stampare qui,
e poi passeremo alla riga successiva e
diremo «documenti nella collezione».
Ora, questo è solo un modo per informare l'utente che questa operazione è avvenuta correttamente,
e quindi passerà quel risultato alla nostra funzione di chiamata.
Quindi, chiameremo il callback e quindi il risultato sarà il parametro per il callback.
Quindi, quando implementiamo l'utilizzo di questa funzione nel nostro file index.js,
forniremo il callback lì che
riceverà il risultato come parametro in arrivo.
Quindi, questo è per il «InsertDocument».
Ora, per il «FindDocument
», quello che sto per fare è dire,
«coll.find» e ho intenzione di trovare tutti i documenti.
Quindi, ecco perché darò un oggetto JavaScript vuoto qui,
che corrisponderà a tutti i documenti nella raccolta e poi dirò,
«toArray» e questo prenderà come parametro una funzione di callback,
e all'interno di questa funzione di callback, ovviamente,
affermerò che questo non è nullo,
e poi diremo, «documenti di callback».
Passeremo semplicemente indietro i documenti recuperati alla funzione chiamante.
Ora, per il «RemoveDocument», ho intenzione di dire, «collezione DeleteOne.»
Quindi, cercherò di trovare il primo documento che
corrisponde a ciò che abbiamo specificato e quindi eliminarlo.
E poi questo richiederà, ancora una volta,
una funzione di callback come secondo parametro,
e all'interno di questa funzione di callback,
la prima cosa che controllo è assicurarsi che l'errore non sia nullo.
E poi dopo di ciò, diremo,
«il log della console ha rimosso il documento virgola.»
Abbiamo usato la virgola qui perché si tratta di un oggetto JavaScript quindi,
se si specifica il log della console in questo modo,
il documento verrà stampato e quindi passeremo
quel risultato attraverso la funzione di callback.
E poi finalmente, per l'aggiornamento coll.UpdateOne.
Questo è un metodo supportato dal driver MongoDB.
Quindi, dirò, «update.one document
", e il secondo parametro è dove
passeremo nei campi che devono essere aggiornati.
E il modo in cui è fatto,
diremo, «dollaro set colon update».
Quindi, questo prenderà le informazioni di aggiornamento che
sto inviando e quindi le passerà in update.one.
Il primo è il documento che deve essere aggiornato.
Il secondo è quali campi del documento devono essere aggiornati qui.
E il terzo parametro è nullo,
e quell'ultimo parametro è una funzione di callback,
che ovviamente ci darà il risultato dell'operazione.
Quindi, la prima cosa che ho intenzione di controllare per assicurarmi che l'errore non sia nullo.
Quindi, eseguirò un «registro della console aggiornato il documento con».
Ora di nuovo, i log della console sono puramente per noi per
garantire che il codice stia facendo quello che sta facendo.
Non aiuta in alcun modo.
Questo è solo per nostra informazione.
In un server di produzione,
non avresti questi registri della console, forse.
Puoi disabilitarli. Quindi, questo è tutto.
Quindi quattro metodi supportati in questo particolare modulo nodo basato su file inserire,
trovare, rimuovere e aggiornare.
Quindi, ora che abbiamo implementato questo modulo nodo basato su file,
andiamo al file index.js,
e quindi per fare uso di quel modulo nodo basato su file,
ho bisogno di questo qui.
Quindi, dirò, «const dboper richiede.»
Poiché si tratta di un modulo nodo basato su file, si ottiene il percorso completo del modulo nodo,
e che in questo caso è. /operations
perché si trova nella stessa cartella del mio file index.js.
Ora, una volta fatto questo,
allora proprio qui, questa funzione,
questo codice che stavamo facendo per accedere al database ora inserire,
useremo il dboper che abbiamo appena implementato per accedere a quel database.
Quindi, diremo, «dboper insert document,
" e questo «insert document» prende il db come primo parametro.
Il db qui, è questo db che è entrato quando chiamiamo MongoClient connect. In
modo che db venga passato, in modo che
il mio modulo del nodo operativo sappia dove accedere al database.
Quindi il secondo parametro è il,
quindi se guardi il «inserisci documento» vedrai
che il secondo parametro è il documento da inserire.
Quindi, dirò, «nome. «
Ho solo intenzione di costruire un oggetto JSON o un oggetto JavaScript qui,
che verrà automaticamente mappato nell'oggetto adiacente quando viene inserito.
E il terzo parametro, come vedi,
«raccolta di documenti db e callback».
Quindi il terzo parametro è la collezione e la collezione è
la collezione di piatti e quello finale è il callback.
La richiamata di nuovo come si ricorda riceve il risultato.
Se si guarda indietro al bambino implementato il documento di inserimento,
il callback ha ricevuto il risultato come parametro.
Quindi all'interno di questo callback gestiremo quel valore del risultato qui.
Quindi, quando arriva il valore del risultato faremo un console.log.
Diciamo inserire il documento
backslash N e diremo risultato OPS.
L' OPS indica il numero di operazioni di inserimento eseguite.
Quindi questo è un altro oggetto che sarà sull'
oggetto JavaScript risultato che viene passato come
parametro e quindi ho intenzione di stampare quel valore.
Quindi questo ci dara' qualche informazione su quello che e' successo.
Ora, una volta completato,
all'interno di questa funzione di callback chiamerò la prossima operazione di database.
Quindi dirò dboper e poi troverò i documenti.
Quindi dirò dbserve e il terzo parametro è docs,
che è la funzione di callback.
Quando ricevo i documenti, farò un
console.log dicendo documenti trovati,
e bloccheremo semplicemente i documenti sullo schermo.
Quindi, questo stamperà i documenti trovati.
Si noti che questa chiamata si trova
all'interno della funzione di callback applicata per la chiamata di funzione precedente,
quindi è qualcosa che voglio che tu noti in modo specifico.
Ora, di nuovo all'interno di questa chiamata di funzione hanno bisogno di farlo in questo modo perché finché non
viene chiamato questo callback non possiamo fare la prossima operazione.
Quindi, in quella prossima operazione aggiornerò il documento che ho appena inserito.
Quindi dirò aggiorna il documento e dirò Aggiorna DB documento,
e quindi il prossimo parametro è il documento
e non ho bisogno di specificare l'intero documento posso specificare solo un campo e
quindi troverà il documento che corrisponde a questo particolare campo.
Quello che ho intenzione di fare è il prossimo parametro è l'aggiornamento che deve essere fornito.
Quindi, l'aggiornamento è quale campo voglio aggiornare,
quindi aggiornerò
il campo di descrizione dicendo Test aggiornato,
e quindi il quarto è la raccolta che è Dips,
e quello finale è la funzione di callback che ottiene
i documenti come valore di ritorno o
meglio risultato dell'operazione di aggiornamento che abbiamo appena eseguito.
Quindi all'interno di questa funzione di callback,
farò di nuovo un console.log dicendo
backslash del documento aggiornato N. Il documento aggiornato verrà
restituito in result.result su
questa proprietà dell'oggetto risultato che viene passato il monitoraggio.
Ancora una volta nota come le chiamate vengono annidate
all'interno delle funzioni di callback qui.
Voglio che tu noti questa struttura del codice
in particolare perché questo è ciò a cui tornerò nel prossimo esercizio.
Ora, dopo averlo fatto,
troverò i documenti,
quindi lasciami copiare e poi userò lo stesso codice qui.
Quindi dirò, trova documenti.
Qui dentro ho di nuovo intenzione di dire, trovato documento aggiornato.
Poi finalmente quando ho finito con questo,
chiamerò semplicemente db drop collection.
Quindi ho intenzione di eliminare questa collezione di piatti in modo
da pulire il mio database in modo da non avere
nulla di più perché per il prossimo esercizio voglio pulire
il database e quindi iniziare con un database più pulito.
Quindi, ho intenzione di pulire
la collezione di piatti e quindi questo si tradurrebbe in una richiamata.
Quindi dentro qui ho intenzione di fare un dicendo console.log,
raccolta abbandonata, e poi stamperò il risultato che è arrivato.
Quindi, infine, chiudere il database.
Si noti che la struttura del codice, il
documento di inserimento DB e all'interno della funzione di callback chiamerò
la funzione successiva e
all'interno del callback off che chiamerò
la funzione successiva e all'interno della funzione di callback successiva e così via.
Quindi, vedi un set nidificato di callback qui e
un set nidificato strutturato ad albero di richiami qui.
E' una cosa a cui voglio che tu presti attenzione.
Salviamo le modifiche e andiamo a guardare questa versione della nostra applicazione.
Tornando al terminale,
lasciami eseguire l'applicazione.
Quindi fammi digitare NPM start e vedremo quel risultato.
Ora, da questo risultato si può vedere che il documento è
inserito nella raccolta e che è il documento che è stato trovato.
Nel secondo passaggio,
stiamo trovando il documento in modo che quando chiamiamo il documento DB find,
quindi questo è il documento che viene recuperato dalla mia collezione.
Quindi gli chiedo di aggiornare il documento con
questo e poi noterai che dice documento aggiornato e poi
qui stampa il risultato o OPS e dice N è uguale a
un numero modificato come uno ed è andato bene.
Poi stampa il documento aggiornato,
troviamo il documento aggiornato qui e questo è ciò che viene stampato qui,
e notare in particolare che la descrizione è stata aggiornata.
Poi, alla fine, ha lasciato cadere la collezione.
Quindi vediamo come questa applicazione viene eseguita ed è in grado di fare uso
del modulo nodo che abbiamo implementato e quindi eseguito varie operazioni di database.
Con questo completiamo questo esercizio.
In questo esercizio ti ho dimostrato come interagiresti con
il tuo server MongoDB dalla tua applicazione nodo.
Abbiamo implementato il nostro modulo nodo qui e poi utilizzato
all'interno della nostra applicazione nodo incapsulando
alcune delle operazioni di database in quel modulo nodo.
Questo è un buon momento per fare un commit Git con
il nodo messaggio MongoDB esempio parte due.