13. When Primitives Behave Like Objects

In the previous chapter (Chapter 12, “Strings”) and less so in the “Of Pizza, Types, Primitives, and Objects” chapter (Chapter 11), you got a sneak peek at something that is probably pretty confusing. I’ve stated many times that primitives are very plain and simple. Unlike Objects, they don’t contain properties that allow you to fiddle with their values in interesting (or boring) ways. Yet, as clearly demonstrated by all the stuff you can do with strings, your primitives seem to have a mysterious dark side to them:

Click here to view code image

var greeting = "Hi, everybody!!!";
var shout = greeting.toUpperCase(); // where did toUpperCase
  come from?

As you can see from this brief snippet, your greeting variable, which stores a primitive value in the form of text, seems to have access to the toUpperCase method. How is this even possible? Where did that method come from? Why am I here? Answers to confusing existential questions like this will make up the bulk of what you see in this page. Also, I apologize for writing that previous sentence in passive voice. Happen again it won’t.

TABLE 13.1 Object Types that also Exist as Primitives

Whenever you are working with boolean, number, or string primitives, you have access to properties their Object equivalent exposes. In the following sections, you’ll see what exactly is going on.

Click here to view code image

var primitiveText = "Homer Simpson";

As you saw in the table earlier, strings also have the ability to be used as objects. There are several ways to create a new object, but the most common way to create an object for a built-in type like our string is to use the new keyword followed by the word String:

Click here to view code image

var name = new String("Homer Simpson");

The String in this case isn’t just any normal word. It represents what is known as a constructor function whose sole purpose is to be used for creating objects. Just like there are several ways to create objects, there are several ways to create String objects as well. The way I see it, knowing about one way that you really shouldn’t be creating them with is enough.

Anyway, the main difference between the primitive and object forms of a string is the sheer amount of additional baggage the object form carries with it. Let’s bring our silly visualizations back. Your primitiveText variable and its baggage looks as shown in Figure 13.1.

FIGURE 13.1 What primitiveText looks like.

There really isn’t much there. Now, don’t let the next part scare you, but if we had to visualize our String object called name, it would look like what you see in Figure 13.2.

FIGURE 13.2 It is a bit more complex, right?

You have your name variable containing a pointer to the text, Homer Simpson. You also have all of the various properties and methods that go with the String object - things you may have used like indexOf, toUpperCase, and so on. You’ll get a massive overview of what exactly this diagram represents in Chapter 16, “A Deeper Look at Objects,” so don’t worry yourself too much about what you see here. Just know that the object form of any of the primitives carries with it a lot of functionality.

Click here to view code image

var game = "Dragon Age: Origins";

The game variable is very clearly a string primitive that is assigned to some literal text. If I want to access the length of this text, I would do something as follows:

Click here to view code image

var game = "Dragon Age: Origins";
alert(game.length);

As part of evaluating game.length, JavaScript will convert your primitive string into an object. For a brief moment, your lowly primitive will become a beautiful object to figure out what the length actually is. The thing to keep in mind is that all of this is temporary. Because this temporary object isn’t grounded or tied to anything after it serves its purpose, it goes away and you are left with the result of the length evaluation (a number) and the game variable (still a string primitive).

This transformation only happens for primitives. If you ever explicitly create a String object, then what you create is permanently kept as an object. Let’s say you have the following:

Click here to view code image

var gameObject = new String("Dragon Age:Origins");

In this case, our gameObject variable very clearly points to something whose type is Object. This variable will continue to point to an Object type unless you modify the string or do something else that causes the reference to be changed. The primitive morphing into an object and then morphing back into a primitive is something unique to primitives. Your objects don’t partake in such tomfoolery.

You can easily verify everything I’ve said by examining the type of your data. That is done by using the typeof keyword. Here is an example of me using it to confirm everything I’ve just told you about:

Click here to view code image

var game = "Dragon Age: Origins";
alert("Length is: " + game.length);

var gameObject = new String("Dragon Age:Origins");

alert(typeof game); // string
alert(typeof game.length); // number
alert(typeof gameObject); // Object

Now, aren’t you glad you learned all this?