sub object functions in javascript

I know you can create literal objects with subobjects and functions:

var obj = {
    val : 1,
    level1 : {
        val : 2,
        val2 : 3,
        func : function(){
            return this.val2
        }
    }
}

console.log(obj.val);
console.log(obj.level1.val);
console.log(obj.level1.func());

outputs:

1
2
3

What I would like to do is do the same thing with methods in a object, something similar to:

function objType() {
    this.val = 1;
    this.func = function(){
        return this.val;
    }
    this.level1 = function(){
        this.val = 2;
        this.func = function(){
            return this.val;
        }
        this.level2 = function(){
            this.val = 3;
            this.func = function(){
                return this.val;
            }
        }
    };
};

then i would expect:

var obj = new objType();
console.log(obj.func());
console.log(obj.level1.func());
console.log(obj.level1.level.func());

to output:

1
2
3

However, only the first console.log outputs before the script throws an error.

Is there any way to have sub methods in Javascript?

--edit--

My goal is to create a class i can use for showing a box in the middle of the screen, for displaying messages, questions(to get a yes/no response), and forms. I was thinking a good way to structure it would be with sub methods, so that it could then be referenced with:

function box() {
    this.show = function(){
        //multiple sub methods here
    }
    this.hide = function(){
        //code to hide window here
    }
}

var aBox = new box();
aBox.show.message('the message');
aBox.hide();
aBox.show.question('the question');
aBox.hide();

--edit-- thanks @Sean Vieira

For completeness I'll put the modified version of my code here using his solution:

function objType() {
    this.val = 1;
    this.func = function(){
        return this.val;
    }
    this.level1 = {
        val : 2,
        func : function(){
            return this.val;
        },
        level2 : {
            val : 3,
            func : function(){
                return this.val;
            }
        }
    }

var obj = new objType();
console.log(obj.func());
console.log(obj.level1.func());开发者_高级运维
console.log(obj.level1.level.func());

that outputs

1
2
3

you can do this easily with chaining

function Box() {
    this.show = function(){
       //your code goes here
       return this;

    },
    this.message = function(message){
       //code goes here
       return this;
    }
  }

var aBox = new Box();
aBox.message('the message').show()

Your issue is that this in JavaScript refers to the containing scope -- which in the case of a function invoked with the new operator is a new Object and this applies everywhere within the scope of that function (unless you create a new scope in some way.)

So in your code we can replace this with an imaginary "new" object ... let's call it that.

function objType() {
    var that = {}; // This is what `new` does behind the scenes
    // (Along with a few other things we won't replicate here).
    that.val = 1;
    that.func = function(){
        return that.val;
    }
    // Do additional things with `that` here
    return that;
}

However, whenever you deal with a function that you are not calling as a "class" (as in a free-standing function or a "method" of an object) then this is set dynamically at runtime.

This means that:

function log_this() {
    console.log(this, 
                    "Type:", typeof this, 
                    "IsObject:", this instanceof Object,
                    "IsFunction:", this instanceof Function);
}

log_this() // window (i.e. global scope)
log_this.apply({"some":"object"}) //  {"some":"object"}
log_this.apply(function(){}) // Anonymous function function(){}
var test_object = { fun: log_this };
test_object.log_this() // test_object

This might work for level1:

var obj2 = new obj.level1();
console.log(obj2.func());