I'm trying to do something very simple. That is, create an object with a function I can call from somewhere else. I must be missing something. The code I'm trying right now is:
function Object1() {
function function1() {
alert("hello");
}
}
Object1.function1();
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):
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 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
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.
You can do this:
Class1 = function () {
this.Function1 = function() {
alert("hello");
}
}
var Object1 = new Class1()
Object1.Function1();
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();
