🧠Understanding JavaScript Strings: Primitive vs Object

In JavaScript, there are two types of strings: primitive strings and String objects. This distinction can sometimes lead to unexpected results, as we’ll see in this blog post.

Primitive Strings vs String Objects

Let’s start with an example:

const Firstname = "kashyap";
const Name = new String("kashyap");

console.log(Firstname === Name); // false

Here, Firstname is a primitive string, created by assigning a string literal to a variable. Name, on the other hand, is a String object, created using the new String() constructor.

When we use the === operator to compare Firstname and Name, it returns false. This might be surprising since both Firstname and Name contain the same characters. However, === checks both value and type. Even though Firstname and Name have the same value, they are of different types (string and object, respectively), so Firstname === Name is false.

We can confirm this by checking the type of Firstname and Name:

console.log(typeof(Firstname)); // "string"
console.log(typeof(Name)); // "object"

Concatenating Primitive Strings and String Objects

Despite their differences, primitive strings and String objects can be used together in many ways. For example, we can concatenate them using the concat method:

console.log(Firstname.concat(Name)); // "kashyapKashyap"

This works because JavaScript automatically converts String objects to primitive strings when necessary. In this case, the concat method expects a primitive string, so Name is converted to a primitive string before concatenation.

Why Can We Use String Methods on Primitive Strings?

You might be wondering why we can use String methods like concat on primitive strings if they’re not objects. The answer lies in JavaScript’s automatic type conversion.

When you call a method on a primitive string, JavaScript temporarily wraps the string in a String object so that the method can be called. This is done automatically and behind the scenes, so it’s usually not something you need to worry about. However, it’s good to be aware of this behavior, which can sometimes lead to confusion.

In conclusion, JavaScript’s handling of strings can be a bit tricky to understand, but once you know the difference between primitive strings and String objects, it becomes much clearer. Remember that === checks both value and type and that JavaScript will automatically convert between primitive strings and String objects as necessary.