10

Clarification:
"JavaScript constructor" should be more properly be written as "javascript constructor" to emphasize that the constructors considered are not just the native JavaScript language constructors, such as Object, Array, Function, etc. but also others, extrinsic to the JavaScript language definition but intrinsic to a browser, such as XMLHttpRequest, The word "JavaScript" is meant to indicate these constructors are expressed and accessed using JavaScript.

some references:

Rhetorically, there are references to constructor functions but NOT constructor objects!

(Facetiously, this is because Objects ARE functions, and Functions are objects!
Why in JavaScript is a function considered both a constructor and an object?
More specifically, objects, or is that obj-eggs?, ARE, ignoring literal instances, instantiations of functions and functions are Object instances of Functions. It is arguable that functions are fundamental to the existence of objects as evidenced by the fact
7. Functions
      precedes
8. Working with Objects
in the MDN docs JavaScript Guide. That section 8, I object!, provides the details needed to create objects using constructors and function instantiations!)

Why are constructors that interface the DOM not functions?

javascript:
  alert([
    "using browser environment:  \n"+window.navigator.userAgent,
     Option, Image, Audio,
       Storage, XMLHttpRequest, Worker, FileReader,
   ] . join("\n\n"));

shows us:

using browser environment:
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3) Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3

[object Option]

[object Image]

[object Audio]

[object Storage]

[object XMLHttpRequest]

[object Worker]

[object FileReader]

but ... 

javascript:
  alert([
             XPCNativeWrapper,
  ].join("\n\n"));

(which produces

function XPCNativeWrapper() { [native code] }

)

and JavaScript language constructors ARE functions.

javascript:
  alert([
    "using browser environment:  \n"+window.navigator.userAgent,
             Array, Boolean, Date, Function,
               Number, Object, RegExp, String,
                 Error, Iterator,
  ].join("\n\n"));

gives us:

using browser environment:
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3) Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3

function Array() { [native code] }

function Boolean() { [native code] }

function Date() { [native code] }

function Function() { [native code] }

function Number() { [native code] }

function Object() { [native code] }

function RegExp() { [native code] }

function String() { [native code] }

function Error() { [native code] }

function Iterator() { [native code] }

Improve this question
2
  • function Object() { [native code] } Clearly Object is a function. (my tongue is in my cheek and I am being cheeky but ,,,) Commented Aug 9, 2011 at 4:53
  • Here are some Object objects that ARE functions: javascript:x=y=z=Object; alert([x,y,z].join("\n\n")) reiterating, every Object is a function! (not so every object!) Commented Aug 10, 2011 at 21:03

3 Answers 3

Reset to default
3

First:

Objects ARE functions

No, the are not:

> a = function() {}
  function () {}
> a instanceof Object
  true
> b = {}
  Object
> b instanceof Function
  false

The toString method (which is what gets called when you do string concatenation) is not a reliable way to get information about an object. If I use typeof, I get the following:

using browser environment:  
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:5.0.1) Gecko/20100101 Firefox/5.0.1

function

function

function

object

function

function

function

So you see, most of them, apart form Storage, are actually functions (why it does not work for Storage, I don't know).

Also keep in mind that the DOM interface can behave differently than native JavaScript objects.

On the other hand, in Chrome the toString method gives this:

[object Function] 

[object Function] 

[object Function] 

function Storage() { [native code] } 

function XMLHttpRequest() { [native code] } 

function Worker() { [native code] } 

function FileReader() { [native code] }
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

typeof Storage === "function" in chrome12
The statement "Objects are functions!" was qualified as facetious - but ... Objects ARE Function instantiations! Without functions there are no instantiations, and without instantiations, via new, there are no objects! (except for literals such as {property1:value1, property2:value2} and predefined entities)
@ekim: Whether all objects are function instantiations is a difficult topic. You could say that everything is eventually created through the Object constructor function and inherits from Object.prototype. But what does the Object function inherit from? From Function.prototype which itself inherits from Object.prototype again. But Object.prototype does not inherit from any other object.
@ekim: If you want to have a better insight, I suggest you read the ECMAScript specification: ecma262-5.com
also ... There is a distinction between an object (lower case) instance of arbitrary type, and an Object (capitalized), the constructor for an Object type which IS a function!
|
2

When you alert those values the browser engine is alerting value.toString() so we are talking about why does Function.prototype.toString behave in a strange manner.

The ES5.1 specification states :

15.3.4.2 Function.prototype.toString ( ) An implementation-dependent representation of the function is returned. This representation has the syntax of a FunctionDeclaration.

Note in particular that the use and placement of white space, line terminators, and semicolons within the representation String is implementation-dependent.

The toString function is not generic; it throws a TypeError exception if its this value is not a Function object. Therefore, it cannot be transferred to other kinds of objects for use as a method.

Clearly ES5 states that toString returns an implementation specific string.

If you read the ES Harmony proposals page it states :

function to string – greater specification for problematic Function.prototype.toString (markm, allen)

Here are some more resources :

Basically it's a known issue that toString on function objects (and especially host objects that are also functions) is undefined behaviour. The TC39 committee is already working on standardizing this.

As you can see the host objects are proposed to be standardized in strawman so it's in the air whether that makes it into ES6. However function objects living in ECMA land should have a standardized toString method in ES6 as defined on the harmony proposals page.

Improve this answer

14 Comments

"15.3.4.2 Function.prototype.toString ( ) An implementation-dependent representation ... has the syntax of a FunctionDeclaration. " Chrome's function Worker() { [native code] } qualifies but [object Worker] does not.
so ... Why don't Image, Option etc. conform? Why are they "known issues"?
@ekim again please distinquish between Host objects (part of the browser and DOM) and ES objects. Host objects can do whatever they please because they are host objects. They are as non-standard as you can get.
This is off topic but ... Predefined objects are conventional and de facto standardized, such as JavaScript: (quoting developer.mozilla.org/en/JavaScript/Reference#Global_Objects) "Global Objects Standard global objects (by category)" though to be sure browsers from different vendors may "warp" the definitions and occasionally augment the "standard" repertoire. The original question does not ask about "host objects" per se but '"JavaScript" constructors' (which are objects of type Function) only.
@ekim sorry what is the standard for the fucntion objects in the DOM? WHERE does it say in the STANDARDS how host constructor objects should behave? WHY ARE YOU COMPLAINING ABOUT UNDEFINED BEHAVIOUR BEING UNDEFINED!
|
1

The question might actually be paraphrased as:

"Do JavaScript (ECMAScript) language conventions apply to and qualify other components of the browser such as the programming objects that interface the DOM?"

The original question uses objects that are supposedly of type Function and used as constructors. The examples shows a dichotomy exists with the programming environment and the DOM interface in how they are represented.

If there is this actual dichotomy, is it made explicit?

This may be the actual issue. If so, the original question should be preceded by this to direct attention to the real problem.

references:

ECMAScript language constructor details:

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.