【javascript】常用方法（持续更新）

var json = {
    "Adam": {
        "name": "Adam",
        "sex": "man",
        "age": 18,
        "hobby": ["Ping-Pang", "basketball"],
    },
    "Jack": {
        "name": "Jack",
        "sex": "man",
        "age": 20,
        "hobby": ["Ping-Pang", "basketball"],
    }
};;
console.log(JSON.stringify(json));

function duplicates(arr) {
    var result = [];
    arr.forEach(function(elem) {
        if (arr.indexOf(elem) != arr.lastIndexOf(elem) && result.indexOf(elem) == -1) {
            result.push(elem);
        }
    });
    return result;
}
console.log(duplicates([1, 2, 4, 4, 3, 3, 1, 5, 3]));

function square(arr) {
    var newArr = [];
    arr.forEach(function(e) {
        newArr.push(e * e);
    });
    return newArr;
}
console.log(square([1, 2, 3, 4]));

function findAllOccurrences(arr, target) {
    var a = []
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            a.push(i);
        }
    }
    return a;
}
console.log(findAllOccurrences('abcdefabc'.split(''), 'a').sort());

function indexOf(arr, item) {
    var eleIndex = 0;
    arr.forEach(function(e, index) {
        if (e == item) {
            eleIndex = index;
        }
    });
    return eleIndex;
}
console.log(indexOf([1, 2, 3, 4], 3));

console.log(([][
    []
] + [])[+!![]] + ([] + {})[!+[] + !![]]);

vara = ~~2.33;
varb = 2.33 | 0;
varc = 2.33 >> 0;
console.log("vara: " + vara);
console.log("varb: " + varb);
console.log("varc: " + varc);

var a = 12333;
var b = -12.121;
a ^= b;
b ^= a;
a ^= b;
console.log(a);
console.log(b);

console.log(Array(10).fill(Math.ceil(Math.random() * 10)));

function count(start, end) {
    var time = {};
    console.log(start);
    var t = setInterval(function() {
        if (start < end) {
            start++;
            console.log(start);
        } else {
            time.cancel();
        }
    }, 100);
    time.cancel = function() {
        clearInterval(t);
    }
    return time;
}
//console.log(count(1, 20));

function isNumber(obj) {
    return typeof obj === 'number' && !isNaN(obj)
}

function fizzBuzz(num) {
    var config = {
        'threeAndFive': 'fizzbuzz',
        'three': 'fizz',
        'five': 'buzz',
        'emptyAndIsNaN': false,
        'other': num
    };
    if (num % 3 === 0 && num % 5 === 0) {
        return config.threeAndFive;
    } else if (num % 3 === 0) {
        return config.three;
    } else if (num % 5 === 0) {
        return config.five;
    } else if (num === '' || isNumber(num)) {
        return false;
    } else {
        return num;
    }
}
console.log(fizzBuzz(15));

function argsAsArray(fn, arr) {
    return fn(arr[0], arr[1], arr[2]);
}

function fn(greeting, name, punctuation) {
    return greeting + ', ' + name + (punctuation || '!');
}

var arr = ['Hello', 'Ellie', '!'];

console.log(argsAsArray(fn, arr));

function functionFunction(str1) {
    return f = function(str2) {
        return str1 + ', ' + str2;
    }
}
console.log(functionFunction('Hello')('world'));

function makeClosures(arrays, fns) {
    var result = [];
    arrays.forEach(function(obj) {
        result.push(function() {
            return fns(obj);
        })
    });
    return result;
}

function fns(x) {
    return x * x;
}
arrays = [1, 2, 3];
console.log(makeClosures(arrays, fns));

function useArguments() {
    var sum = 0;
    var length = arguments.length;
    for (var i = 0; i < length; i++) {
        sum += arguments[i];
    }
    return sum;
}
console.log(useArguments(1, 2, 3, 4));

function createModule(str1, str2) {
    var obj = {};
    obj.greeting = str1;
    obj.name = str2;
    obj.sayIt = function() {
        return obj.greeting + ',' + obj.name;
    };
    return obj.sayIt();
}
console.log(createModule('hello', 'world'));

function valueAtBit(num, bit) {
    var a = num.toString(2);
    return a[bit - 1];
}
console.log(valueAtBit(128, 8));

function base10(str) {
    return parseInt(str, 2);
}
console.log(base10('11000000'));

function convertToBinary(num) {
    var a = num.toString(2);
    var strstr = '';
    if (a.length < 8) {
        var zeroArr = Array(8 - a.length).fill(0);
        var strArr = zeroArr.join('');
        strstr = strArr + a;
    } else {
        strstr = a;
    }
    return strstr;
}
console.log(convertToBinary(3));

/**
 *  给定一个构造函数 constructor，请完成 alterObjects 方法，将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量。
 */
function alterObjects(constructor, greeting) {
    constructor.prototype.greeting = greeting;
}
var C = function(name) { this.name = name; return this; };
var obj1 = new C('Rebecca');
alterObjects(C, 'What\'s up');
console.log(obj1.greeting);
/**
 * 给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false
 */
function containsNumber(str) {
    var flag = false;
    str.split('').forEach(function(e) {
        if (e > '0' && e < '9') {
            flag = true;
        }
    });
    return flag;
}
console.log(containsNumber('abcd'));
/**
 * 给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false
 */
function containsRepeatingLetter(str) {
    var length = str.length;
    var flag = false;
    for (var i = 0; i < length - 1; i++) {
        if (str[i] === str[i + 1]) {
            flag = true;
        }
    }
    return flag;
    // return /([a-zA-Z])\1/.test(str);
}
console.log(containsRepeatingLetter('ratlerr'));
/**
 * 给定字符串 str，检查其是否以元音字母结尾
 * 1、元音字母包括 a，e，i，o，u，以及对应的大写
 * 2、包含返回 true，否则返回 false
 */
function endsWithVowel(str) {
    var lastChar = str.charAt(str.length - 1).toLowerCase();
    switch (lastChar) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            return true;
        default:
            return false;

    }
}
console.log(endsWithVowel('uiiipE'));
/**
 * 给定字符串 str，检查其是否符合如下格式
 * 1、XXX-XXX-XXXX
 * 2、其中 X 为 Number 类型
 */
function matchesPattern(str) {
    return (/^\d{3}\-\d{3}\-\d{4}$/).test(str);
}
console.log(matchesPattern('123-456-7890'));
/**
 * 给定字符串 str，检查其是否符合美元书写格式
 * 1、以 $ 开始
 * 2、整数部分，从个位起，满 3 个数字用 , 分隔
 * 3、如果为小数，则小数部分长度为 2
 * 4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3
 */
function isUSD(str) {
    var re = /^\$([1-9]\d{0,2}(,\d{3})*|0)(\.\d{2})?$/;
    return re.test(str);
}
/**
 * 获取 url 中的参数
 * 1. 指定参数名称，返回该参数的值 或者 空字符串
 * 2. 不指定参数名称，返回全部的参数对象 或者 {}
 * 3. 如果存在多个同名参数，则返回数组
 */
function getUrlParam(sUrl, sKey) {
    var valueArr = [];
    var paramArr = sUrl.split('?')[1].split('#')[0].split('&');
    var paramObj = {};
    console.log(paramArr);
    if (sKey) {
        //如果存在多个同名参数，则返回数组
        paramArr.forEach(function(e) {
            if (e.split('=')[0] === sKey) {
                valueArr.push(e.split('=')[1]);
            }
        });
        if (valueArr.length == 1) { //返回该参数的值或者空字符串
            return valueArr[0];
        } else if (valueArr.length == 0) {
            return "";
        } else {
            return valueArr;
        }
    } else {
        //不指定参数名称，返回全部的参数对象 或者 {}
        if (paramArr.length === 1 || paramArr === undefined) {
            return paramObj;
        } else {
            // ["key=1", "key=2", "key=3", "test=4"]
            paramArr.forEach(function(e) {
                var key = e.split('=')[0];
                var value = e.split('=')[1];
                if (paramObj.hasOwnProperty(key)) {
                    paramObj[key].push(value);
                } else {
                    paramObj[key] = [value];
                }
            });
            return paramObj;
        }
    }

}
var url = "http://www.nowcoder.com?key=1&key=2&key=3&test=4#hehe";
var key = "key";
console.dir(getUrlParam(url));
/**
 * 用 JavaScript 实现斐波那契数列函数,返回第n个斐波那契数。 f(1) = 1, f(2) = 1 等
 */
function fibonacci(n) {
    if (n == 1 || n == 2) {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}
console.log(fibonacci(10));
/**
        按所给的时间格式输出指定的时间
        格式说明
        对于 2014.09.05 13:14:20
        yyyy: 年份，2014
        yy: 年份，14
        MM: 月份，补满两位，09
        M: 月份, 9
        dd: 日期，补满两位，05
        d: 日期, 5
        HH: 24制小时，补满两位，13
        H: 24制小时，13
        hh: 12制小时，补满两位，01
        h: 12制小时，1
        mm: 分钟，补满两位，14
        m: 分钟，14
        ss: 秒，补满两位，20
        s: 秒，20
        w: 星期，为 ['日', '一', '二', '三', '四', '五', '六'] 中的某一个，本 demo 结果为 五
 */
function formatDate(oDate, sFormation) {
    var add0 = function(num) {
        if (num < 10)
            return 0 + "" + num;
        else
            return num;

    }
    var o = {
        "yyyy": oDate.getFullYear(),
        "yy": oDate.getFullYear() % 100,
        "MM": add0(oDate.getMonth() + 1),
        "M": oDate.getMonth() + 1,
        "dd": add0(oDate.getDate()),
        "d": oDate.getDate(),
        "HH": add0(oDate.getHours()),
        "H": oDate.getHours(),
        "hh": add0(oDate.getHours() % 12),
        "h": oDate.getHours() % 12,
        "mm": add0(oDate.getMinutes()),
        "m": oDate.getMinutes(),
        "ss": add0(oDate.getSeconds()),
        "s": oDate.getSeconds(),
        "w": function() {
            var day = ["日", "一", "二", "三", "四", "五", "六"];
            return day[oDate.getDay()];
        }(),
    }
    for (var k in o) {
        sFormation = sFormation.replace(k, o[k]);
    }
    return sFormation;
}
console.log(formatDate(new Date((new Date()).valueOf()), 'yyyy-MM-dd HH:mm:ss 星期w'));
/**
    将 rgb 颜色字符串转换为十六进制的形式，如 rgb(255, 255, 255) 转为 #ffffff
    1. rgb 中每个 , 后面的空格数量不固定
    2. 十六进制表达式使用六位小写字母
    3. 如果输入不符合 rgb 格式，返回原始输入
 */
function rgb2hex(sRGB) {
    var result = ['#'];
    if (!/rgb\(\d+(,\s*\d+){2}\)/.test(sRGB)) {
        return sRGB;
    }
    sRGB.replace(/\d+/g, function($0) {
        result.push(('0' + (+$0).toString(16)).slice(-2));
    });
    return result.join('');
}
console.log(rgb2hex('rgb(5, 252, 255)'));
/**
    css 中经常有类似 background-image 这种通过 - 连接的字符，通过 javascript 设置样式的时候需要将这种样式转换成 backgroundImage 驼峰格式，
    请完成此转换功能
    1. 以 - 为分隔符，将第二个起的非空单词首字母转为大写
    2. -webkit-border-image 转换后的结果为 webkitBorderImage
 */
function ucfirst(str) {
    var str = str.toLowerCase();
    var strarr = str.split(' ');
    var result = '';
    for (var i in strarr) {
        result += strarr[i].substring(0, 1).toUpperCase() + strarr[i].substring(1);
    }
    return result;
}

function removeEmpty(arr) {
    var length = arr.length;
    for (var i = 0; i < length; i++) {
        if (arr[i] == '') {
            arr.splice(i, 1);
        }
    }
    return arr;
}

function cssStyle2DomStyle(sName) {
    var strArr = removeEmpty(sName.split('-'));
    var newArr = [];
    strArr.forEach(function(e, index) {
        if (index != 0) {
            newArr.push(ucfirst(e));
        } else {
            newArr.push(e.toLowerCase());
        }

    });
    return newArr.join('');
}
console.log(cssStyle2DomStyle('webkit-border-image'));
/**
    统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率
    1. 不限制 key 的顺序
    2. 输入的字符串参数不会为空
    3. 忽略空白字符
    输入： 'hello world'
    输出： {h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1}
 */
function count(str) {
    var obj = {};
    var newArr = str.replace(/\s+/g, "").split('');
    newArr.forEach(function(e) {
        obj[e] = obj.hasOwnProperty(e) ? obj[e] + 1 : 1;
    });
    return obj;
}
var countStr = 'hello world';
console.log(count(countStr));