code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

Object.prototype.dump = function( excludePrototype, maxDepth, depth ){
    depth    = depth || [];
    maxDepth = maxDepth >= 0 ? maxDepth : -1;
    excludePrototype = !!excludePrototype;
    
    // some working vars
    var output = [ "" ],
        key = "",
        indent = "";

    for( var i = 0; i < depth.length; i++ ){
        indent += "  ";}

    if( maxDepth === -1 || depth.length < maxDepth ){
        for( key in this ) if( ( this.hasOwnProperty( key ) || excludePrototype ) ){
            
            if( depth.contains( this[ key ] ) ){
              output[ 0 ] = "{circular reference}";
            
            } else {
                depth.push( this[ key ] );
                output.push( 
                    indent + key + ": " + 
                    this[ key ].dump( excludePrototype, maxDepth, depth ) 
                );
                depth.pop( this[ key ] );
            
            }    
        }
    } else {
       output[ 0 ] = "{object}";
    }

    return output.join("\n");
};

Array.prototype.contains = function( obj ){
    for( var i = 0; i < this.length; i++ ){
        if( this[ i ] === obj ){
            return true; }
    }

    return false;
};

// default dumpster method
var defaultDumpster = function(){ return this.toString(); };

String.prototype.dump =
Number.prototype.dump =
RegExp.prototype.dump =
Boolean.prototype.dump = defaultDumpster;

Function.prototype.dump = function(){ return "{function}"; };
Date.prototype.dump = function(){ return "{" + this.getTime() + "}"; };

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

var obj = {
    num: 123,
    str: "testString",
    bln: true,
    arr: [ 1, 2, 3 ],
    fnc: function(){ return "moooo"; },
    rxp: /^.*$/gi,
    dt: new Date(),
    obj: {
        num: 123,
        str: "testString",
        bln: true,
        arr: [ 1, 2, 3 ],
        fnc: function(){ return "moooo"; },
        rxp: /^.*$/gi
    }
}

obj.obj.obj = obj;

// Doesn't include the methods/properties declared in a objects prototype.
obj.dump( false ) 

// Iterate throught the first object and also dump evrything (not native) of the prototype.
obj.dump( true, 1 ); 

Backwards compatability

1
2
3
4

function odump(obj, depth, max){
    return obj.dump( true, max );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

var odump = (function(){
  var max, INDENT = "                                   "; // As long as you need :)
  
  function valueToStr(value, depth) {
    switch (typeof value) {
      case "object":   return objectToStr(value, depth + 1);
      case "function": return "function";
      default:         return value;
    }
  }
  
  function objectToStr(object, depth) {
    if (depth > max)
      return false;
    
    var output = "";
    for (var key in object)
      output += "\n" + INDENT.substr(0,2*depth) + key + ": " + valueToStr(object[key], depth);

    return output;  
  };
  
  return function odump(object, depth, _max) {
    max = _max || 2;
    return objectToStr(object, depth || 0);
  };
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

TEST = { };
TEST = (function() {
	var max,
		depth = 0,
		INDENT = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
	function valueToStr(value, depth) {
		switch(typeof value) {
			case "object": 
				return objectToStr(value, depth + 1);
			case "function": 
				return "function";
			case "string":
				return "'"+value+"'";
			default:         
				return value;
		}
	};
	function objectToStr(object, depth) {
		if(depth > max)
			return false;
		var type = Object.prototype.toString.call(object),
			output = "\n",
			indent = INDENT.substr(0, depth);
		for(var key in object)
			output += indent + valueToStr(key) + ": " + valueToStr(object[key], depth) + ",\n";
		indent = INDENT.substr(0, depth - 1);
		switch(type) {
			case "[object Object]":
				return "{ " + output.substr(0, output.length - 2) + "\n" + indent + "}";  
			case "[object Array]":
				return "[ " + output.substr(0, output.length - 2) + "\n" + indent + "]";  
			default:
				return;
		}
	};
	return function(value, aggregate, MAX) {
		max = MAX || 2;
		value = valueToStr(value, depth);
		var d = document.getElementById("TEST");
		if(!d) { // TEST does not exist
			var d = document.createElement("textarea");
			d.id = "TEST";
			document.body.appendChild(d);
		}
		d.innerHTML = aggregate ? d.innerHTML + value : value;
	};
})();