JavaScript编程题记录

封装函数 f ，使 f 的 this 指向指定的对象

function bindThis(f,oTarget){ 
    if(f.bind){
        return f.bind(oTarget);
    }else{
        return function(){
            return f.apply(oTarget,arguments);
        }
    }
}

tips:bind返回值是一个函数，而apply是立即执行函数

获取 url 中的参数

1. 指定参数名称，返回该参数的值 或者 空字符串
2. 不指定参数名称，返回全部的参数对象 或者 {}
3. 如果存在多个同名参数，则返回数组

function getUrlParam(sUrl, sKey) {
    var params=sUrl.split('?')[1].split('#')[0];
    if(sKey){
        //指定参数
        var resultArr=[];
        var paramsArr=params.split('&');
        paramsArr.forEach(function(item){
            if(item.split('=')[0]===sKey){
                resultArr.push(item.split('=')[1]);
            }
        });
        if(resultArr.length===1){
            return resultArr[0];
        }else if(resultArr.length===0){
            return "";
        }else{
            return resultArr;
        }
    }else{
        //不指定传参
        var resultObj={}; 
        if(params===undefined){
            return resultObj;
        }
        var paramsArr=params.split('&');
        paramsArr.forEach(function(item){
            if(!(item.split('=')[0] in resultObj)){
                resultObj[item.split('=')[0]]=[];
            }
            resultObj[item.split('=')[0]].push(item.split('=')[1]);       
        });
        return resultObj;
    }
}

查找两个节点的最近的一个共同父节点，可以包括节点自身

function commonParentNode(oNode1, oNode2) {
    for(;;oNode1=oNode1.parentNode){
        if(oNode1.contains(oNode2)){
            return oNode1;
        }
    }
}

根据包名，在指定空间中创建对象

function namespace(oNamespace,sPackage){
    var arr=sPackage.split('.');
    var origin=oNamespace;
    arr.forEach(function(item){
        if(item in oNamespace){
            if(typeof oNamespace[item]!=='object'){
                oNamespace[item]={};
            }
        }else{
            oNamespace[item]={};
        }
        oNamespace=oNamespace[item];
    });
    return origin;
}

为 Array 对象添加一个去除重复项的方法

Array.prototype.uniq=function(){
    var uniqArr=[];
    var NaNPushed=false;
    this.forEach(function(item){
        if(uniqArr.indexOf(item)===-1){
            //NaN!=NaN
            if(item!=item){
                if(!NaNPushed){
                    uniqArr.push(item);
                    NaNPushed=true;
                }
            }else{
                uniqArr.push(item);
            }
        }
    });
    return uniqArr;
}

实现斐波那契数列函数,返回第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);
    }
}

按所给的时间格式输出指定的时间

格式说明
对于 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: 星期，为 ['日', '一', '二', '三', '四', '五', '六'] 中的某一个

function formatDate(DateObj,formatStr){
    var formatObj={
        yyyy:DateObj.getFullYear(),
        yy:(''+DateObj.getFullYear()).slice(-2),
        MM:('0'+(DateObj.getMonth()+1)).slice(-2),
        M:DateObj.getMonth()+1,
        dd:('0'+DateObj.getDate()).slice(-2),
        d:DateObj.getDate(),
        HH:('0'+DateObj.getHours()).slice(-2),
        H:DateObj.getHours(),
        hh:('0'+DateObj.getHours()%12).slice(-2),
        h:DateObj.getHours()%12,
        mm:('0'+DateObj.getMinutes()).slice(-2),
        m:DateObj.getMinutes(),
        ss:('0'+DateObj.getSeconds()).slice(-2),
        s:DateObj.getSeconds(),
        w:['日','一','二','三','四','五','六'][DateObj.getDay()]
    };
    return formatStr.replace(/([a-z]+)/ig,function(key){
        return formatObj[key];
    });
}

如果第二个参数 bUnicode255For1 === true，则所有字符长度为 1，否则如果字符 Unicode 编码 > 255 则长度为 2

function strLength(str,bUnicode255For1){
    if(bUnicode255For1){
        return str.length;
    }else {
        var len=str.length;
        for(var i=0;i<str.length;i++){
            if(str.charCodeAt(i)>255){
                len++;
            }
        }
        return len;
    }
}

判断输入是否是正确的邮箱格式

function isAvailableEmail(sEmail){
    var checkReg=/^(\w+)(\.\w+)*@(\w+)(\.\w+)*.(\w+)$/i;
    return checkReg.test(sEmail);
}

将 rgb 颜色字符串转换为十六进制的形式，如 rgb(255, 255, 255) 转为 #ffffff

1. rgb 中每个 , 后面的空格数量不固定
2. 十六进制表达式使用六位小写字母
3. 如果输入不符合 rgb 格式，返回原始输入

function rgb2hex(sRGB) {
    return sRGB.replace(/^rgb\((\d+)\s*,\s*(\d+)\s*,\s*(\d+)\)$/,function(allMatch,rMatch,gMatch,bMatch){
         return '#'+toHex(rMatch)+toHex(gMatch)+toHex(bMatch);
    });
    function toHex(matchItem){
        return ('0'+(+matchItem).toString(16)).slice(-2);
    }
}

将字符串转换为驼峰格式

1. 以 - 为分隔符，将第二个起的非空单词首字母转为大写
2. -webkit-border-image 转换后的结果为 webkitBorderImage

function cssStyle2DomStyle(sName) {
    var str=sName.split('-');
    if(str[0]==''){
        str.splice(0,1);
    }
    for(var i=1;i<str.length;i++){
        str[i]=str[i][0].toUpperCase()+str[i].slice(1);
    }
    return str.join('');
}

统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率

1. 不限制 key 的顺序
2. 输入的字符串参数不会为空
3. 忽略空白字符

function count(str) {
    str.replace(/\s/g,'');
    var countObj={};
    for(var i=0;i<str.length;i++){
        if(!countObj[str[i]]){
            countObj[str[i]]=1;
        }else{
            countObj[str[i]]++;
        }
    }
    return countObj;
}

计算给定数组 arr 中所有元素的总和，数组中的元素均为 Number 类型

function sum(arr) {
    var sum=0;
    arr.forEach(function(item){
        sum+=item;
    });
    return sum;
}

移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组

function remove(arr, item) {
    var newArr=[];
    arr.forEach(function(e){
        if(item!=e){
            newArr.push(e);
        }
    });
    return newArr;
}

移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回

//解法一
function removeWithoutCopy(arr,item){
    for(var i=0;i<arr.length;i++){
        if(item==arr[i]){
            arr.splice(i,1);
            i--;
        }
    }
    return arr;
}
//解法二
function removeWithoutCopy(arr,item){
    var len=arr.length;
    for(var i=0;i<len;i++){
        if(arr[0]!==item){
            //插尾
            arr.push(arr[0]);
        }
        //去头
        arr.shift();
    }
    return arr;
}

在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组

//解法一
function append(arr, item) {
    return arr.concat([item]);
}
//解法二
function prepend(arr, item) {
    return [...arr,item];
}

删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组

function truncate(arr) {
    return arr.slice(0,-1);
}

在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组

//解法一
function prepend(arr, item) {
    return [item].concat(arr);
}
//解法二
function prepend(arr, item) {
    return [item,...arr];
}

删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组

function curtail(arr) {
    return arr.slice(1);
}

合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组

function concat(arr1, arr2) {
    return arr1.concat(arr2);
}

在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组

function insert(arr, item, index) {
    var newArr=arr.slice(0);
    newArr.splice(index,0,item);
    return newArr;
}

统计数组 arr 中值等于 item 的元素出现的次数

function count(arr, item) {
    var count=0;
    arr.forEach(function(e){
        if(e===item){
            count++;
        }
    });
    return count;
}

找出数组 arr 中重复出现过的元素

function duplicates(arr) {
    var resultArr=[];
    arr.forEach(function(item){
        if(arr.indexOf(item)!=arr.lastIndexOf(item)&&resultArr.indexOf(item)==-1){
            resultArr.push(item);
        }
    });
    return resultArr;
}

为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组

function square(arr) {
    var resultArr=[];
    arr.forEach(function(item){
        resultArr.push(item*item);
    });
    return resultArr;
}

在数组 arr 中，查找值与 item 相等的元素出现的所有位置

function findAllOccurrences(arr, target) {
    var resultArr=[];
    arr.forEach(function(item,index){
        if(item===target){
            resultArr.push(index);
        }
    });
    return resultArr;
}

给定的 js 代码中存在全局变量，请修复

//示例代码
function globals() {
    myObject = {
      name : 'Jory'
    };

    return myObject;
}

function globals() {
    var myObject = {
      name : 'Jory'
    };

    return myObject;
}

请修复给定的 js 代码中，函数定义存在的问题

//示例代码
function functions(flag) {
    if (flag) {
      function getValue() { return 'a'; }
    } else {
      function getValue() { return 'b'; }
    }
    return getValue();
}

function functions(flag) {
    if (flag) {
      var getValue=function() { return 'a'; };
    } else {
      var getValue=function() { return 'b'; };
    }

    return getValue();
}

修改 js 代码中 parseInt 的调用方式，使之通过全部测试用例，'12'->12、'12px'->12、 '0x12'->0

//示例代码
function parse2Int(num) {
    return parseInt(num);
}

function parse2Int(num) {
    return parseInt(num,10);
}

实现一个打点计时器，要求

1. 从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2. 返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3. 第一个数需要立即输出

function count(start, end) {
    console.log(start);
    var timer=setInterval(function(){
        var nextTic=++start;
        console.log(nextTic);
        if(nextTic>=end){
            clearTimeout(timer);
        }
    },100);
    return {
        cancel:function(){
            clearInterval(timer);
        }
    }
}

实现 fizzBuzz 函数，参数 num 与返回值的关系如下：

1. 如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
2. 如果 num 能被 3 整除，返回字符串 fizz
3. 如果 num 能被 5 整除，返回字符串 buzz
4. 如果参数为空或者不是 Number 类型，返回 false
5. 其余情况，返回参数 num

function fizzBuzz(num) {
    if(num%5==0&&num%3==0){
        return 'fizzbuzz';
    }else if(num%3==0){
        return 'fizz';
    }else if(num%5==0){
        return 'buzz';
    }else if(num==undefined||typeof num!='number'){
        return false;
    }else{
        return num;
    }
}

将数组 arr 中的元素作为调用函数 fn 的参数

输入：function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']
输出：Hello, Ellie!

//解法一
function argsAsArray(fn, arr) {
    return fn.apply(null,arr);
}
//解法二
function argsAsArray(fn, arr) {
    return fn(...arr);
}

将函数 fn 的执行上下文改为 obj 对象

输入：function () {return this.greeting + ', ' + this.name + '!!!';}, {greeting: 'Hello', name: 'Rebecca'}
输出：Hello, Rebecca!!!

function speak(fn, obj) {
    return fn.apply(obj,arguments);
}

实现函数 functionFunction，调用之后满足如下条件：

1. 返回值为一个函数 f
2. 调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', '
3. 所有函数的参数数量为 1，且均为 String 类型

输入：functionFunction('Hello')('world')
输出：Hello, world

function functionFunction(str) {
    return function(innerStr){
        return str+', '+innerStr;
    }
}

实现函数 makeClosures，调用之后满足如下条件：

1. 返回一个函数数组 result，长度与 arr 相同
2. 运行 result 中第 i 个函数，即 resulti，结果与 fn(arr[i]) 相同

输入：[1, 2, 3], function (x) { return x * x; }
输出：4

//解法一
function makeClosures(arr, fn) {
    var result=[];
    arr.forEach(function(item,index){
        result[index]=function(){
            return fn(item);
        } 
    });
    return result;
}
//解法二
function makeClosures(arr, fn) {   
    var result = new Array();
    for(let i=0;i<arr.length;i++){
        result[i] = function(){
            return fn(arr[i]);           
        };
    }
    return result;
}
//错误解法
function makeClosures(arr, fn) {   
    var result = new Array();
    for(var i=0;i<arr.length;i++){
        result[i] = function(){
            return fn(arr[i]);           
        };
    }
    return result;
}

已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：

1. 返回一个函数 result，该函数接受一个参数
2. 执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致

输入：var sayIt = function(greeting, name, punctuation) { return greeting + ', ' + name + (punctuation || '!'); }; partial(sayIt, 'Hello', 'Ellie')('!!!');
输出：Hello, Ellie!!!

function partial(fn, str1, str2) {
    return result=function(str3){
        return fn(str1,str2,str3);
    }
}

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换

function useArguments() {
    var sum=0;
    for(key in arguments){
        sum+=arguments[key];
    }
    return sum;
}

实现函数 callIt，调用之后满足如下条件

1. 返回的结果为调用 fn 之后的结果
2. fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {
    var args=Array.prototype.slice.call(arguments,1);
    return fn.apply(null,args);
}

实现函数 partialUsingArguments，调用之后满足如下条件：

1. 返回一个函数 result
2. 调用 result 之后，返回的结果与调用函数 fn 的结果一致
3. fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
    var args=Array.prototype.slice.call(arguments,1);
    return result=function(){
        return fn.apply(null,args.concat(Array.prototype.slice.call(arguments,0)));
    }
}

已知 fn 为一个预定义函数，实现函数 curryIt，调用之后满足如下条件：

1. 返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）
2. 调用 a 之后，返回一个函数 b, b 的 length 属性值为 1
3. 调用 b 之后，返回一个函数 c, c 的 length 属性值为 1
4. 调用 c 之后，返回的结果与调用 fn 的返回值一致
5. fn 的参数依次为函数 a, b, c 的调用参数uj

输入：var fn = function (a, b, c) {return a + b + c}; curryIt(fn)(1)(2)(3);
输出：6

function curryIt(fn) {
    return a=function(arg1){
        return b=function(arg2){
            return c=function(arg3){
                return fn(arg1,arg2,arg3);
            }
        }
    }
}

完成函数 createModule，调用之后满足如下要求：

1. 返回一个对象
2. 对象的 greeting 属性值等于 str1， name 属性值等于 str2
3. 对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ' + name属性值

function createModule(str1, str2) {
    return {
        greeting:str1,
        name:str2,
        sayIt:function(){
            return this.greeting+', '+this.name;
        }
    }
}

获取数字 num 二进制形式第 bit 位的值。注意：

1. bit 从 1 开始
2. 返回 0 或 1
3. 举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

//解法一
function valueAtBit(num, bit) {
    var s=num.toString(2);
    return s[s.length-bit];
}
//解法二
function valueAtBit(num, bit) {
    return (num >> (bit -1)) & 1;
}

给定二进制字符串，将其换算成对应的十进制数字

function base10(str) {
    return parseInt(str,2);
}

将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位

function convertToBinary(num) {
    var str=num.toString(2);
    while(str.length<8){
        str='0'+str;
    }
    return str;
}

给定一个构造函数 constructor，请完成 alterObjects 方法，将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量

输入：var C = function(name) {this.name = name; return this;}; var obj1 = new C('Rebecca'); alterObjects(C, 'What\'s up'); obj1.greeting;
输出：What's up

function alterObjects(constructor, greeting) {
    return constructor.prototype.greeting=greeting;
}

找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)

1. 返回数组，格式为 key: value
2. 结果数组不要求顺序

输入：var C = function() {this.foo = 'bar'; this.baz = 'bim';}; C.prototype.bop = 'bip';iterate(new C());
输出：["foo: bar", "baz: bim"]

function iterate(obj) {
    var resultArr=[];
    for(key in obj){
        if(obj.hasOwnProperty(key)){
            resultArr.push(key+': '+obj[key]);
        }
    }
    return resultArr;
}

给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false

function containsNumber(str) {
    return /[0-9]/.test(str);
}

给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false

function containsRepeatingLetter(str) {
    return /([a-zA-Z])\1/.test(str);
}

给定字符串 str，检查其是否以元音字母结尾

1. 元音字母包括 a，e，i，o，u，以及对应的大写
2. 包含返回 true，否则返回 false

function endsWithVowel(str) {
    return /[a,e,i,o,u,A,E,I,O,U]$/.test(str);
}

给定字符串 str，检查其是否包含 连续3个数字

1. 如果包含，返回最新出现的 3 个数字的字符串
2. 如果不包含，返回 false

function captureThreeNumbers(str) {
    var res=str.match(/\d{3}/);
    if(res){
        return res[0];
    }else{
        return false;
    }
}

给定字符串 str，检查其是否符合如下格式

1. XXX-XXX-XXXX
2. 其中 X 为 Number 类型

function matchesPattern(str) {
    return /^(\d{3}-){2}\d{4}$/.test(str);
}

给定字符串 str，检查其是否符合美元书写格式

1. 以 $ 开始
2. 整数部分，从个位起，满 3 个数字用 , 分隔
3. 如果为小数，则小数部分长度为 2
4. 正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3

function isUSD(str) {
    return /^\$\d{1,3}(,\d{3})*(\.\d{2})?$/.test(str);
}