JavaScript Prototype and Encapsulation

Your code is almost right. Just lose this when accessing tagId. this.tagId is setting a property on that particular TextField, not the var tagId you declared up top.

If you set a variable x without using var, as in x = 2, it finds the nearest x going up the scope chain; if none is found it ends up being a property of the global object (window). In your case you can modify tagId from any of those functions since they can reach it one level up. That's why it's used as a "private" variable, the same way privateMethod can be reached.

And since jeeni.TextField is being set to the return value from the whole function, you don't to reference jeeni on the inside.

jeeni.TextField = (function(){

    var tagId;

    var privateMethod = function(){
        console.log("IN: privateMethod");
    }

    var publicMethod = function(){
        console.log("IN: publicMethod: " + tagId);
    }

    function TextField(id){
        // this === the new instance of TextField
        console.log("Constructor", this);
        // set the tagId variable which is in scope here
        tagId = id;
    }

    TextField.prototype.foo = publicMethod

    return TextField

 }()); 

Note that I also added var before the public/private methods, otherwise you are leaking them to the global scope. You could just as well use function publicMethod(){ ... }, which is usually better for debugging.

In case you're confused, x = function(){}... is not the same as function x(){}. See chapter 2 of "Named function expressions demystified".

With that cleared up, this is still probably not what you want, since with this code tagId will be shared between all instances of TextField. The usual method of having one tagId per instance would be making it a "public" property, which is exactly what you had done (I don't see any problem with this, since id itself comes from the outside):

...

// var tagId -> drop this

publicMethod = function(){
    console.log("IN: publicMethod: " + this.tagId);
}

function TextField(id){
    console.log("Constructor");
    this.tagId = id;
}

Now let's make tagId private and specific for each instance. The simplest way to do it, without creating new functions every time, is to create a private object (let's call it tags) that holds all the data, and give each instance it's own ID (tf_id). The ID is visible, but since the tags object is private you can only access the data by using one of the public methods:

jeeni.TextField = (function(){

    var tags = {}
      , uid = 0;

    privateMethod = function(){
        console.log("IN: privateMethod");
    }

    publicMethod = function(){
        console.log("IN: publicMethod: " + tags[this.tf_id].tagId);
    }

    function TextField(id){
        this.tf_id = uid++
        tags[this.tf_id] = id
    }

    TextField.prototype.foo = publicMethod

    return TextField

 }());

Apparently I read the question incorrectly.

If you set a property of something (i.e. this.tagId) it immediately becomes accessible to the world. You've wrapped your constructor in the wrong spot - change it to something like this instead:

jeeni.TextField = (function(){
    var TextField = function(id){
        console.log("Constructor");
        var tagId = id;
        privateMethod = function(){
            console.log("IN: privateMethod");
        }

        this.publicMethod = function(){
            console.log("IN: publicMethod: " + tagId);
        }
    }

    TextField.prototype = {
            constructor: TextField
    };

    return TextField;
}());

Basically, you won't be able to put anything on the prototype that requires access to those protected variables.

There are a few problems here. The first is that you are messing about with global variables in a not-normal way. Effectively you have this:

var globalVar;

globalVar = function() {
    globalVar = function() {
        //... stuff
    }
    return globalVar;
}

What are you hoping that will do? The normal way to write this is:

function myObj(id) {
    // in javascript the function *is* the constructor
    tagId = id;
    function someMethod() {
        //...
    }
}
var globalVar = new myObj(someId);

Although it's better to avoid globals.

In the example you give, this is the actual object you're returning:

 function(id){
    console.log("Constructor");
    this.tagId = id;
}

So no, it doesn't have a privateMethod or publicMethod for that matter. Since this function object is constructed in the scope of the enclosing function, the constructor could access privateMethod, which is where the privacy of it comes from.

To see how to do private variables and methods in javascript, go to the wizard himself:

http://javascript.crockford.com/private.html