Object.prototype.valueOf() method

{ '0': 'a'
, '1': 'b'
, '2': 'c'
Object.prototype.valueOf.call(new String("abc"))
{ '0': 'a'
, '1': 'b'
, '2': 'c'

According to MDN JavaScript calls the valueOf method to convert an object to a primitive value.If an object has no primitive value, valueOf returns the object itself, which is displayed as: [object Object] But above valueOf is returning in different format rather than returning primitive { '0': 'a' , '1': 'b' , '2': 'c' }.Isn't it against the definition?Why is it returning in that format .Now,this has created confusion .How to know what will get returned if Object.prototype.valueOf.call(array) is called for array and other objects.

Also why the return object form {}.valueOf() gets displayed since returns from [].valueOf() method when logged displays nothing



Let's look at what valueOf (that's a link) does:

Let O be the result of calling ToObject passing the this value as the argument.



Create a new String object whose [[PrimitiveValue]] internal property is set to the value of the argument. See 15.5 for a description of String objects.

In other words, it simply creates a new string object with the original value, i.e. new String('abc'). Now take a look at how that is displayed in your console, and you'll notice it's the same as the .valueOf.call result.

Edit: This actually has more to do with what medium you use to view the answer. Chrome's and Firefox's dev tools display strings as their literal values (the string itself), but display string objects as if they were regular objects (by displaying their properties).

A string is just an "array" of characters with some methods on them. So the representation {'0' : 'a', '1' : 'b', '2' : 'c'} means "a in the first position, b in the second, c in the third", which is the string you asked for.

And as a final note, valueOf does not give [object ObjectName]. You may be referring to Object.prototype.toString


Perhaps I've missed what the actual question is. Here is what ECMA-262 says: Object.prototype.valueOf ( )

When the valueOf method is called, the following steps are taken:

  1. Let O be the result of calling ToObject passing the this value as the argument.

  2. If O is the result of calling the Object constructor with a host object (, then

    a. Return either O or another value such as the host object originally passed to the constructor. The specific result that is returned is implementation-defined.

  3. Return O.

In the expression:


Object.prototype.valueOf is being called with a string primitive as this. So at step 1, it is converted using the internal ToObject method.

If passed a value of Type String (which "abc" is) ToObject will return a String object.

Step 2 is irrelevant since the object is not a host object (it's a native object).

Step 3 returns the object created by toObject.

So test it:

var x = Object.prototype.valueOf.call("abc");

alert(typeof x); // object

typeof returns object because the resulting value is a String object (a nice quirk of the typeof operator). You can go further:

typeof x.match; // function
x.constructor;  // function String() {[native code]}
alert(x); // abc

All consistent with the returned value being (a reference to) a String object.


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us Javascript

©2020 All rights reserved.