封装函数 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 中的参数
- 指定参数名称，返回该参数的值 或者 空字符串
- 不指定参数名称，返回全部的参数对象 或者 {}
- 如果存在多个同名参数，则返回数组
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;i255){
len++;
}
}
return len;
}
}
判断输入是否是正确的邮箱格式
function isAvailableEmail(sEmail){
var checkReg=/^(\w+)(\.\w+)*@(\w+)(\.\w+)*.(\w+)$/i;
return checkReg.test(sEmail);
}
将 rgb 颜色字符串转换为十六进制的形式，如 rgb(255, 255, 255) 转为 #ffffff
- rgb 中每个 , 后面的空格数量不固定
- 十六进制表达式使用六位小写字母
- 如果输入不符合 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);
}
}
将字符串转换为驼峰格式
- 以 - 为分隔符，将第二个起的非空单词首字母转为大写
- -webkit-border-image 转换后的结果为 webkitBorderImage
function cssStyle2DomStyle(sName) {
var str=sName.split('-');
if(str[0]==''){
str.splice(0,1);
}
for(var i=1;i统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率
- 不限制 key 的顺序
- 输入的字符串参数不会为空
- 忽略空白字符
function count(str) {
str.replace(/\s/g,'');
var countObj={};
for(var i=0;i计算给定数组 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 末尾添加元素 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);
}
实现一个打点计时器，要求
- 从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
- 返回的对象中需要包含一个 cancel 方法，用于停止定时操作
- 第一个数需要立即输出
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 与返回值的关系如下：
- 如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
- 如果 num 能被 3 整除，返回字符串 fizz
- 如果 num 能被 5 整除，返回字符串 buzz
- 如果参数为空或者不是 Number 类型，返回 false
- 其余情况，返回参数 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，调用之后满足如下条件：
- 返回值为一个函数 f
- 调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', '
- 所有函数的参数数量为 1，且均为 String 类型
输入：functionFunction('Hello')('world')
输出：Hello, world
function functionFunction(str) {
return function(innerStr){
return str+', '+innerStr;
}
}
实现函数 makeClosures，调用之后满足如下条件：
- 返回一个函数数组 result，长度与 arr 相同
- 运行 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已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
- 返回一个函数 result，该函数接受一个参数
- 执行 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，调用之后满足如下条件
- 返回的结果为调用 fn 之后的结果
- fn 的调用参数为 callIt 的第一个参数之后的全部参数
function callIt(fn) {
var args=Array.prototype.slice.call(arguments,1);
return fn.apply(null,args);
}
实现函数 partialUsingArguments，调用之后满足如下条件：
- 返回一个函数 result
- 调用 result 之后，返回的结果与调用函数 fn 的结果一致
- 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，调用之后满足如下条件：
- 返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）
- 调用 a 之后，返回一个函数 b, b 的 length 属性值为 1
- 调用 b 之后，返回一个函数 c, c 的 length 属性值为 1
- 调用 c 之后，返回的结果与调用 fn 的返回值一致
- 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，调用之后满足如下要求：
- 返回一个对象
- 对象的 greeting 属性值等于 str1， name 属性值等于 str2
- 对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ' + name属性值
function createModule(str1, str2) {
return {
greeting:str1,
name:str2,
sayIt:function(){
return this.greeting+', '+this.name;
}
}
}
获取数字 num 二进制形式第 bit 位的值。注意：
- bit 从 1 开始
- 返回 0 或 1
- 举例：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 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
- 返回数组，格式为 key: value
- 结果数组不要求顺序
输入：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，检查其是否以元音字母结尾
- 元音字母包括 a，e，i，o，u，以及对应的大写
- 包含返回 true，否则返回 false
function endsWithVowel(str) {
return /[a,e,i,o,u,A,E,I,O,U]$/.test(str);
}
给定字符串 str，检查其是否包含 连续3个数字
- 如果包含，返回最新出现的 3 个数字的字符串
- 如果不包含，返回 false
function captureThreeNumbers(str) {
var res=str.match(/\d{3}/);
if(res){
return res[0];
}else{
return false;
}
}
给定字符串 str，检查其是否符合如下格式
- XXX-XXX-XXXX
- 其中 X 为 Number 类型
function matchesPattern(str) {
return /^(\d{3}-){2}\d{4}$/.test(str);
}
给定字符串 str，检查其是否符合美元书写格式
- 以 $ 开始
- 整数部分，从个位起，满 3 个数字用 , 分隔
- 如果为小数，则小数部分长度为 2
- 正确的格式如：$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);
}