Question

Here are two reasons to think strings are objects. First, you can create a string in the following way:

var mystring = new String("asdf");

I’m under the impression that the constructor function following the new operator has to return an object. Second, strings seem to have properties and methods. For example:

mystring.toUpperCase();

BUT, if strings were objects, then we’d expect something like the following to work:

function string_constructor() {
    return "asdf";
}

var mystring = new string_constructor();

But it doesn’t, and I’ve been told it doesn’t because strings aren’t objects. So are strings objects or not? And, either way, how can I make sense of everything I’ve listed?

Answer 1

Speaking about language types, Strings are values of the String type.

The language has five primitive types, which are String, Number, Boolean, Null and Undefined.

There are String objects (also for Number or Boolean), they are called primitive wrappers, they are created when you use the constructor function associated with them, for example:

typeof new String('foo'); // "object"
typeof 'foo';             // "string"

But don’t get confused with them, you will rarely need to use primitive wrappers, because even if primitive values are not objects, you can still access their inherited properties, for example, on a string, you can access all members of String.prototype, e.g.:

'foo'.indexOf('o'); // 2

That’s because the property accessor (the dot in this case) temporarily converts the primitive value to an object, for being able to resolve the indexOf property up in the prototype chain.

About the constructor function you have in your question, as you know, it won’t return the string.

Functions called with the new operator return an implicit value, which is a new object that inherits from that function’s prototype, for example:

function Test () {
  // don't return anything (equivalent to returning undefined)
}

new Test() instanceof Test; // true, an object

If an object is returned from the constructor, that newly created object (this within the constructor) will be lost, so the explicit returned object will come out the function:

function Test2() {
  return {foo: 'bar'};
}

new Test2().foo; // 'bar'

But in the case of primitive values, they are just ignored, and the new object from the constructor is implicitly returned (for more details check the [[Construct]] internal operation, (see step 9 and 10)).