DEV Community: Asir Sam R

What is Node.js and npm? A Beginner’s Guide

Asir Sam R — Mon, 24 Mar 2025 09:46:47 +0000

Introduction

In the world of modern web development, JavaScript has expanded beyond just running in the browser. Thanks to Node.js, developers can now use JavaScript for server-side programming as well. Alongside Node.js, npm (Node Package Manager) plays a crucial role in managing libraries and dependencies. This post will help you understand what Node.js and npm are and why they are essential for JavaScript development.

What is Node.js?

Node.js is an open-source, cross-platform runtime environment that allows you to run JavaScript outside the browser. It is built on Chrome’s V8 JavaScript engine, which compiles JavaScript code into machine code for fast execution.

Key Features of Node.js:

Asynchronous and Event-Driven – Handles multiple requests simultaneously without blocking the execution.
Non-blocking I/O – Improves efficiency and performance by processing tasks in parallel.
Single Programming Language – Enables full-stack development using JavaScript for both frontend and backend.
Scalability – Suitable for building real-time applications like chat apps, streaming services, and APIs.

Example: Creating a Simple HTTP Server in Node.js

const http = require('http');

const server = http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello, World!');
});

server.listen(3000, () => {
    console.log('Server running at http://localhost:3000');
});

This simple server listens on port 3000 and responds with “Hello, World!”

What is npm?

npm (Node Package Manager) is the default package manager for Node.js. It helps developers install, manage, and share JavaScript libraries and tools.

Why Use npm?

Dependency Management – Easily install and manage third-party libraries.
Version Control – Maintains project stability by managing package versions.
Script Automation – Automate tasks using npm scripts.
Open-source Community – Access a vast repository of free-to-use JavaScript packages.

Basic npm Commands:

Initialize a Project

   npm init -y

This creates a package.json file, which stores project dependencies and metadata.

Install a Package (e.g., Express.js)

   npm install express

Adds Express to the project and lists it in package.json.

Install Packages Globally

   npm install -g nodemon

Installs nodemon globally, allowing automatic server restarts on file changes.

Update Dependencies

   npm update

Updates all installed packages to their latest compatible versions.

How Node.js and npm Work Together

Node.js provides the runtime for executing JavaScript code outside the browser, while npm simplifies dependency management. Together, they enable developers to create scalable, efficient applications.

Example: Building a Simple Express Server

const express = require('express');
const app = express();

app.get('/', (req, res) => {
    res.send('Hello from Express!');
});

app.listen(3000, () => {
    console.log('Server running on http://localhost:3000');
});

This example uses npm to install Express.js and Node.js to run the server.

Conclusion

Node.js and npm have transformed JavaScript into a powerful full-stack development tool. Whether you're building APIs, web applications, or real-time services, understanding these tools is essential. Now that you have a solid foundation, start experimenting and building your own Node.js projects!

Javascript Object #14

Asir Sam R — Tue, 18 Apr 2023 12:00:25 +0000

In the Post we are going to some latest ECMA method introduced in Javasciript.

Object.values()

To access the value of an Object we usually use for...in loop to iterate over it and access the elements inside the Object.But there is problem with for...in as we have already seen this in past post about for...in loop,that iterates over all the inherited properties of an Object.That is not fair and we have sort that it with Object.hasOwnProprty() method.That's a Good way, but what if we can do it in more easy way.

ES2017 has introduced the Object.values to access the values of an own enumerable properties of an Object.

let's see this with an example,

`const person = {
    firstName: 'John',
    lastName: 'Doe',
    age: 25
};

for (const key in person) {
    if (person.hasOwnProperty(key)) {
        const value = person[key];
        console.log(value);

    }
}
`

OUTPUT

`John
Doe
25
`

Let's now see this with the Object.values(),

The Syntax is,

`Object.values(obj)`

`const person = {
    firstName: 'John',
    lastName: 'Doe',
    age: 25
};

const profile = Object.values(person);

console.log(profile);
`

OUTPUT

`[ 'John', 'Doe', 25 ]
`

The Object.values() accepts an object and returns its own enumerable property’s values as an array.

Object.entries()

As like Object.values(),in ES2017 introduced the Object.entries.

Object.entries are same like Object.values,but it returns the enumerable string-keyed property into [key, value] pair of Object.

`Object.entries()`

`const ssn = Symbol('ssn');
const person = {
    firstName: 'John',
    lastName: 'Doe',
    age: 25,
    [ssn]: '123-345-789'
};

const kv = Object.entries(person);

console.log(kv);
`

OUTPUT

`[
    ['firstName', 'John'],
    ['lastName', 'Doe'],
    ['age', 25]
]
`

The firstName, lastName, and age are own enumerable string-keyed property of the person object, therefore, they are included in the result.
The ssn is not a string-key property of the person object, so it is not included in the result.

That's all for now,hope you learnt something.Please put down comments suggesting me to do better,that will motivates me a lot to do more in Javascript.

Thanks for you Time in between breaks,
Sam

Javascript Object #13

Asir Sam R — Tue, 18 Apr 2023 10:02:21 +0000

In this Post we are going to see the Object.is() method in Javascript.

Object.is()

This is method was introduced later in ECMASCRIPT17,this method is used to compare the two values.

The === and Object.is() behaves the same way as the Strict equal,but in two ways they differ.

-0 and +0
NaN

Negative zero

In === it treats both the negative and non negative numbers as same or else what we could say is, they are equal.
let's see this with an example,

`let amount = +0,
    volume = -0;
console.log(volume === amount);`

OUTPUT:

`true`

Here comes the Object.is() he treat him as they are not same,

`let amount = +0,
    volume = -0;
console.log(Object.is(amount, volume));`

OUTPUT

`false`

Nan

Here comes another one,as when you compare the Nan with the === operator it will return false,as they think they are not same.Nan is the only number that does not equals itself.

`let quantity = NaN;
console.log(quantity === quantity);`

OUTPUT

`false`

However, Object.is() treats NaN as the same value:

`let quantity = NaN;

console.log(Object.is(quantity, quantity));


Output:

true`

I'll attach a table that can help you a lot and save your many time.

Thanks for your mean Time,
Sam.

Javascript Object #12

Asir Sam R — Tue, 18 Apr 2023 04:05:39 +0000

In this Post we are going to see,how to iterate over an enumerable Property in an Javscript Objects.

The for..in loops iterate over the enumerable properties of an Object.Note that a property can be Keyed by a String or Symbol.A property is enumerable when its enumerable attribute is set to true.By default while creating an Object using literal syntax,the enumerable attribute is set true initially.

Let's see an example,

`
object.propertyName = value;

or by

let obj = {
    propertyName: value,
    ...
};

`

in both the cases the Object enumerable property is set to true by default.

Now let's create a for..loop and iterate over an Object.

`for(const propertyName in object) {
    // ...
}
`

`var person = {
    firstName: 'John',
    lastName: 'Doe',
    ssn: '299-24-2351'
};

for(var prop in person) {
    console.log(prop + ':' + person[prop]);
}
`

OUTPUT:

`firstName:John
lastName:Doe
ssn:299-24-2351
`

In this example, we used the for...in loop to iterate over the properties of the person object. We accessed the value of each property using the following syntax:

`object[property];`

The for...in loop & Inheritance

So for we have seen the iteration over a normal Object,but what if we iterate an Object that inherits the property from another Object.The for..in loop will inherit the properties that inherits from the another Object,the for..in goes up in prototype chain and iterate over enumerable properties.Let's see an example,

`var decoration = {
    color: 'red'
};

var circle = Object.create(decoration);
circle.radius = 10;


for(const prop in circle) {
    console.log(prop);
}
`

OUTPUT:

`radius
color
`

The circle object has its own prototype that references the decoration object. Therefore, the for...in loop displays the properties of the circle object and its prototype.

If you want to enumerate over only the own properties of an Object,you can use hasOwnProperty() method.

`for(const prop in circle) {
    if(circle.hasOwnProperty(prop)) {
        console.log(prop);
    }
}
`

OUTPUT:

`radius
`

The for...in loop and Array

It’s good practice to not use the for...in to iterate over an array, especially when the order of the array elements is important.

Let's see an example that works flawlessly,

`const items = [10 , 20, 30];
let total = 0;

for(const item in items) {
    total += items[item];
}
console.log(total); `

However we can add a new property to the Array type in the Javascript,

`Array.prototype.foo = 100;`

Hence, the for...in will not work correctly. For example:

`// somewhere else
Array.prototype.foo = 100;

const items = [10, 20, 30];
let total = 0;

for (var prop in items) {
  console.log({ prop, value: items[prop] });
  total += items[prop];
}
console.log(total);`

OUTPUT:

`{ prop: '0', value: 10 }
{ prop: '1', value: 20 }
{ prop: '2', value: 30 }
{ prop: 'foo', value: 100 }
160`

Look at this,we have got the wrong once as it has inherites a property from it's prototype.

Let's see another example,

`var arr = [];
// set the third element to 3, other elements are `undefined`
arr[2] = 3; 

for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);    
}`

OUTPUT:

`undefined
undefined
3`

However, the for...in loop ignores the first two elements:

`for (const key in arr) {
    console.log(arr[key]);
}
`

OUTPUT:

`3
`

Yes,that's all for now.If you are reading this Please give me suggestions or comments to motivate me do more and better on upcoming posts.

Many Thanks for Your Time,
Sam

Javascript Object #11

Asir Sam R — Sat, 15 Apr 2023 09:35:14 +0000

Welcome back! in the last post we have seen about the Object properties and it one property Data property.Now we are going to see about the accessor property in this Post.

As like Data Properties,accessor property have [[Configurable]] and [[Enumerable]] attributes.But the accessor property have the [[Get]] and [[Set]] attributes instead of [[Value]] and [[Writable]].

When you want to read a data from the accessor property the [[Get]] method is automatically called to return a value.when you want to assign a value to the property [[Set]] function is called automatically.

To define a accessor property,you need to use Object.defineProperty() method. or example:

`let person = {
    firstName: 'John',
    lastName: 'Doe'
}

Object.defineProperty(person, 'fullName', {
    get: function () {
        return this.firstName + ' ' + this.lastName;
    },
    set: function (value) {
        let parts = value.split(' ');
        if (parts.length == 2) {
            this.firstName = parts[0];
            this.lastName = parts[1];
        } else {
            throw 'Invalid name format';
        }
    }
});

console.log(person.fullName);`

OUTPUT

`'John Doe'`

in this example,the Person Object conatins two properties,firstName and lastName.Then we are adding the fullName property to the Person Oject as an accessor property.In the fullName accessor property,

The [[Get]] returns the full name that is the result of concatenating of firstName, space, and lastName.
The [[Set]] method splits the argument by the space and assigns the firstName and lastName properties the corresponding parts of the name.
If the full name is not in the correct format i.e., first name, space, and last name, it will throw an error.

From the ES5,we can define a multiple property in a single statement using the Object.defineProperties() method.

`var product = {};

Object.defineProperties(product, {
    name: {
        value: 'Smartphone'
    },
    price: {
        value: 799
    },
    tax: {
        value: 0.1
    },
    netPrice: {
        get: function () {
            return this.price * (1 + this.tax);
        }
    }
});

console.log('The net price of a ' + product.name + ' is ' + product.netPrice.toFixed(2) + ' USD');`

OUTPUT

`The net price of a Smartphone is 878.90 USD`

In this example, we defined three data properties: name, price, and tax, and one accessor property netPrice for the product object.

In Javascript we can also find the property descriptor of an Object using the Object.getOwnPropertyDescriptor() method,The Object.getOwnPropertyDescriptor() method takes two arguments:

An Object.
A Property of an Object.

It returns a descriptor object that describes a property. The descriptor object has four properties: configurable, enumerable, writable, and value.

`let person = {
    firstName: 'John',
    lastName: 'Doe'
};


let descriptor = Object.getOwnPropertyDescriptor(person, 'firstName');

console.log(descriptor);`

OUTPUT

`{ value: 'John',
  writable: true,
  enumerable: true,
  configurable: true }`

That's all about the Javascript Object Properties.We will see more intersting things about Object in Upcoming Post.

If you are reading this post,and find helpfull.Please give a like and comments that will motivate me a lot and do more interesting things in Javascript.

Thanks for your mean Time,
Sam

Javascript Object #10

Asir Sam R — Sat, 15 Apr 2023 06:21:40 +0000

So far in our long Javascript Object post,we have seen about Javascript Object creation, what is Object properties, etc. But in the post we are going to see Object properties in Javascript.This may make you little confusing,because as we have already came through Object Properties as it was the collection unordered keys and values. But this is not same,this is really different.

Object Properties

Javascript Object properties are some of the internal attributes of the Object that define the Object characteristics.They can be defined mannually.These attributes are internal and ususally they are sorrounded by two Squre brackets.We can assign the characteristic of the individual properties,that does'nt affect the other properties in the Object.

Objects have two types of Properties,

Data Properties.
Accessor Properties.

Data Properties

Data Properties contains the single location for the value.that means the data of the property is stored in the a single attribute.
There are four types of attributes in Data property.

[[Configurarable]]
[[Enumerable]]
[[Writable]]
[[Value]]

By default all the internal properties attributes are set to true,while creating an Object.The default value of the attribute [[Value]] is undefined.

[[Configurarable]]

This is the first attribute of the Object data property,this defines weather the data in the Object can be redefined or either can delete via Delete Operator.

To define the Charateristic of a property in an Object.we have to use define property method, *Object.defineProperty() *

This *Object.defineProperty() * accepts the three arguments,
1.The Object to define.
2.The name of the Property in the Object.
3.A property descriptor object that has four properties: configurable, enumerable, writable, and value.

Note If you Define a new Property using the Object.defineProperty() ,all the internal attributes of the property is set the default false.

Let's make this in an example,

let person = {
    firstName: 'Ross',
    lastName: 'Rachael'
};

In this example we have create an Object with two properties,Let's now try to delete the firstName property

`delete person.firstName;
console.log(person.firstName);`

`undefined`

Boom,the firstName property have been deleted,as you haven't assigned any internal attributes mannually so the default value of the [[Configurable]] attribute is set to true.so you can remove it via the delete operator.

Let's now define a property using the Object.defineProperty,and see what is going to happen,

`let person = {};

Object.defineProperty(person, 'ssn', {
    configurable: false,
    value: '012-38-9119'
});

Object.defineProperty(person, 'ssn', {
    configurable: true
});
`

`TypeError: Cannot redefine property: ssn`

As you can see,it throws an error.because the we configured the internal attributes to false,so we cannot redefine the property once we set the configurable attribute to false.

[[Enumerable]]

[[Enumerable]] defines,whether the property can be iterable or not.
By default this attribute is also set TRUE,t means that you can iterate over all object properties using the for...in loop like this:

`
let person = {};
person.age = 25;
person.ssn = '012-38-9119';

for (let property in person) {
    console.log(property);
}
`

OUTPUT:

`
age
ssn
`

Let's manipulate the Ennumerable property and try this again,

`let person = {};
person.age = 25;
person.ssn = '012-38-9119';

Object.defineProperty(person, 'ssn', {
    enumerable: false
});

for (let prop in person) {
    console.log(prop);
}`

OUTPUT:

`age`

as you can see the ssn property didn't came into console as we have set the enumerable attribute of the property to false.

[[Writable]]

This attribute specifies wheater the value of the property can be changed or not.By default this attribute is also set the true.

[[Value]]

As i have told in the beginning the data in the Object in the Data properties are stored in a single location and that is the [[Value]] attribute.This contains the actual value of a property.

That's it.We will see about the Accessor Property in upcoming post.

If you are reading this Post Please Hit Up the Like,that motivates me a lot to do and learn more aboyt Javascirpt.

Many Thanks for your Morning Time,
Sam

Javascript Object #9

Asir Sam R — Thu, 13 Apr 2023 06:53:10 +0000

We have seen so many important things about Javascript Object.But now we are going to see another most important topic,which is this in Javascript.

this

As you may came across many programming languages and have a good familiarity about the this keyword.But in Javascript this keyword in totally different.Let's know about the Strange this keyword in Javasciript.

`In Javascript **this** is the Object of which Function is property.In more simple words,**this** reference to the Object of that is currently calling the Function.`

let's see this with an example,

`let counter = {
  count: 0,
  next: function () {
    return ++this.count;
  },
};

counter.next();`

as you can see,here counter is an Object and next() is a method inside the counter Object,as you can see inside the Object. The this keyword inside the method references the current Object counter.

But this is not enough,we have to check the this keyword on differenct context like,

Global Context.
Function Context.

Global Context.

`console.log(this === window); // true`

In Global context,this refers the Global Object,in Browser it is the Window Object and in NodeJs Environment it is Global Object.And this behaviour is same in both Strict and non strict mode.
And If you assign a property with this in Global context,Javascript will add the Property to the window Object,as like this,

`this.color= 'Red';
console.log(window.color); // 'Red'`

Function Context.

In Javascript you can call the Function in Following ways,

1.Function Invocation.
2.Method Invocation.
3.Constructor Invocation.
4.indirect Invocation.

Function invocation.

Inside the Function the this keyword differs in Strict and Non Strict mode.let's see

`function show() {
   console.log(this === window); // true
}

show();`

When you call the show() function, the this references the global object, which is the window on the web browser and global on Node.js.

`Calling the show() function is the same as:
window.show();
`

But in the Strict mode,Javascript sets the this inside the Function context as undefined.Let's see that with an example,

`"use strict";

function show() {
    console.log(this === undefined);
}

show();`

If you want to enable the Strict mode use the directive "use strict" in the beggining of the Javascript file,or else you can use the Strict mode inside the specific function.

`function show() {
    "use strict";
    console.log(this === undefined); // true

    function display() {
        console.log(this === undefined); // true
    }
    display();
}

show();`

Output:
true
true

As you can see the strict mode applies for both the function and Nested function as well.

Method invocation

When you call a method of an Object, Javascript set the this to the Object that contains that method.Let's see this with a quick example,

`let car = {
    brand: 'Honda',
    getBrand: function () {
        return this.brand;
    }
}

console.log(car.getBrand()); // Honda`

In this example, the this object in the getBrand() method references the car object.

Let's Go little tricky here,as getBrand is a Property of a Object and it can be Stored in variable right.Yes, Let's do it.

`let brand = car.getBrand;
console.log(brand()); // undefined
`

ufff, Strange right.for me too this things looks so strange untill i know the exact reason.when you assign the brand variable with the Object getBrand property,this will assign the Property but what happens is, the brand variable is now in global context and it reference the Global Object,thus inoder to fix this we have to bind the brand variable to the exact Object.

`let brand = car.getBrand.bind(car);
console.log(brand()); // Honda
`

To fix this issue, you use the bind() method of the Function.prototype object. The bind() method creates a new function whose the this keyword is set to a specified value.

Let's see another example,

`let car = {
    brand: 'Honda',
    getBrand: function () {
        return this.brand;
    }
}

let bike = {
    brand: 'Harley Davidson'
}

let brand = car.getBrand.bind(bike);
console.log(brand());

Output:

Harley Davidson`

In this example, the bind() method sets the this to the bike object, therefore, you see the value of the brand property of the bike object on the console.

Constructor invocation

When you use the new keyword to create an instance of a function object, you use the function as a constructor.

`function Car(brand) {
    this.brand = brand;
}

Car.prototype.getBrand = function () {
    return this.brand;
}

let car = new Car('Honda');
console.log(car.getBrand());`

The expression new Car('Honda') is a constructor invocation of the Car function.JavaScript creates a new object and sets this to the newly created object. This pattern works great with only one potential problem.
Now, you can invoke the Car() as a function or as a constructor. If you omit the new keyword as follows:

`var bmw = Car('BMW');
console.log(bmw.brand);
// => TypeError: Cannot read property 'brand' of undefined`

Since the this value in the Car() sets to the global object, the bmw.brand returns undefined.

ES6 introduced a meta-property named new.target that allows you to detect whether a function is invoked as a simple invocation or as a constructor.

You can modify the Car() function that uses the new.target metaproperty as follows:

`function Car(brand) {
    if (!new.target) {
        throw Error('Must use the new operator to call the function');
    }
    this.brand = brand;
}`

Indirect Invocation

In JavaScript, functions are first-class citizens. In other words, functions are objects, which are instances of the Function type.

The Function type has two methods: call() and apply() . These methods allow you to set the this value when calling a function. For example:

`function getBrand(prefix) {
    console.log(prefix + this.brand);
}

let honda = {
    brand: 'Honda'
};
let audi = {
    brand: 'Audi'
};

getBrand.call(honda, "It's a ");
getBrand.call(audi, "It's an ");`

Code language: PHP (php)

In this example, we called the getBrand() function indirectly using the call() method of the getBrand function. We passed honda and audi object as the first argument of the call() method, therefore, we got the corresponding brand in each call.

The apply() method is similar to the call() method except that its second argument is an array of arguments.

`getBrand.apply(honda, ["It's a "]); // "It's a Honda"
getBrand.apply(audi, ["It's an "]); // "It's a Audi"`

Thanks for You Mean Time,
Sam

Javascript Object #8

Asir Sam R — Wed, 12 Apr 2023 10:21:47 +0000

From the past posts we've seen about Prototype and Prototype Chaining in quite detail.Now we are going to see,how to link methods in the prototype chains and how i will be usefull in our cases.

Defining methods in the JavaScript prototype object

The Simple way to define a new method in the Prototype Object is,

`function Person(name) {
    this.name = name;
}`

`Person.prototype.greet = function() {
    return "Hi, I'm " + this.name + "!";
}`

by defining like this,Javascript Object add the greet() method to the Person.prototype Object.

Now let's create a new instance for the Person,

`let p1 = new Person('John');`

Internally Javascript creates a new Object p1 and links the Object with Person.prototype via prototype Linkage.

Let's visaualize it,

As You can see the Link between the p1, Person.prototype and Object.prototype is called as the Prototye Chain.

Now let's access the methods inside the Prototype Object,

`let greeting = p1.greet();
console.log(greeting);`

as you can see p1 doesn't have the greet() method and the javascript engine will search for it in the Person.prototype Object.
Since JavaScript can find the greet() method on the Person.prototype object, it executes the greet() method and returns the result

Now let's call the toString() method and let's see what happens,

`let s = p1.toString();
console.log(s);`

in this above case, the JavaScript engine follows the prototype chain to look up for the toString() method in the Person.prototype.
in our case the Person.prototype doesn't contains the toString() method and the prototype chain starts to search for it in the Object.prototype Object.Since JavaScript can find the toString() method in the Object.prototype, it executes the toString() method.

If you call the method that does'nt exist in the Person.prototype and Object.prototype.Javscript engine will search through the prototype chain and if it can't find the method it will throw an error.

`
p1.study()
`

Because the study() method doesn’t exist on any object in the prototype chain, the JavaScript engine issues the following error:

`TypeError: p1.fly is not a function`

Now let's create another instance of Person function with different name,

`let p2 = new Person('Jane');`

Now the p2 object holds all the properties and method p1 holds.
In conclusion, when you define a method on the prototype object, this method is shared by all instances.

let's create a method in the individual Object instead of in prototype,

`p2.draw = function () {
    return "I can draw.";
};
`

The JavaScript engine adds the draw() method to the p2 object, not the Person.prototype object:

It means that you can call the draw() method on the p2 object:

`p2.draw();`

But you cannot call the draw() method on the p1 object:

`p1.draw()
`
TypeError: p1.draw is not a function

When you define a method in an object, the method is only available to that object. It cannot be shared with other objects by default.

that's all now for Prototypal Linkage in Javascript.I hope you all got good understanding in prototypal linkage.if you feel any diffuculties feel free to ask me in the comments.

Many Thanks for your valuable Time,
Sam

Javascript Object #7

Asir Sam R — Wed, 12 Apr 2023 04:30:45 +0000

Welcome All,in the last post we've seen what is Prototype in Object.In Javascript every Object contains a Prototype property and it itself is an another Object and it contains many useful methods.
Now we are going to see about the Prototypal Linkage in Object,as from the last post we have seen that Javascript doesn't conatains classical inheritance instead it has Prototypal Inheritance in the Post we are Going to see about the How this Proto Inheritance is happening.

PROTOTYPAL INHERITANCE

Most of the People Don't know that Javascript has an inbuild Function called Object() most of the Novice developers think that it is Just an Object,but it is not an Object.while you console log this,

`typeof(Object)

output
'function'

`

Pretty Confusing right, yeah may be at the beginning it will, as you been new to Javascript Prototype.

Javascipt also has an anonymous object and that can be referenced via Object.prototype.as you can see,

`console.log(Object.prototype);`

the Object.prototype has some usefull properties like toString,_ valueOf_ and it also has some important property called constructor and it reference to and Object() function.this is how Javascript Object linking together for example,

`console.log(Object.prototype.constructor === Object); // true`

as you can see both are same,

Let's visaulize this in more better way,assume circle as a Object() function and Square as an Object.let illustrate the relationship between them,

thus,this how they linked together.

Let's first define a Constructor Function,

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6wjhwm9g3sf3ugj0ib05.png)
`function Person(name) {
    this.name = name;
}`

In this Fuction,it accepts an argument called name and assign it to the name Property of this Object.

But do you know what's happening behind the scenes,the Javascirpt engine will create an Function Person and an anonymous Object.Like the Object() Function.Person function has a Prototype Property and it reference the anonymous Object and the Object has a constructor Property that holds the Person() function.

In addition,Javascript links the Person.prototype and Object.Prototype Object via the [Prototype],which is know as the Prototypal Linkage.This is called The Prototypal linkage in the Javascript

So for,we have seen how Prototypal Linkage is Happening in Javascirpt Object.In future Post we'll see how to methods are linking using the real time examples.

Please Support me by giving a reaction to this post,
If you've learned something.

Many Thanks for You Patience and Time,
Sam

Javascript Object #6

Asir Sam R — Tue, 11 Apr 2023 04:22:59 +0000

Welcome All,

Till our Last Post we've seen only pretty basics in Javascript.From now we are going to Jump into little deep about Objects in Javascript,as i've told you that Javascript Object are very Deep and He is very Strong one,as most of the things in javascript is an Object.

Let's Quick Dive into it,in this Post we are Going to know about Prototype in Javascript.

Prototype

As in many Programming Languages,they have Inheritance to access the Feature from his Parent class or Object.As like that Javascript can inherit features from one Object to another Object via Prototype.Unlike in other Programming languages like Java,C++ they have Classical Inheritance but in Javascript it is Prototypal Inheritance.

Every Object has it's own Property called Prototype.And Prototype itself is an another Object and it contains another prototype and it is somewhat called as the Prototype Chain.This Chain ends when it's Prototype is null.

Suppose you have an object person with a property called name:

`let person = {'name' : 'John'}`

When examining the person object in the console, you’ll find that the person object has a property called prototype denoted by the [[Prototype]]

The prototype itself is an object with its own properties:

Suppose if you want to access a property from an Object it'll return the value if exist,or else if the Property is not present in the Object the Javascript engine will search for the Property in the Object Prototype and even if it can't find it there it'll search it in the Prototype's Prototype untill it finds the Property or reaches the end of the prototype Chain.

For example, you can call the toString() method of the person object like this:

The toString() method returns the string representation of the person object. By default, it’s [object Object] which is not obvious.

In this example on calling the toString() method,the Javascript engine will search for it in the Person Object and it could not find it there and it continue to search for it in the Object Prototype and it will find it there.

Since the person’s prototype has the toString() method, JavaScript calls the toString() of the person’s prototype object

for now that's it,we'll see more intresting things about the Prototype and it's inheritance in upcoming post.

Many Thanks for Your Time,
Sam

Javascript Object #5

Asir Sam R — Wed, 05 Apr 2023 11:55:50 +0000

Very Warm Welcome,
As it was very warm here in mid-afternoon of mid-summer days
In the last Chapter we've created an Object using the Constructor function,as i told we have to call the Constructor Function with "new" keyword.But whatif we call that without the new keyword.let's see about that in this Post.

Technically, you can call a constructor function like a regular function without using the new keyword like this:

`let friends = Name('Joey','Chandler');`

In this case, the Person just executes like a regular function. Therefore, the this inside the Person function doesn’t bind to the person variable but the global object.

If you attempt to access the firstName or lastName property, you’ll get an error:

`console.log(person.firstName);

TypeError: Cannot read property 'firstName' of undefined
`

Similarly, you cannot access the getFullName() method since it’s bound to the global object.

`person.getFullName();
Code language: CSS (css)

Error:

TypeError: Cannot read property 'getFullName' of undefined`

Inoder to Prevent this ES6 has introduced new property called new.target.
If the constructor called with the new keyword it would return the reference of the Function.Otherwise it'll return undefined.

Let's see example for the property,

`function Person(firstName, lastName) {
    if (!new.target) {
        throw Error("Cannot be called without the new keyword");
    }

    this.firstName = firstName;
    this.lastName = lastName;
`

From this Block,if You call the Construction function with new keyword it will return the new Object otherwise it'll throw an error.

Alternatively we can also do another way to fix this,

`
function Person(firstName, lastName) {
    if (!new.target) {
        return new Person(firstName, lastName);
    }

    this.firstName = firstName;
    this.lastName = lastName;
}

let person = Name("Joe", "Phoebhe");

console.log(person.firstName);`

Thus it'll return new Object even though we call the Constructor Function without new keyword.

That's for now,we'll meet in future Object Post,Bye..

Thanks for you warm Time,
Sam

Javascript Object #4

Asir Sam R — Wed, 05 Apr 2023 10:31:56 +0000

In the last Chapter we've seen a piece of closure called "Lexical Enviroment",Let put that in hold for now and get back into our Object series in this Blog.

In the Begginning Chapter we learnt what is object and how to create it.In the Past Chapter we've created the object using Object literal syntax.Now we are going to create an Object using the CONSTRUCTOR Syntax.

CONSTRUCTOR OBJECT

Before creating the Object,let know about the use cases of Object created using Constructor Syntax,

let person = {
    firstName: 'Rachael',
    lastName: 'Ross'
};

as you can see this is the basic method of creating an Object using literal Syntax,What If, we wan't to create same Object multiple times but with Different values,here comes the Constructor syntax into use,

The basic Syntax is,

`function Name(firstName, lastName){
         this.firstName = firstName;
         this.lastName = lastName;
}
`

This is the basic syntax of the Construtor Function,These are as like Normal Function but the rules to call a constructor functions was,

1.The name of a constructor function starts with a capital letter like Person, Document, etc.
2.A constructor function should be called only with the new operator.

Now let's create an Object with our Constructor Function,

In order to create a new Object,we need to call our Function "New" keyword to create a new instance of an Object

For Example,

`let friends = new Name('Chandler','Monica');
`

That's it very quite right,Then what's go behind this while Creating the new Objects.

1.Create a new empty object and assign it to the this variable.
2.Assign the arguments 'Chandler' and 'Monica' to the firstName and lastName properties of the object.
3.Return the 'this' value.

So,this might be equivalent to the
`

`
function Name(firstName, lastName) {
// this = {};

// add properties to this
this.firstName = firstName;
this.lastName = lastName;

// return this;

`
`
Pretty Straigt.We can also add method to the Constructor function,
let's create a method to get the fullname of an Object,as follows.

`function Name(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;

    this.getFullName = function () {
        return this.firstName + " " + this.lastName;
    };
}`

Now we've added a method to our function.Let's call it out

`
let friends = new Name('Ross','Rachael');
console.log(person.getFullName());

Output:

Ross Rachael

`
`

Simple but not efficient,because whenever you create a new instance for every Object getFullName() will be duplicated and it is not memory efficient.Inorder to overcome this,we can create this method in the Object "Prototype" so that every instance of that type can use the method.

what if we use return inside the constructor function,
Returning from constructor functions

Typically, a constructor function implicitly returns this that set to the newly created object. But if it has a return statement, then here’s are the rules:

1.If return is called with an object, the constructor function returns that object instead of this.
2.If return is called with a value other than an object, it is ignored.

That's all about Constructor Function now,we'll see more about this in upcoming post.

Many Thanks for Your Time,
Sam

DEV Community: Asir Sam R

What is Node.js and npm? A Beginner’s Guide

Introduction

What is Node.js?

Key Features of Node.js:

Example: Creating a Simple HTTP Server in Node.js

What is npm?

Why Use npm?

Basic npm Commands:

How Node.js and npm Work Together

Example: Building a Simple Express Server

Conclusion

Further Reading:

Javascript Object #14

Object.values()

Object.entries()

Javascript Object #13

Object.is()

Negative zero

Nan

Javascript Object #12

The for...in loop & Inheritance

The for...in loop and Array

Javascript Object #11

Javascript Object #10

Object Properties

Data Properties

[[Configurarable]]

[[Enumerable]]

[[Writable]]

[[Value]]

Javascript Object #9

this

Global Context.

Function Context.

Function invocation.

Method invocation

Constructor invocation

Indirect Invocation

Javascript Object #8

Defining methods in the JavaScript prototype object

Javascript Object #7

PROTOTYPAL INHERITANCE

Javascript Object #6

Prototype

Javascript Object #5

Javascript Object #4