Voice of a Developer: JavaScript Objects

Sumit Jolly
8y
5.9k
0
2

Article

JavaScript is a language of the Web. This series of articles will talk about my observations learned during my decade of software development experience with JavaScript. What mistakes a developer generally maes and what differences they should be aware of.

In part 1, we learnt about Data Types, and touched on Objects. But part 2 will focus in detail on Objects. You can go through Part 1 from here,

Voice of a Developer: JavaScript Data Types

Q: Can you use save asa reference in Javascript like we have in other programming languages?

Ans:

Yes, let’s go back in C / C++ days where we have a concept of pointers,

ex:

int x=49;
int *ptr;
ptr = &x;

This means that address of x is stored in ptr.
address

Therefore, ptr is pointing to integer. The advantage of this is you could change value in x via pointer

Ex:

*ptr=50;
printf(“%d”, x); // 50

Similarly, in Javascript the primitive data is saved-as-value. On the contrary, save-as-reference mechanism is there for objects,

Ex:

> var person = {name: "Sumit"};
> var anotherPerson = person;
> person.name = "Ravi";
> console.log(anotherPerson.name); // Ravi
> console.log(person.name); // Ravi

The variable is a reference, not a value

Object Own and Inherited Properties

The own properties are properties that were defined on the object, while the inherited properties were inherited from the object’s Prototype object.

We learnt about own properties in part 1, ex- person.name // own property

Prototypal inheritance – Inherited property

In most OOPS based languages, classes inherit from classes. In Javascript, it’s prototype-based. Objects inherit from Objects. And, we know an object is a prototype of classes. Therefore, it’s prototypical based inheritance

Q: How do we implement prototypal inheritance?

Ans: Use property called __proto__

Ex:

> var automobile = {engine: true};
> var car = {tyres: 4};

Now, we know car is a type of automobile, so we could inherit from automobile.

> car.__proto__ = automobile; //inheritance
> car.engine; // true

Hence, there is CAR => Automobile (car is a automobile)

Enumerable	Non-Enumerable
Own properties are enumerable. This means you can iterate over these	Inherited properties are non-emunerable. These are hidden unless asked specifically
Ex- car.tyres	Ex car.engine
Object.keys (car) //tyres;
car.propertyIsEnumerable("tyres"); //true	car.hasOwnProperty("engine"); //false
car.hasOwnProperty("tyres"); // true	car.propertyIsEnumerable("engine"); //false

Q: Is __proto__ only way to prototypal inheritance?

Ans: No, you could you Object to create it,

ex-

var automobile = {engine: true};
var car = Object.create(automobile);

Now, you could see car.engine is available

Q: Is there any other way to check property in object?

Ans: Yes, you could use below pattern to validate,

ex-

> "engine" in car; //true
> "valueOf" in {}; //true