var str = "ababccddabbb"; 
var obj = {}; 
for (var i = 0; i < str.length; i++) { 
    var key = str.charAt(i); 
    if (!!obj[key]) { 
       obj[key]++; 
    } 
    else { 
       obj[key] = 1; 
    } 
} 
console.log(obj); 
var max = -1, max_key = "", key; 
for (key in obj) { 
    if (max < obj[key]) { 
       max = obj[key]; 
       max_key = key; 
    } 
} 
console.log(max_key + ":" + max);

var str = "abcdefg";
var subStr="";
if (/efg/.test(str)) {
    subStr=str.substr(str.indexOf("efg"),3);
}
console.log(subStr);

function getBytes(str) {
    var len = str.length;
    var bytes = len;
    for (var i = 0; i < len; i++) {
        if (str.charCodeAt(i) > 255) {
            bytes++;
        }
    }
    return bytes;
}
console.log(getBytes("您好，hello"));

var assert = {
    isBoolean: function (G) {
        return (typeof G === "boolean");
    },
    isNumber: function (G) {
        return (typeof G === "number" && isFinite(G));
    },
    isString: function (G) {
        return (typeof G === "string" || G.constructor == String);
    },
    isFunction: function (G) {
        var A = {};
        return (A.toString.apply(G) === A.toString.apply(Function));
    },
    isArray: function (G) {
        return Object.prototype.toString.call(G) === "[object Array]";
    },
    isObject: function (G) {
        return (G && (typeof G === "object" || this.isFunction(G)) || false);
    }
};

基本类型（包括undefined,Null,boolean,String,Number），按值传递；
引用类型（包括数组，对象），按址传递，引用类型在值传递的时候是内存中的地址。例如：
var a = { "id": 1 };
var b = a;
b["name"] = 2;
console.log(a); //{id: 1, name: 2}
如果你修改b的值，那么a变量的值也发生了变化。
克隆分为2种：
A、浅度克隆：基本类型为值传递，对象仍为引用传递。
B、深度克隆：所有元素或属性均完全克隆，并于原引用类型完全独立，即，在后面修改对象的属性的时候，原对象不会被修改。
深度克隆对象代码：
function cloneObject(obj) {
    var o = obj.constructor === Array ? [] : {};
    for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            o[i] = typeof obj[i] === "Object" ? cloneObject(obj[i]) : obj[i];
        }
    }
    return o;
}
如果是一个简单的数组，元素中没有引用类型的值，可以直接用array.concat();或者array.slice(0);来深度拷贝一个数组，这样简单又高效。数组的concat()和slice()本来就会生成一个新的数组，原来的数组不会受影响。

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i += 1) {
        for (var j = 0; j < len - i - 1; j += 1) {
            if (arr[j + 1] < arr[j]) {
                var temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}
var arr = [-1, -5, 0, 300, 90, 90, -5];
bubbleSort(arr);
console.log(arr);

(function ($) {
    window.Util = window.Util || {};
    Util.getObjectKeys = function (o) {
        var keys = [];
        if (typeof o == "object") {
            for (var property in o) {
                keys.push(property);
            }
        }
        return keys;
    };
    Util.getObjectValues = function (o) {
        var values = [];
        if (typeof o == "object") {
            for (var property in o) {
                values.push(o[property]);
            }
        }
        return values;
    };
})(window.jQuery);

var str = '数码,女装,虚拟';
var arr = str.match(/\,/gi);
var items = arr == null ? 0 : arr.length; // 方法1
var items = str.split(',').length - 1; // 方法2
console.log(items);