DEV Community: Md Nazmul Islam

CRUD Operation

Md Nazmul Islam — Sat, 25 Dec 2021 13:55:49 +0000

MongoDB is a document-oriented database program widely classified as a NoSQL database program.
In MongoDB, the CRUD operation refers to the creating, reading, updating, and deleting documents. Here is an explanation of the operations in detail:

Create
Create (or insert) operations add new documents to a collection. There are two ways to add new documents to a collection:

db.collection.insertOne()
db.collection.insertMany() insertOne() operation allows us to create individual documents in a collection, while the insertMany() operation is used to create multiple documents in a single operation.

Example 1:
Here is an example of how we can add a single car to the cars collection using the insertOne() operation:

db.cars.insertOne(
//inserting Bugatti Veyron Mansory Vivere-2005 into cars collection
    {
       name: "Bugatti Veyron Mansory Vivere"
       model: "2005"
    }
)

Example 2:
Now we will see how we can add info of multiple cars to the cars collection with a single operation using insertMany().

db.cars.insertMany([{
//inserting three cars along with their models into cars collection
       name: "Bugatti Veyron Mansory Vivere"
       model: "2005"
},{
       name: "Aston Martin AM-RB 001"
       model: "2018"
},{
       name: "Ferrari Pininfarina Sergio"
       model: "2013"
}])

Read
Read operations retrieve documents from a collection. Here is the method in Mongodb to retrieve information:

db.collection.find()
find() operation will return everything from a collection if you call it without any parameters. On the other hand, we can specify any filter or criteria to retrieve information from a collection using:
db.collection.find(query)
Example:
Here is an example of how we can read information about all cars from the cars collection:
db.cars.find() // no parameters

Output:

{ "_id" : ObjectId("1"), "name" : "Bugatti Veyron Mansory Vivere", "model" : "2005" }
{ "_id" : ObjectId("2"), "name" : "Aston Martin AM-RB 001", "model" : "2018" }
{ "_id" : ObjectId("3"), "name" : "Ferrari Pininfarina Sergio", "2013" : "2005" }

Update

Update operations modify existing documents in a collection. There are three ways to update documents of a collection:

db.collection.updateOne()
– Updates one field in the document where the given criteria or filter meets the condition. Updating a field will not remove the old field instead a new field will be added to the document.
db.collection.updateMany()
– Updates all fields in the document where the given criteria or filter meets the condition.
db.collection.replaceOne()
– Replace the entire document. It will replace the old fields and values with new ones.
Example: if we have the following document:

{
   "_id" : ObjectId("1"),
   "model" : 2005
}

Using:
replaceOne({"_id" : ObjectId("1")}, { "new_model" : 2020})
will result in:

{
   "_id" : ObjectId("1"),
   "new_model" : 2020
}

While using:
updateOne({"_id" : ObjectId("1")}, {$set: { "new_model" : 2020}})
Will result in:

{
   "_id" : ObjectId("1"),
   "model" : 2005,
   "new_model" : 2020
}

While using:
updateMany({"_id" : ObjectId("1")}, {$set: { "name" : "NewName"}, $set: { "new_model" : 2020}})
will result in:

{
   "_id" : ObjectId("1"),
   "model" : 2005,
   "new_model" : 2020
   "name" : "newName"
}

Delete
Delete operations delete documents from a collection. There are two methods to delete documents of a collection:

db.collection.deleteOne()
db.collection.deleteMany() deleteOne() method removes only the first document matched by the query filter document, and deleteMany() deletes multiple objects at once. Example 1: Here is an example of how we can remove only one car having the model “2013” from the cars collection: db.cars.deleteOne( //deletes one car having model "2013" { "model": "2013" } ) Example 2: Here is an example of how all cars, having the model “2013” - can be deleted from the cars collection:

db.cars.deleteMany(
//delete all cars having model "2013"
    { "model": "2013" }
)

JavaScript try - catch - finally Statement

Md Nazmul Islam — Mon, 20 Dec 2021 09:45:44 +0000

The try, catch and finally blocks are used to handle exceptions (a type of an error). Before you learn about them, you need to know about the types of errors in programming.

JavaScript try...catch Statement:
The try...catch statement is used to handle the exceptions. Its syntax is:

try {
    // body of try
} 
catch(error) {
    // body of catch  
}

The main code is inside the try block. While executing the try block, if any error occurs, it goes to the catch block. The catch block handles the errors as per the catch statements.

If no error occurs, the code inside the try block is executed and the catch block is skipped.

JavaScript try...catch...finally Statement:
You can also use the try...catch...finally statement to handle exceptions. The finally block executes both when the code runs successfully or if an error occurs.

The syntax of try...catch...finally block is:

try {
    // try_statements
} 
catch(error) {
    // catch_statements  
}
finally() {
    // codes that gets executed anyway
}

Note: You need to use catch or finally statement after try statement. Otherwise, the program will throw an error.

JavaScript try...catch in setTimeout:
The try...catch won't catch the exception if it happened in "timed" code, like in setTimeout(). For example:

try {
    setTimeout(function() {
        // error in the code
    }, 3000);
} catch (e) {
  console.log( "won't work" );
}

The above try...catch won't work because the engine has already left the try..catch construct and the function is executed later.

The try..catch block must be inside that function to catch an exception inside a timed function. For example,

setTimeout(function() {
    try {
        // error in the code
    } catch {
        console.log( "error is caught" );
    }
}, 3000);

You can also use the throw statement with the try...catch statement to use user-defined exceptions. For example, a certain number is divided by 0. If you want to consider Infinity as an error in the program, then you can throw a user-defined exception using the throw statement to handle that condition.

2 Essential CSS Properties

Md Nazmul Islam — Sun, 19 Dec 2021 15:10:48 +0000

1.Grid

CSS Grid Layout is used to divide a page into major parts.

Like tables, grid layout make an author to align elements into columns and rows. However, by the use of CSS grid we can easily make attractive looked webpages. By using it we can easily make responsive website with pixcl perfection.

Example:

HTML:

CSS:

Output:

2.Flex

The flex CSS shorthand property is the combination of flex-grow, flex-shrink, and flex-basis property. It is used to set the length of flexible items. The flex property is much responsive and mobile-friendly. It is easy to position child elements and the main container. The margin doesn’t collapse with the content margins. The order of any element can be easily changed without editing the HTML section.

Syntax: