Help with prototype object

Question

I am mlearning javascript and have some trouble creating an onject via prototype.
I have this:

 <script type="text/javascript">

        function myclass(a, b, c) {
            if (arguments.length) { this.Init(a, b, c); }
        }
        myclass.prototype.Init = function(a, b, c) {
            this.param1 = a;
            this.param2 = b;
            this.param3 = c;
        };
        myclass.prototype.Print = function() {

            alert(this.param1 + '-' + this.param2 + '-' + this.param3);
        };

        var myObject = myclass(3, 5, 6);
        myObject.Print();


    </script>

but I get an error on line with this.Init(a, b, c);
Error: Object doesn't support this property or method

Answer 1

Just out of curiosity is there a particular reason you have a separate "init" method?

The function that defines your "class" is called the "constructor" and you can just perform the setup there. If you wanted to "re-initialize" the object, then it may be helpful but it doesn't seem to serve a point here.

For instance:

// You might as well start wrapping your code now:

var myExample = (function myExample () {

    // A common convention is to start the name of constructors with a
    //      capital letter, one reason is it help makes it more obvious
    //      when you forget the new keyword...Whether you use it or not
    //      is up to you. Also note, calling it "MyClass" is a little
    //      misleading because it's not a "class" really. You might
    //      confuse yourself if you think of it as a class too much.
    //      If you're wondering why I put the name twice, it's because
    //      otherwise it would be an anonymous function which can be
    //      annoying when debugging. You can just use var MyClass = function () {}
    //      if you want

    var MyClass = function MyClass(a, b, c) {

        // This will set each parameter to whatever was provided
        //      or if nothing is provided: null. If you leave out
        //      the || "" part then any
        //      time a value is not provided the parameter will
        //      return "undefined". This may be what you want in some cases.

        this.param1 = a || "";
        this.param2 = b || "";
        this.param3 = c || "";   
    };

    // likewise it's convention to start most variables/functions lowercase
    //      I think it's easier to type/looks better, but do as you please.

    MyClass.prototype.print = function print() {
        alert(this.param1 + '-' + this.param2 + '-' + this.param3);
    };

    var myObject = new MyClass();
    myObject.print();
}());

The "wrapping" is

(function () {
 //your code here 
}());

It's mostly pointless here, but it's something you'll have to start doing eventually so might as well start now. That's just one way to "wrap" there are others as well.

Basically, the way your script was written, if the user ran another script that had a function called MyClass, it could overwrite yours or vice versa, causing problems.

The "wrapping" keeps it all within that function. If you need to make something available to outside stuff, you can expose it.

per comment:

You can access functions and variables from inside the wrapper by exposing them to the outside like so:

var myApp = (function myApp(){

    // The constructor for our "class", this will be available from outside because
    //    we will expose it later

    var myClass = function(){
        //code to set up "class" etc


        // See how we can use private function within myApp
        privateFunction();
     };


    // Here we set up the private function, it will not be available outside myApp
    //    because will will not expose it
    var privateFunction = function(){ };


    // Another public function that we will expose later
    var otherPublic = function(){};

    //now we expose the stuff we want public by returning an object containing
    //    whatever it is we want public, in this case it's just myClass and otherPublic

    return { myClass: myClass, otherPublic: otherPublic  };
}()); 

Note in that example we are just exposing the constructor, if you wanted instance of the object you'd have to collect them in a variable and expose that variable like:

var theInstance = new myClass();
return { theInstance : theInstance };

It would now be available outside myApp as myApp.theInstance

You can also use a more basic wrapping scheme:

var myApp =  {

    myClass: function(){

        //if we want to call another function in myApp we have to do it like so:
        myApp.publicFunction();
    },

    publicFunction: function(){},

    someString: "this is a string"

};

There myApp is just an object literal containing your functions etc. The main difference is that EVERYTHING in myApp can be accessed from outside via myApp.name or myApp[name];

Answer 2

You forgot the new keyword when you declare myObject:

var myObject = new myclass(3, 5, 6);