Section 1.1: Understanding Arrays as Objects

Are arrays considered objects in JavaScript? Remember, an object is a mutable collection of properties. Let’s create an empty array and add some properties:

const flightArr = [];

flightArr.no = 815; // Property added

flightArr.from = 'Sydney'; // Property added

delete flightArr.no; // Property removed

We can then confirm that arrays have the hidden property linking them to their prototype, Array.prototype:

flightArr.__proto__ === Array.prototype; // true

Object.getPrototypeOf(flightArr) === Array.prototype; // true

While arrays are indeed objects, they should not be manipulated in the same manner as shown previously. Here is a proper way to create an array:

const arr = ['Jack', 'Locke', 'Kate'];

JavaScript emulates arrays using objects, where indices are treated as string keys. This means that accessing an element via string keys and numeric indices yields the same result:

arr['1']; // 'Locke'

arr[1] === arr['1']; // true

When using the typeof operator, JavaScript confirms that arrays are a type of object:

const arr = [];

typeof arr; // 'object'

Array.isArray(arr); // true

Section 1.2: Functions as Objects

Now, let’s explore whether functions qualify as objects. We can define a function and add properties to it:

const movie = function() {};

movie.title = 'Toc Toc'; // Property added

movie.year = 2017; // Property added

delete movie.year; // Property removed

Consider the Integer function that converts values into integers:

const Integer = function(value) {

return parseInt(value);

};

Integer('123'); // 123

We can also attach properties to this function, such as a maximum value or another function, and call the isInteger method:

Integer.MAX_VALUE = 9007199254740991;

Integer.isInteger = function(value) {

return Number.isInteger(value);

};

Just like built-in functions such as Number, String, and Boolean, our custom functions also act like objects. For instance:

const x = function() { return 'Hi'; };

x.type = 'Greeting';

console.log(x()); // 'Hi'

console.log(x.type); // 'Greeting'

Section 1.3: The Nature of Primitives

The built-in primitive types include boolean, number, bigint, string, symbol, null, and undefined. However, can we treat primitives as objects? Let's consider:

const text = "Hi";

text.type = 'greeting'; // Attempting to add a property

console.log(text.type); // undefined

Primitives cannot have properties added, altered, or removed. However, they can access methods from their respective prototype, appearing as if they are objects. When accessing properties, JavaScript temporarily converts the primitive to a corresponding object:

'in bruges'.toUpperCase(); // "IN BRUGES"

JavaScript constructs a temporary wrapper object to access properties. However, this does not apply to null and undefined, which remain as primitives and cannot have properties:

null.msg; // Uncaught TypeError

undefined.length; // Uncaught TypeError

Final Thoughts

In conclusion, while functions and arrays are indeed objects in JavaScript, not all values fit this description. Primitives are not objects but are treated as such to some extent. The exceptions to this rule are null and undefined, which are distinctly not treated as objects. Ultimately, aside from primitives, JavaScript treats nearly everything as an object.

To enhance your understanding, consider watching these informative videos:

This video delves into the concept that in JavaScript, everything behaves like an object.

Explore the question of whether everything in JavaScript is an object in this engaging video.