Difference between functions in C# and Javascript?

What most authors say is that "functions are first class citizens" in javascript. They are not first class in C#, in that they are merely methods there, attached to a class. Method delegates (and lambdas) are specific classes for the purpose of making methods like first class citizens.

So here's the thing, as best I can explain it, without telling you to go back and read Crockford's "Javascript: The Good Parts" and something by like Skeet or someone:

Javascript has a lot less parts than C#. Don't compare something you can do in C# directly with something you can (or can't) do in Javascript (and vice-verse).

So why don't all languages (or at least C#) have "first class functions"? The answer is usually the simplest: Because that wasn't a language design requirement. That's sort of a cop-out on my part, however, because obviously they've added it in now. But if nobody told you to include it in your future-language, would you?

So the key thing to remember is: in C# functions (methods) have to be attached to a class. In Javascript they don't. The why is in the language definition (spec).

Also, I should follow this up with a statement on object creation:

You can create a new object in javascript in one of two ways:

//using object syntax
var ob1 = { name: value, nestedFunction: function(){} };

or

//using a function
function MyFunc(){
  var name = value;
  function nestedFunction(){}
}
var ob2 = new MyFunc();

And in the second case we're using a function to declare the object, in the first case we're just declaring it using literal syntax.

To do the same thing in C# we have to create a new object as a class:

MyClass ob1 = new MyClass(); //constructor is a member function of the class
public class MyClass {
  public MyClass() {
  }
  public void nestedFunction(){
  }
}

Notice how in the Javascript one I still had to define the method that was being returned.

Ok, I think that's enough for tonight.

Javascript functions can be created and assigned to a variable, they're first class citizens in the language and have some more flexibility over the syntactical sugar that C# has applied.

In C#, when you write the code

x => x * x

The compiler creates a real named method and wraps that method in a delegate that can be executed.

Delegates, along with the syntactic sugar that C# applies gives a very similar feel to JavaScript, but it's doing very different things internally.

In JavaScript you can create a function and assign it directly to a variable and execute it without wrapping it in any other structures to enable the action. Functions are first class citizens in JavaScript.

I have some rough ideas about the difference between JS and C#:

1, Js is an interpreted language, which means JS needs a browser build-in ECMAScript interpreter to work. Whereas C# is a Compiled language, which means C# codes will be compiled as IL to work.

2，JS is a dynamically typed language, which means you don't need to specify the types of the variables when defining. Whereas C# is statically typed language, which means you need to specify the exact types of the variables.

3, OOP-encapsulation, in JS, a lot of people say function is first class citizen. Normally, function has 2 kinds of usages: a)just a function to manipulate some work b)class&constructor, using which you can instantiate objects. Whereas in C#, function is function, which should belong to class(or interface).

4, OOp-inheritance, in JS, we use prototype to realize inheritance. Whereas in C#, we strictly use class to realize inheritance.

5, OOP-polymorphism, in JS, according to my knowledge, we can use arguments, which is a pseudo-array, to realize functional overload to simulate polymorphism, which is a bruising. Whereas, for C#, polymorphism is so perfectly embodied.

6, In JS, we don't have GC. Whereas, there is a strong GC for C#.

Maybe some ideas are not correct, welcome suggestions.

Just to clarify some confusion;

1) JavaScript is a compiled language indeed. The way the code is compiled is right before the execution on the browser, and it is fast! This is why some developers think it's an 'interpreted' language.

2) C# does not have functions in JS sense. It has class methods.