javascript - Why "function" keyword is necessary before object name ?All objects are function in real? - Stack

admin管理员组

文章数量:1340362

When we make an object like this

function myObject(){  
Properties and methods here----
}; 

We write “function” keyword before name of object is it necessary? All objects are functions in real? Can we not write direct object name like this?

myObject(){  
Properties and methods here----
}; 

When we make an object like this

function myObject(){  
Properties and methods here----
}; 

We write “function” keyword before name of object is it necessary? All objects are functions in real? Can we not write direct object name like this?

myObject(){  
Properties and methods here----
}; 

• javascript
• object

Share Improve this question Follow asked Jul 28, 2011 at 10:22 JamnaJamna 2,57777 gold badges2828 silver badges2323 bronze badges

Add a ment  | 

8 Answers 8

Sorted by: Reset to default 4

No, not all objects are functions. (All functions are objects, though.)

Here, obj isn't a function:

var obj = {
    foo: "bar"
};

Nor dt here:

var dt = new Date();

The function keyword is necessary in order to say "what follows is a function declaration or function expression." It's just part of the basic syntax of JavaScript.

in the first case, the function can be used as the constructor for an object. So you can have:

function Person(name) {
    this.name = name
}

Person.prototype = {
    // methods can go in here
}

person1 = new Person("bob");
alert(person1.name) // alerts "bob"

It is also true that you can use a function as an object. For example:

function myObject() {
    return myObject.test;
}

myObject.test = "bob";
alert(myObject()) // would alert "bob"

but all objects are not functions.

var someObject = {
     name: "bob",
     moody: "sad"
}

alert(someObject.name); // alerts "bob"
try {
    someObject();
} catch (er) {
    alert(er);  // alerts "TypeError: object is not a function"
}

I'd suggest you take a look at https://developer.mozilla/en/JavaScript/Reference/Global_Objects/Function

One reason is obviously disambiguity;

function foo() 
{
    alert("cake") 
}

foo()
{
    alert("burb");
}

foo();

alerts cake, burb, cake as the 2nd foo() {...} is just a regular function call followed by a regular pound statement enclosed in {}.

function declares a function. Because of the way JavaScript works, a function can be used as a class, to make objects.

But if you really just want an object, use squiggly braces, like this:

var myObject = {
  x : 30, // a property
  getX : function() { // a method
     return this.x;
  }
}

But your understanding of JavaScript needs a lot of work: read a few books about it.

In Javascript we can create objects in various ways:

1) Literals

   let employee = {"name": "tyrion","age":34}

2) Constructor functions(functions having this)

   function employee(name, age) {
     this.name = name;
     this.age = age;
   }

let specificEmployee = new employee("tyrion",34);

Constructor function always need to have a new operator to create a object

3) Using Object constructor

   let employee = Object.create(null);
   employee.name = "tyrion";
   employee.age = 34

In javascript every thing other than primitive type is an instance inherited from Object constructor.

No it's not required. You can also have:

var myObject = {  
   Prop1: "Value1", 
   Prop2: "Value2", 
   Method1: function() {
      alert("hello");
   }
};

Live test case: http://jsfiddle/rKunx/

You can write:

myObject = {
Properties and methods here----
}

If you want to avoid the function keyword as much as possible in Java you could use classes:

class Person {
  name;

  setName(name) {
    this.name = name;
    this.doStuff();
  }
  doStuff() {
    //...
  }
}

The obvious disadvantage to using classes though is that any property or function has to be accessed with this. An advantage of this keyword is that it is clear to know that you are referring to a class property or function and not a local one within the function.

Some people use a var or let in the top:

setName(name) {
  let t = this;
  t.name = name;
  t.doStuff();
}

Still, many prefer to use a function to define some kind of class instead since that does not need this in order to reach the properties which are just variables in the scope of the function. Put inside a module you will still be able to contain these in much the same way you would a class.

If I could make a wish for the future of Javascript it would be to find some way that this is implicitly referring to the class in some way to have a smaller code style with less tokens and easier readability.

本文标签：