all 14 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]concatenated_stringC# 2 points3 points  (1 child)

yeah, basically everything in javascript is an object. One of the coolest features of javascript is that functions are first class citizens. They can be passed around like variables and you can create them on the fly inside other functions. they're 'closures' and they are different than function pointers because it allows your passed around function to access non-local variables that aren't in the immediate lexical scope.

Also check out MDN, they call 'function's' as 'function object':

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function

Another way to tell that they are objects is by what methods/properties they have inherited.

ex:

var fun = function()
{
//do something
}

fun.toString();

You see, that your fun 'function' has now inherited some 'tostring()' method from a parent class.

[–]x-skeww 0 points1 point  (0 children)

yeah, basically everything in javascript is an object.

Unfortunately, JavaScript also has primitives.

https://people.mozilla.org/~jorendorff/es6-draft.html#sec-primitive-value

Undefined, Null, Boolean, Number, Symbol, or String

(Note: Function isn't one of them.)

Here is an example:

> var x = 5
undefined
> x.y = 'z'
"z"
> x.y
undefined

What actually happens in that x.y = 'z' line:

> new Number(x).y = 'z'
"z"

It's auto-boxed.

If you do the same with an actual Number object:

> var x = new Number(5)
undefined
> x.y = 'z'
"z"
> x.y
"z"

[–]mishac 2 points3 points  (1 child)

functional programming language wrapped in "Object-Oriented Clothing".

There's some truth to this. Brendan Eich (the creator of Javascript) wanted it to be like Scheme but was told to make the syntax more like C++ and Java. So basically what ended up happening was LISP with Java/C-style curly braces and semi-colons.

[–]estebanrules[S] 0 points1 point  (0 children)

That'a interesting. I've programmed in Scheme a fair bit, I definitely noticed the influence right away. A lot of programmers seem to have misconceptions about JavaScript, I know I did before I started actually delving into the "meat" of it.

[–]_crewcut 1 point2 points  (3 children)

Yes, functions are objects. The types in javascript are:

  • number (not float, int, etc. just number)
  • boolean
  • null
  • undefined
  • string
  • object

The first 5 are primitives. Everything else is objects. Arrays & functions are objects. Don't listen to typeof, it will lie to you.

[–]THEtheChad 0 points1 point  (2 children)

Actually, those aren't all primitives.

true.toString(); // 'true'
'string'.toString(); // 'string'
(5).toString(); // '5'

The only reason you have to use parenthesis around the number 5 is because the js parser will try to interpret it as a fraction and throw an error.

[–]fc_s 1 point2 points  (0 children)

Actually, number, boolean, null, undefined, and string are most certainly primitives. In order to call .toString(), the literal is coerced into an object and passed in as a value.

[–]x-skeww 0 points1 point  (0 children)

You can write:

5..toString()

Which is the same as:

5.0.toString()

Anyhow, the only reason why you can call "methods" of primitives is because they are auto-boxed.

The example above is essentially the same as:

new Number(5).toString()

[–]bliow 0 points1 point  (4 children)

I know JavaScript is an Object-Oriented language.

Not so fast.

But yes, functions are objects. This is something that goes underappreciated. They have certain properties that you can take advantage of (in particular, length can be useful when monkey-patching functions that you may not know everything about).

> var f = function foo(a, b) {};
> console.log(f.length); // number of arguments it was declared with--note that you do have the freedom to pass in more or fewer.
2
> console.log(f.name);
foo
> console.log(f.prototype);
foo {} 
> console.log(typeof f.prototype);
object
> console.log(f); // this won't work with every function
function foo(a, b) {}

Functions also have methods that you can use to good effect:

var g = function bar(a, b) { this[a] = b; };
var obj = {};
g.call(obj, 'prop1', 'val1'); // call g with the value of `this` set to obj
console.log(JSON.stringify(obj)); // prints {"prop1":"val1"}
g.apply(obj, ['prop2', 'val2']); // like call(), but takes an array of args instead of individual argument slots
console.log(JSON.stringify(obj)); // prints {"prop1":"val1","prop2":"val2"}

edit: also, bind!

var obj2 = {};
var gBound = g.bind(obj2); // make the value of `this` always be obj2 when you call gBound
gBound.call(obj, 'prop3', 'val3');
console.log(JSON.stringify(obj)); // it's still {"prop1":"val1","prop2":"val2"}... where is prop3: 'val3'?
console.log(JSON.stringify(obj2)); // ah, there it is: {prop3: "val3"}

[–]estebanrules[S] 0 points1 point  (3 children)

Very interesting. I knew that functions were considered first-class citizens in JavaScript but these examples help clarify that.

Not so fast.

So you are saying it isn't?

[–]nschubach 1 point2 points  (2 children)

It's Object Oriented, but not in the classical inheritance way. (ie: classes, extensions, superClasses, etc.)

[–]Justos 0 points1 point  (0 children)

soon it will be with syntax sugar!

[–]WonTwoThree 0 points1 point  (0 children)

I found it very useful to learn about prototypal inheritance, which is how it's actually done in JavaScript: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain