Uno dei vantaggi più significativi dell'utilizzo di MongoDB per gli sviluppatori web è la sua eccellente integrazione con JavaScript. MongoDB fornisce un driver JavaScript nativo che consente agli sviluppatori di interagire con il database direttamente utilizzando il codice JavaScript. Ora, è necessario installare il driver MongoDB Node.js sulla macchina prima di poter iniziare a creare le applicazioni MongoDB in JavaScript. Dobbiamo usare il seguente comando per questo:
npm e mongodbIl driver ci consente di interagire con MongoDB dal tuo codice JavaScript ed eseguire varie operazioni come la connessione al database, l'inserimento dei dati, l'interrogazione dei dati e l'aggiornamento dei dati.
Esempio 1: sviluppare una connessione MongoDB con JavaScript
Inizia stabilendo la connessione con il server MongoDB con JavaScript che può essere realizzato utilizzando il modulo “npm” come discusso in precedenza.
cost { MongoClient } = richiedere ( 'mongodb' ) ;
cost URL = 'mongodb:// 127.0.0.1:27017 ' ;
cost cliente = nuovo MongoClient ( URL ) ;
cost dbNome = 'Il mio DB' ;
asincrono funzione principale ( ) {
attendere il cliente. Collegare ( ) ;
consolle. tronco d'albero ( 'Connesso al server con successo' ) ;
cost db = cliente. db ( dbNome ) ;
cost collezione = db. collezione ( 'Persone' ) ;
ritorno 'Fatto.' ;
}
principale ( )
. Poi ( consolle. tronco d'albero )
. presa ( consolle. errore )
. Finalmente ( ( ) => cliente. vicino ( ) ) ;
Per prima cosa importiamo il MongoClient richiesto dal modulo 'mongodb' nel nostro file 'File.js'. Definiamo quindi l'URL di connessione per il server MongoDB (url) e creiamo una nuova istanza MongoClient utilizzando l'URL specificato.
Successivamente specifichiamo il nome del database MongoDB (dbName) da utilizzare nella connessione. Successivamente, la funzione asincrona main() gestisce le operazioni principali sul server MongoDB. Qui ci connettiamo al server MongoDB utilizzando wait client.connect(). Questa è un'operazione asincrona, quindi la funzione viene sospesa finché la connessione non viene stabilita correttamente. Possiamo visualizzare il messaggio che appare sul prompt una volta che la connessione è stata stabilita con successo. Otteniamo un riferimento al database con il nome specificato in 'dbName' utilizzando client.db(dbName).
Quindi, otteniamo un riferimento alla raccolta denominata 'Persons' utilizzando db.collection('Persons'). Dopo aver definito la funzione main(), chiamiamo main() per eseguire le operazioni. Se la funzione main() si risolve con successo, stampa il risultato (in questo caso, è la stringa 'done') utilizzando .then(console.log). Se si verifica un errore durante l'esecuzione, rileva l'errore e lo stampa utilizzando .catch(console.error). Infine, garantisce che la connessione client MongoDB venga chiusa utilizzando .finally(() => client.close()).
Pertanto, il prompt mostra il messaggio in cui è stata stabilita la connessione MongoDB nel file JavaScript:
Esempio 2: inserire un documento MongoDB con JavaScript
Ora che la connessione è stata stabilita con il server MongoDB, possiamo utilizzare le query MongoDB con JavaScript. Qui applichiamo la query di inserimento per inserire il singolo documento.
cost { MongoClient } = richiedere ( 'mongodb' ) ;cost URL = 'mongodb:// 127.0.0.1:27017 ' ;
cost cliente = nuovo MongoClient ( URL ) ;
cost dbNome = 'Il mio DB' ;
asincrono funzione principale ( ) {
cost db = cliente. db ( dbNome ) ;
cost collezione = db. collezione ( 'utenti' ) ;
cost inserisciDoc =
attendono il ritiro. insertOne ( { nome : 'Andrea' , età : 23 } ) ;
consolle. tronco d'albero ( 'Documento inserito =' , inserisciDoc ) ;
ritorno 'Fatto.' ;
}
principale ( )
. Poi ( consolle. tronco d'albero )
. presa ( consolle. errore )
. Finalmente ( ( ) => cliente. vicino ( ) ) ;
Definiamo la funzione main() come una funzione asincrona che esegue l'operazione di inserimento nel database. Al suo interno, ci colleghiamo al server MongoDB utilizzando l'istanza MongoClient e l'URL. Quindi, accediamo al database specificato (MyDB) utilizzando client.db(dbName) e otteniamo la raccolta 'users' dal database utilizzando db.collection('users').
Successivamente, inseriamo un documento con il nome dei campi 'Andrew' e l'età di 23 anni nella raccolta 'users' utilizzando collection.insertOne(). Il metodo insertOne() restituisce una promessa che si risolve con il risultato dell'inserimento. Il documento aggiunto viene visualizzato utilizzando console.log. Infine, chiudiamo la connessione client MongoDB.
Il documento inserito nella raccolta di database MongoDB è stato inserito correttamente come mostrato nel seguente output:
Esempio 3: trova un documento MongoDB con JavaScript
Allo stesso modo, possiamo applicare la query “find” di MongoDB con JavaScript per trovare il documento dalla raccolta creata nell'esempio precedente.
cost { MongoClient } = richiedere ( 'mongodb' ) ;cost URL = 'mongodb:// 127.0.0.1:27017 ' ;
cost cliente = nuovo MongoClient ( URL ) ;
cost dbNome = 'Il mio DB' ;
asincrono funzione principale ( ) {
cost db = cliente. db ( dbNome ) ;
cost collezione = db. collezione ( 'utenti' ) ;
cost findQuery = { nome : 'Andrea' } ;
cost trovaDoc = attendono il ritiro. Trovare ( findQuery ) . toArray ( ) ;
consolle. tronco d'albero ( 'Documento =' , trovaDoc ) ;
}
principale ( )
. Poi ( consolle. tronco d'albero )
. presa ( consolle. errore )
. Finalmente ( ( ) => cliente. vicino ( ) ) ;
Iniziamo con la dimostrazione dalla funzione principale in cui ci connettiamo prima al server MongoDB utilizzando l'istanza MongoClient creata e l'URL specificato. Quindi, accediamo al database MyDB utilizzando client.db(dbName) dove dbName è il nome del database precedentemente definito.
Successivamente, otteniamo un riferimento alla raccolta 'users' dal database utilizzando db.collection('users'). Viene creato un oggetto query denominato “findQuery” che specifica che i documenti da recuperare debbano avere il campo nome uguale a “Andrew”. Successivamente, eseguiamo una query di 'trova' sulla raccolta 'utenti' utilizzando collection.find(findQuery) che restituisce un cursore ai documenti corrispondenti.
La parola chiave 'await' viene utilizzata prima di collection.find() per garantire che il risultato venga risolto prima di procedere. Il risultato dell'operazione di ricerca viene convertito in un array di documenti utilizzando toArray() e i documenti trovati vengono archiviati nella variabile 'findDoc'. I documenti vengono quindi registrati sulla console utilizzando console.log.
Di conseguenza, il documento trovato della raccolta MongoDB viene visualizzato al momento dell'esecuzione:
Esempio 4: aggiornamento di un documento MongoDB con JavaScript
Successivamente, eseguiamo l'operazione di 'aggiornamento' in JavaScript per aggiornare il documento specificato della raccolta MongoDB.
cost { MongoClient } = richiedere ( 'mongodb' ) ;cost URL = 'mongodb:// 127.0.0.1:27017 ' ;
cost cliente = nuovo MongoClient ( URL ) ;
cost dbNome = 'Il mio DB' ;
asincrono funzione principale ( ) {
cost db = cliente. db ( dbNome ) ;
cost collezione = db. collezione ( 'utenti' ) ;
cost updateQuery = { nome : 'Andrea' } ;
cost nomeaggiornamento = { $impostato : { nome : 'Lui stesso' } } ;
cost aggiornamentoRisultato = attendono il ritiro. aggiornamentoUno ( updateQuery , nomeaggiornamento ) ;
consolle. tronco d'albero ( 'Documento aggiornato =' , aggiornamentoRisultato ) ;
ritorno 'Fatto' ;
}
principale ( )
. Poi ( consolle. tronco d'albero )
. presa ( consolle. errore )
. Finalmente ( ( ) => cliente. vicino ( ) ) ;
Per aggiornare un documento nella raccolta “users”, invochiamo la funzione main(). Prepariamo quindi una query di 'aggiornamento' utilizzando { nome: 'Andrew' } per trovare il documento con il campo nome uguale a 'Andrew'. Successivamente, impostiamo il campo del nome del documento corrispondente su 'Sam' utilizzando { $set: { name: 'Sam' } }.
Definiamo la query 'update' e l'operazione 'update' per eseguire l'aggiornamento utilizzando collection.updateOne(updateQuery, updateName). Il metodo updateOne() aggiorna il primo documento che corrisponde alla query 'update' e restituisce un oggetto che rappresenta il risultato dell'aggiornamento. La variabile 'updateResult' contiene il risultato dell'azione di aggiornamento.
La schermata di output successiva mostra i risultati della query aggiornata:
Esempio 5: eliminare un documento MongoDB con JavaScript
Infine, utilizziamo il metodo delete di MongoDB per eliminare il documento precedente da MongoDB all'interno di JavaScript.
cost { MongoClient } = richiedere ( 'mongodb' ) ;cost URL = 'mongodb:// 127.0.0.1:27017 ' ;
cost cliente = nuovo MongoClient ( URL ) ;
cost dbNome = 'Il mio DB' ;
asincrono funzione principale ( ) {
cost db = cliente. db ( dbNome ) ;
cost collezione = db. collezione ( 'utenti' ) ;
cost deleteQuery = { nome : 'Lui stesso' } ;
cost deleteResult = attendono il ritiro. eliminaUno ( deleteQuery ) ;
consolle. tronco d'albero ( 'Documento eliminato =' , deleteResult ) ;
ritorno 'Fatto' ;
}
principale ( )
. Poi ( consolle. tronco d'albero )
. presa ( consolle. errore )
. Finalmente ( ( ) => cliente. vicino ( ) ) ;
Creiamo un oggetto query 'delete' denominato 'deleteQuery' che specifica i criteri per i documenti da eliminare. In questo caso, cerca i documenti il cui campo nome è uguale a “Sam”. Dopo aver preparato la query di eliminazione, applichiamo l'effettiva operazione di eliminazione utilizzando il metodo deleteOne() dell'oggetto della raccolta.
Passiamo 'deleteQuery' come argomento a 'deleteOne' che elimina il primo documento corrispondente che soddisfa i criteri specificati nella query. La variabile 'deleteResult' contiene il risultato dell'azione di eliminazione.
Il documento specificato viene eliminato dalla raccolta MongoDB utilizzando il file 'javascript':
Conclusione
Ora abbiamo una conoscenza fondamentale su come utilizzare MongoDB con JavaScript tramite il driver MongoDB Node.js. Abbiamo dimostrato tutto con le diverse operazioni di Mongo DB, dalla connessione alla cancellazione del documento con JavaScript. Da qui, possiamo creare applicazioni più complesse e integrare MongoDB nei progetti Node.js secondo necessità.