Basic Object Structure and Calling for JavaScript [duplicate]

The inner function is just a function implemented in the scope of the parent's one. It's not a member of the whole object.

Usually you do this:

function Object1() {
}

Object1.prototype = {
    function1: function () { 
         alert("hello");
    }
};

var obj = new Object1();
obj.function1();

It's important to note that this is using the prototype of the constructor function Object1, thus this approach will allow object inheritance:

var Object2 = Object.create({ function2: function() { } }, Object1.prototype);

See more about object-oriented prototype-based programming on Mozilla Developer Network (MDN):

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript

i think you will like this

var Object1 = function(name) {
  this.name = name;
};

Object1.prototype.function1 = function(prefix) {
  console.log(prefix + " " + this.name);
};


var obj = new Object1("naomi");
obj.function1("hello");
//=> "hello naomi"

An added demonstration for private data members

Object1.prototype.otherFunction = function() {

  // private variable
  var count = 0;

  // private function
  var incrementCounter = function() {
    count += 1;
  };

  return incrementCounter();
};

obj.otherFunction(); //=> 1
obj.otherFunction(); //=> 2
obj.otherFunction(); //=> 3

Just for fun, here's a subclass, too!

var Object2 = function(name, numberOfCats) {

  // call parent constructor
  Object1.call(this, name);

  this.numberOfCats = numberOfCats;
};

// setup prototype chain
Object2.prototype = Object.create(Object1.prototype, {constructor: {value: Object2}});

// an object2 public instance method
Object2.prototype.sayHello = function() {
  console.log(this.name + " has " + this.numberOfCats + " cats");
};

Usage is as you'd expect

var obj2 = new Object2("naomi", 3);
obj2.sayHello()
//=> "naomi has 3 cats"

Our method from Object1 is inherited too

obj2.function1("hi my name is");
//=> "hi my name is naomi"

And the private one too

obj2.otherFunction(); //=> 1
obj2.otherFunction(); //=> 2

This function would be 'private'.

To make it publicly accessible, you would need to do something like this:

function Object1() 
{
    this.Function1 = function() 
    {
        alert("hello");
    }
}

var thingy = new Object1();
thingy.Function1();

Similarly, to make private variables, you would use:

function Object1()
{
    var myPrivateVariable = 'something';
}

While public variables would be:

function Object1()
{
    this.myPublicVariable = 'something';
}

Try to avoid declaring a bunch of your variables as global, which happens by accident when you forget to declare them directly:

function Object1()
{
    globalVariable = 'oops';
}

JavaScript handles OOP quite a bit differently than most other languages, especially when it comes to prototyping and closures.

THIS is a decent link to the basics, but I also recommend the classic "JavaScript: The Good Parts" as well.

I believe this is the best way to achieve what you want.

var Thing = (function () {
    function Thing(varOne) {
        this.varOne = varOne;
    }
    Thing.prototype.saySomething = function () {
        console.log(this.varOne);
    };
    return Thing;
})();

var app = new Thing("Cheese");
app.saySomething();

If you want to use objects and classes inside JavaScript, might I take the liberty to suggest TypeScript? It compiles into plain old javascript and can work with your existing javascript code.

Now some might suggest that this is a radical change. Its really not. Its just JavaScript with classes, and since its a superset of Javascript, it can make things infinitely easier. Furthermore, Typescript will be fully functional javascript when ECMAScript 6 is released, so why not use the to-be-released features today, and when it does come out, you can just change the type extension from typescript to javascript. If you just want to take a look at how it works, just look here.

Demo:

This is from a nodejs console.

> var Thing = (function () {
...     function Thing(varOne) {
.....         this.varOne = varOne;
.....     }
...     Thing.prototype.saySomething = function () {
.....         console.log(this.varOne);
.....     };
...     return Thing;
... })();
undefined
> var app = new Thing("Cheese Cake");
undefined
> app.saySomething();
Cheese Cake
undefined
>

I generated the above js code using Typescript, this is what the Typescript looks like:

class Thing {
    constructor( public varOne: string) {}

    saySomething (): void {
        console.log(this.varOne);
    }
}

var app = new Thing("Cheese");
app.saySomething();

As you can see, the syntax is much cleaner. You can go to Typescript's official website to learn more.

I think this is what you want.

var Object1 = {
    Function1: function() {
        alert("hello");
    }
}

Object1.Function1();

As you said that you want to create an object and an function inside that object, this is how it should be done:-

var myFunc = function() {   
    alert("Hello");
}

var myObj  = {"func":myFunc};

Now you can use:- myFunc.func();