What is meant by 'first class object'?

In a recent question, I received suggestions to talk on, amongst other things, the aspect of JavaScript where functions are 'first class' objects. What does the 'first class' mean in this context, as opposed to other objects?

EDIT (Jörg W Mittag): Exact Duplicate: "What is a first class programming construct?"

To quote Wikipedia:

> In computer science, a programming > language is said to support > first-class functions (or function > literal) if it treats functions as > first-class objects. Specifically, > this means that the language supports > constructing new functions during the > execution of a program, storing them > in data structures, passing them as > arguments to other functions, and > returning them as the values of other > functions.

This page also illustrates it beautifully:

> Really, just like any other variable

• A function is an instance of the Object type
• A function can have properties and has a link back to its constructor method
• You can store the function in a variable
• You can pass the function as a parameter to another function
• You can return the function from a function

also read TrayMan's comment, interesting...

The notion of "first-class functions" in a programming language was introduced by British computer scientist Christopher Strachey in the 1960s. The most famous formulation of this principle is probably in Structure and Interpretation of Computer Programs by Gerald Jay Sussman and Harry Abelson:

• They may be named by variables.
• They may be passed as arguments to procedures.
• They may be returned as the results of procedures.
• They may be included in data structures.

Basically, it means that you can do with functions everything that you can do with all other elements in the programming language. So, in the case of JavaScript, it means that everything you can do with an Integer, a String, an Array or any other kind of Object, you can also do with functions.

More complete approval of Strachey-Sussman-Abelson's formulation. So if your language supports such a construct then you've got a function as a first-class language :)

var men = function (objectOfAdmiration) {
  return objectOfAdmiration();
};
men.isSweetHeart = true;

var women = function (objectOfAdmiration) {
  return objectOfAdmiration();
};
women.isSweetHeart = true;

var aliens = function (objectOfAdmiration) {
  return objectOfAdmiration();
};

function like(obj){
  if (obj.isSweetHeart) {
      return function (){ return "Holy TRUE!"}; 
  }
  else {
      return function (){ return "Holy CRAP!"};
  }
}

alert("Men like women is " + men(like(women))); // -> "Holly TRUE!"
alert("Women like men is " + women(like(men))); // -> "Holly TRUE!"

alert("Men like aliens is " + men(like(aliens))); // -> "Holly CRAP!"
alert("Aliens like women is " + aliens(like(women))); // -> "Holly TRUE!" :)

//women(like(aliens)); //  Who knows? Life is sometimes so unpredictable... :)

In short, anything is a first-class object if it acts in the language as a state manipulation sort of object or type of object. Simply something you can operate on and pass around statements and evaluate in expressions at the same time. Or even shorter: when you can think of a function as an object that can be additionally invoked.

In javascript functions are first class objects because it can do a lot more than what objects can do.

• A function is an instance of an Object type.

Function instanceof Object //returns true

Like an object a function can have properties and can have a link back to it’s constructor function.

 var o = {}; // empty object 'o'
    o.a = 1 ; 
    o.b = 2 ; 

    console.log(o.a); // 1
    console.log(o.b); // 2 


    function foo(){};
    foo.a = 3 ; 
    foo.b = 4 ; 

    console.log(foo.a);  // logs 3
    console.log(foo.b);  // logs 4 

• Functions can be stored in a variable as a value.

  var foo = function(){}; 
    console.log(foo); // function(){}

• Functions can be passed as arguments to other functions

function callback (foo){
      foo();
}

callback(function(){console.log('Successfuly invoked as an argument inside function callback')})

• You can return a function from a function

 function foo(){
	    return function(){console.log('working!')};
    }

    var bar = foo();
    bar(); // working!

• Can be stored in a variable as a reference.

    var sum = function (a,b){return a+b}  
    sum(4,4);

JavaScript functions are first-class functions meaning functions and objects are treated as the same thing. Functions can be stored as a variable inside an object or an array as well as it can be passed as an argument or be returned by another function. That makes function "first-class citizens in JavaScript"

JavaScript uses literal notation syntax which makes it hard to fully grasp the fact that in JavaScript functions are objects.

For example..

var youObj1 = new Object();
// or
var youObj1 = {};

both declerations are equivalent. By using new we are calling the constructor function of an Object. Also by using {} (JavaScript shortcut called literals) we are calling the construction function of an Object. {} is just a shorter representation for instantiating the constructor.

Most languages uses new keyword to create an object, so lets create a JavaScript object.

var myFunction = new Function("a",  "b", 'return a_b');

As you see we created an object name function.

Creating same object name function using JavaScript function expression..

var myFunction = function myFunction(a,b) {
    return a+b;
}

Here we go we just created a object name function.

Simple test. If you can do this in your language (Python as example):

def double(x):
    return x*x

f = double

print f(5) #prints 25

Your language is treating functions as first class objects.

Definition on the Mozilla site is concise and clear. According to them,

> In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are Function objects.

And

> a function is a "subprogram" that can be called by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the function body. Values can be passed to a function, and the function will return a value.

It means that functions are objects, with a type and a behaviour. They can be dynamically built, passed around as any other object, and the fact that they can be called is part of their interface.

It means that function actually inherits from Object. So that you can pass it around and work with it like with any other object.

In c# however you need to refrain to delegates or reflection to play around with functions. (this got much better recently with lambda expressions)

i guess when something is first class in a language, it means that it's supported by its syntax rather than a library or syntactic sugar. for example, classes in C are not first class

Simple in JavaScript, functions are first-class objects that is, functions are of the type Object and they can be used in a first-class manner like any other object (String, Array, Number, etc.) since they are in fact objects themselves. They can be “stored in variables, passed as arguments to functions, created within functions, and returned from functions