Chapter 3: Natives

Several times in Chapters 1 and 2, we alluded to various built-ins, usually called “natives,” like String and Number. Let’s examine those in detail now.

Here’s a list of the most commonly used natives:

  • String()
  • Number()
  • Boolean()
  • Array()
  • Object()
  • Function()
  • RegExp()
  • Date()
  • Error()
  • Symbol() — added in ES6!

As you can see, these natives are actually built-in functions.

If you’re coming to JS from a language like Java, JavaScript’s String() will look like the String(..) constructor you’re used to for creating string values. So, you’ll quickly observe that you can do things like:

  1. var s = new String( "Hello World!" );
  3. console.log( s.toString() ); // "Hello World!"

It is true that each of these natives can be used as a native constructor. But what’s being constructed may be different than you think.

  1. var a = new String( "abc" );
  3. typeof a; // "object" ... not "String"
  5. a instanceof String; // true
  7. Object.prototype.toString.call( a ); // "[object String]"

The result of the constructor form of value creation (new String("abc")) is an object wrapper around the primitive ("abc") value.

Importantly, typeof shows that these objects are not their own special types, but more appropriately they are subtypes of the object type.

This object wrapper can further be observed with:

  1. console.log( a );

The output of that statement varies depending on your browser, as developer consoles are free to choose however they feel it’s appropriate to serialize the object for developer inspection.

Note: At the time of writing, the latest Chrome prints something like this: String {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"}. But older versions of Chrome used to just print this: String {0: "a", 1: "b", 2: "c"}. The latest Firefox currently prints String ["a","b","c"], but used to print "abc" in italics, which was clickable to open the object inspector. Of course, these results are subject to rapid change and your experience may vary.

The point is, new String("abc") creates a string wrapper object around "abc", not just the primitive "abc" value itself.