DEV Community: Anurag Affection

Get API & Fetching Data from MongoDB in Go - 05

Anurag Affection — Sat, 18 May 2024 07:42:24 +0000

First check the Go version by running the command

go version

Create a folder

mkdir <folder_name>

Switch to created folder

cd <folder_name>

Initialize the go project by running the given command. You will get go.mod file.

go mod init <folder_name>

Create a main.go file, use terminal or bash

notepad main.go 
touch main.go

Let's write some basic code in main.go file.

package main 

import (
    "fmt"
)


func main () {
    fmt.Println("Hello From Go")
}

Run the code by following command

go run main.go

You will see this output in console

Hello From Go

Install some packages to connect MongoDB. Here are commands

go get go.mongodb.org/mongo-driver
go get go.mongodb.org/mongo-driver/mongo

Revisit the main.go file to connect MongoDB. Add some code to connect MongoDB. This is how it will look after adding.

package main 

// package importing
import (
    "fmt"

    "log"
    "context"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)


// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}



// entry point 
func main () {
    fmt.Println("Hello From Go")
}

Run the code by following command

go run main.go

You will see this output in console

Connected to MongoDB!
Hello From Go

Till, Our MongoDB is connected. Now let's add some data. We are going to add movie data. So, let's make a movie structure.

// movie model or structure 
type Movie struct {
    ID    string `json:"id"`
    Title string `json:"title"`
}

Now write a function to add movie to database.

// to add movie to db
func addMovie(id, title string) {

    movie := Movie{
        ID:    id,
        Title: title,
    }

    _, err := collection.InsertOne(ctx, movie)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Movie added successfully!")
}

Call the addMovie function to main function.

addMovie("1", "Captain America")

This is how our code will look like after completing above steps

package main 

// package importing
import (
    "fmt"

    "log"
    "context"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)




// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}



// movie model or structure 
type Movie struct {
    ID    string `json:"id"`
    Title string `json:"title"`
}


// to add movie to db
func addMovie(id, title string) {

    movie := Movie{
        ID:    id,
        Title: title,
    }

    _, err := collection.InsertOne(ctx, movie)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Movie added successfully!")
}




// entry point 
func main () {
    fmt.Println("Hello From Go")

    // callig addMovie 
    addMovie("1", "Captain America")
}

Run the code by following command

go run main.go

You will see this output in console

Connected to MongoDB!
Hello From Go
Movie added successfully!

We have successfully added some data to MongoDB, you can verify in your database, which is your localhost.

mongodb://localhost:27017/

Now import these packages

"encoding/json"
"net/http"
"go.mongodb.org/mongo-driver/bson"

This how our import will look like

// package importing
import (
    "fmt"

    "log"
    "context"

    "encoding/json"
    "net/http"

        "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

Now write a function to getAllMovies. Here is the code

// api to get all movies
func getAllMovies(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    // Define a slice to store the decoded documents
    var movies []Movie

    // Find all movies in the collection
    cursor, err := collection.Find(ctx, bson.M{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(ctx)

    // Iterate through the cursor and decode each document
    for cursor.Next(ctx) {
        var movie Movie
        if err := cursor.Decode(&movie); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        movies = append(movies, movie)
    }

    // Check for cursor errors after iterating
    if err := cursor.Err(); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // Encode the movies slice as JSON and write it to the response
    if err := json.NewEncoder(w).Encode(movies); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

Call the getAllMovies with route in main, also run the server.

        // api to getAllMovies 
    http.HandleFunc("/movies", getAllMovies)

    // our server on port on 8000
    http.ListenAndServe(":8000", nil)

Let's have a full code, after completing all the above steps

package main 

// package importing
import (
    "fmt"

    "log"
    "context"

    "encoding/json"
    "net/http"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)




// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}



// movie model or structure 
type Movie struct {
    ID    string `json:"id"`
    Title string `json:"title"`
}


// to add movie to db
func addMovie(id, title string) {

    movie := Movie{
        ID:    id,
        Title: title,
    }

    _, err := collection.InsertOne(ctx, movie)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Movie added successfully!")
}





// api to get all movies
func getAllMovies(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    // Define a slice to store the decoded documents
    var movies []Movie

    // Find all movies in the collection
    cursor, err := collection.Find(ctx, bson.M{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(ctx)

    // Iterate through the cursor and decode each document
    for cursor.Next(ctx) {
        var movie Movie
        if err := cursor.Decode(&movie); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        movies = append(movies, movie)
    }

    // Check for cursor errors after iterating
    if err := cursor.Err(); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // Encode the movies slice as JSON and write it to the response
    if err := json.NewEncoder(w).Encode(movies); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}






// entry point 
func main () {
    fmt.Println("Hello From Go")

    // callig addMovie 
    addMovie("1", "Captain America")

    // api to getAllMovies 
    http.HandleFunc("/movies", getAllMovies)

    // visit this url in browser
    fmt.Println("Your Server is running on http://localhost:8000")

    // our server on port on 8000
    http.ListenAndServe(":8000", nil)
}

Run the code by following command

go run main.go

You will see this output in console

Connected to MongoDB!
Hello From Go
Movie added successfully!
Your Server is running on http://localhost:8000

Visit http://localhost:8000/movies on browser to verify the API. This what you will get.

[
    {
        "id": "1",
        "title": "The Shawshank Redemption"
    },
    {
        "id": "1",
        "title": "The Shawshank Redemption"
    },
    {
        "id": "1",
        "title": "Captain America"
    },
    {
        "id": "1",
        "title": "Captain America"
    },
    {
        "id": "1",
        "title": "Captain America"
    },
    {
        "id": "1",
        "title": "Captain America"
    }
]

That's for this article. Thank You.

Storing Data in MongoDB with Go - 04

Anurag Affection — Sat, 18 May 2024 07:03:11 +0000

First check the Go version by running the command

go version

Create a folder

mkdir <folder_name>

Switch to created folder

cd <folder_name>

Initialize the go project by running the given command. You will get go.mod file.

go mod init <folder_name>

Create a main.go file, use terminal or bash

notepad main.go 
touch main.go

Let's write some basic code in main.go file.

package main 

import (
    "fmt"
)


func main () {
    fmt.Println("Hello From Go")
}

Run the code by following command

go run main.go

You will see this output in console

Hello From Go

Install some packages to connect MongoDB. Here are commands

go get go.mongodb.org/mongo-driver
go get go.mongodb.org/mongo-driver/mongo

Revisit the main.go file to connect MongoDB. Add some code to connect MongoDB. This is how it will look after adding.

package main 

// package importing
import (
    "fmt"

    "log"
    "context"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)


// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}



// entry point 
func main () {
    fmt.Println("Hello From Go")
}

Run the code by following command

go run main.go

You will see this output in console

Connected to MongoDB!
Hello From Go

Till, Our MongoDB is connected. Now let's add some data. We are going to add movie data. So, let's make a movie structure.

// movie model or structure 
type Movie struct {
    ID    string `json:"id"`
    Title string `json:"title"`
}

Now write a function to add movie to database.

// to add movie to db
func addMovie(id, title string) {

    movie := Movie{
        ID:    id,
        Title: title,
    }

    _, err := collection.InsertOne(ctx, movie)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Movie added successfully!")
}

Call the addMovie function to main function.

addMovie("1", "Captain America")

This is how our code will look like after completing above steps

package main 

// package importing
import (
    "fmt"

    "log"
    "context"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)




// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}



// movie model or structure 
type Movie struct {
    ID    string `json:"id"`
    Title string `json:"title"`
}


// to add movie to db
func addMovie(id, title string) {

    movie := Movie{
        ID:    id,
        Title: title,
    }

    _, err := collection.InsertOne(ctx, movie)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Movie added successfully!")
}




// entry point 
func main () {
    fmt.Println("Hello From Go")

    // callig addMovie 
    addMovie("1", "Captain America")
}

Run the code by following command

go run main.go

You will see this output in console

Connected to MongoDB!
Hello From Go
Movie added successfully!

We have successfully added some data to MongoDB, you can verify in your database, which is your localhost.

mongodb://localhost:27017/

That's for this article. Thank You.

Connecting MongoDB in Go - 03

Anurag Affection — Fri, 17 May 2024 05:21:05 +0000

First check the Go version by running the command

go version

Create a folder

mkdir <folder_name>

Switch to created folder

cd <folder_name>

Initialize the go project by running the given command. You will get go.mod file.

go mod init <folder_name>

Create a main.go file, use terminal or bash

notepad main.go 
touch main.go

Let's write some basic code in main.go file.

package main 

import (
    "fmt"
)


func main() {
    fmt.Println("MongoDb with Go")
}

Run the code by following command

go run main.go

You will see this output in console

MongoDb with Go

Install some packages to connect MongoDB in Go. Here are commands

go get go.mongodb.org/mongo-driver
go get go.mongodb.org/mongo-driver/mongo

Revisit the main.go file to connect MongoDB. This is our full code

package main

import (
    "context"
    "fmt"
    "log"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

// mongodb connections
var collection *mongo.Collection
var ctx = context.TODO()

func init() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // check connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection = client.Database("testingWithGo").Collection("movies")
}

func main() {
    fmt.Println("MongoDb with Go")
}

Run the code by following command again

go run main.go

You will see this output in console

Connected to MongoDB!
MongoDb with Go

That's for today. Thank You .

Creating Simple Server in Go - 02

Anurag Affection — Thu, 16 May 2024 15:12:21 +0000

First check the Go version by running the command

go version

Create a folder

mkdir <folder_name>

Switch to created folder

cd <folder_name>

Initialize the go project by running the given command. You will get go.mod file.

go mod init <folder_name>

Create a main.go file, use terminal or bash

notepad main.go 
touch main.go

Let's write some basic code in main.go file.

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello From Go \n")
    fmt.Fprintf(w, "You are on %s route", r.URL.Path)
}

func main() {
    fmt.Println("Your Server is running on http://localhost:8000")
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8000", nil)

}

/*
--- 1. fmt ,       for formattting
--- 2. net/http ,  for creating server
--- both are standard package from go 

The fmt.Fprintf function expects at least two arguments:
1. an io.Writer (w)
2. a format specifier
3. optional arguments

*/

Run the code by following command

go run main.go

You will see this output in console

Your Server is running on http://localhost:8000

Visit http://localhost:8000on browser & try to change path of URL. You will see

Hello From Go 
You are on / route

This was our simple server using Go.
That's for today. Thank You.

Simple Project Setup in Go - 01

Anurag Affection — Thu, 16 May 2024 06:56:02 +0000

First check the Go version by running the command

go version

Create a folder

mkdir <folder_name>

Switch to created folder

cd <folder_name>

Initialize the go project by running the given command. You will get go.mod file.

go mod init <folder_name>

Create a main.go file

notepad main.go 
touch main.go

Let's write some basic code in main.go file.

package main 

import (
    "fmt"
)


func main () {
    fmt.Println("Hello From Go")
}

Run the code by following command

go run main.go

You will see this output in console

Hello From Go

That's for today. Thank You .

The three dots (...) in JavaScript

Anurag Affection — Fri, 19 Apr 2024 15:32:15 +0000

The three dots (...) in JavaScript are typically used for two purposes:

1. Spread Syntax:

It allows an iterable (like an array or a string) to be expanded into individual elements. For example:

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5]; // arr2 is [1, 2, 3, 4, 5]

2. Rest Parameters:

It collects all remaining elements into an array. For example:

function sum(...numbers) {
    return numbers.reduce((acc, curr) => acc + curr, 0);
}
sum(1, 2, 3); // returns 6

Object Rest Properties

It's a feature introduced in ECMAScript 2018 (ES9). It allows you to extract all the remaining properties of an object into a new object. Here's how it works:

const obj = { a: 1, b: 2, c: 3 };
const { a, ...rest } = obj;

console.log(a); // 1
console.log(rest); // { b: 2, c: 3 }

JSON vs OBJECT in Javascript

Anurag Affection — Wed, 10 Apr 2024 07:49:47 +0000

JSON (JavaScript Object Notation):

JSON is a lightweight data interchange format that is easy for humans to read and write and easy for machines to parse and generate.
It is a text-based format and closely resembles JavaScript object literal syntax, but it is a strict subset of JavaScript syntax.
JSON is primarily used for transmitting data between a server and a web client (browser) in web applications.
JSON is language-independent and is widely supported by various programming languages, including JavaScript.
JSON supports only primitive data types (strings, numbers, booleans, null), arrays, and objects (nested key-value pairs).

Example of JSON

{
  "name": "John",
  "age": 30,
  "address": {
    "city": "New York",
    "country": "USA"
  },
  "hobbies": ["reading", "gardening", "traveling"]
}

Accessing value of JSON

// Example JSON string
const jsonString = '{"name": "John", "age": 30, "city": "New York"}';

// Parse JSON string into a JavaScript object
const jsonObject = JSON.parse(jsonString);

// Access values using dot notation
console.log(jsonObject.name); // Output: John
console.log(jsonObject.age); // Output: 30
console.log(jsonObject.city); // Output: New York

// Access values using bracket notation
console.log(jsonObject['name']); // Output: John
console.log(jsonObject['age']); // Output: 30
console.log(jsonObject['city']); // Output: New York

Object in JavaScript:

An object in JavaScript is a collection of key-value pairs.
Where keys are strings (or Symbols) and values can be of any data type (including other objects, arrays, functions, etc.).
Objects can be created using object literals, constructors, or classes in modern JavaScript.
Objects in JavaScript are dynamic and mutable, meaning their properties can be added, modified, or deleted at runtime.

Object Literal:

// Creating an object using object literal
let person = {
  name: 'John',
  age: 30,
  greet: function() {
    console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old.');
  }
};

// Accessing properties and calling method
console.log(person.name); // Output: John
console.log(person.age); // Output: 30
person.greet(); // Output: Hello, my name is John and I am 30 years old.

Constructor:

// Defining a constructor function
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.greet = function() {
    console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old.');
  }
}

// Creating an object using the constructor function
let person1 = new Person('John', 30);

// Accessing properties and calling method
console.log(person1.name); // Output: John
console.log(person1.age); // Output: 30
person1.greet(); // Output: Hello, my name is John and I am 30 years old.

Class (ES6+):

// Defining a class
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// Creating an object using the class
let person2 = new Person('John', 30);

// Accessing properties and calling method
console.log(person2.name); // Output: John
console.log(person2.age); // Output: 30
person2.greet(); // Output: Hello, my name is John and I am 30 years old.

FAQs

Are both JSON & Object store values as key-value pair?

Yes, both JSON (JavaScript Object Notation) and JavaScript objects store data in a key-value pair format.

2. Does JSON support Function or Method as values ?

No, JSON (JavaScript Object Notation) does not support functions as values. It only supports a limited set of data types, including strings, numbers, booleans, arrays, objects, and null.

JSON vs JSONP

Anurag Affection — Tue, 09 Apr 2024 12:33:37 +0000

Difference between JSON & JSONP

JSON is a data format commonly used for data interchange between a client and a server, while JSONP is a technique used to fetch JSON data from a different domain in web applications by dynamically injecting script tags into the DOM and using callback functions to handle the response.

JSON (JavaScript Object Notation):

JSON is a lightweight data interchange format that is easy for humans to read and write and easy for machines to parse and generate.
It is language-independent, but it is primarily used with JavaScript due to its close relationship with JavaScript objects.
JSON is a text-based format and is typically used for transmitting data between a server and a web application.
JSON data is structured as key-value pairs and supports arrays and nested objects.
JSON is parsed using the JSON.parse()method in JavaScript and is generated using the JSON.stringify() method.

{
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com",
  "address": {
    "city": "New York",
    "country": "USA"
  },
  "hobbies": ["reading", "gardening", "traveling"]
}

JSONP (JSON with Padding):

JSONP is a technique used to overcome the Same-Origin Policy limitations in web browsers when making cross-domain requests.
It is essentially a way of fetching JSON data from a different domain in a web page that is hosted on a different domain.
JSONP works by inserting a <script> tag into the DOM with a src attribute pointing to a URL that returns JSON data. This URL includes a callback function as a query parameter.
The server returns JSON data wrapped in a function call, where the function name is the callback specified in the URL. This allows the JSON data to be executed as JavaScript code in the context of the web page.
JSONP is primarily used for making cross-domain AJAX requests in web applications when the server supports JSONP callbacks.
Suppose we have a server that provides JSON data about users. Let's say the URL to fetch user data is https://example.com/users?callback=myCallback.
When you make a request to this URL with a specified callback function, the server responds with JSON data wrapped in a function call matching the specified callback function. Here's how the response might look:

myCallback({
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com",
  "address": {
    "city": "New York",
    "country": "USA"
  },
  "hobbies": ["reading", "gardening", "traveling"]
});

When this response is executed in the browser, it will invoke the myCallback function with the JSON data as an argument. This allows you to use the JSON data in your JavaScript code, overcoming the Same-Origin Policy restrictions for cross-domain requests.