This question already has answers here: How is a Javascript string not an object? (2 answers) Closed 7 years ago.

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 ar开发者_StackOverflow中文版e strings objects or not? And, either way, how can I make sense of everything I've listed?

---

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)).

---

In JavaScript, strings come in two flavors:

1. There is a String language type which contains values like "foo" and 'bar'. Those values are primitive values. Read about the String type here

2. Then there is a String constructor. (A constructor is a function object which is used to create new instances of a certain "class" (or pseudo-class)). So this: new String("foo") will create a new object (a value of the type Object), which contains the primitive value "foo". Read about the String constructor here

In practice you don't use the new String('foo') notation, but the string literal notation 'foo'.

---

So to answer your question:

In JavaScript, strings are not objects. They are primitive values. However, there exist String objects which can be used to store string values, but those String objects are not used in practice.

---

Primitive strings behaves like objects in JavaScript because they are automatically converted to objects when you call an object method:

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String

String objects may be created by calling the constructor new String(). The String object wraps JavaScript's string primitive data type with the methods described below. The global function String() can also be called without new in front to create a primitive string. String literals in JavaScript are primitive strings.

Because JavaScript automatically converts between string primitives and String objects, you can call any of the methods of the String object on a string primitive. JavaScript automatically converts the string primitive to a temporary String object, calls the method, then discards the temporary String object. For example, you can use the String.length property on a string primitive created from a string literal

---

String are both primitive and object type. Think about int, float, char ... which have real Object classes like Integer, Float and Char in Java.

---

String is a wrapper around the primitive string datatype. When you do something like var s = "My String" then a String wrapper object is created behind the scenes when needed..

It is interesting however that typeof s = 'string' instead of 'object'. Anybody know why that is?

---

Strings are objects, but what you are doing in your example is not creating a new String. By using 'new' you are creating an instance of a Object, not a 'string'

var F = function() {
    return 'c';
};
var a = new String('a');
var b = 'b';
var c  = new F();
alert("a is: " + typeof a + ", b is: " + typeof b + ", c is: " + typeof c);
// alerts: a is: object, b is: string. c is: object

You shouldn't use 'new' for strings regardless (or arrays, or 'simple' objects.)