前端试题本（Javascript篇）

JS1. 下面这个JS程序的输出是什么：
JS2.下面的JS程序输出是什么：
JS3.页面有一个按钮button id为 button1，通过原生的js如何禁用？
JS4.页面有一个按钮button id为 button1，通过原生的js 设置背景色为红色？
JS5.处理a.html文件时，以下哪行伪代码可能导致内存越界或者抛出异常（）
JS6.下面的代码结果是
JS7.下面的代码结果是
JS8.考察this(测试环境是浏览器，Node环境中全局对象有所不同)
JS9、var和函数的声明提前
JS10.给基本类型数据添加属性，不报错，但取值时是undefined
JS11、判断一个字符串中出现次数最多的字符，并统计次数
JS12.经典闭包-实现一段脚本，使得点击对应链接alert出相应的编号
JS13.事件处理程序中的this
JS14.请编写一个JavaScript函数 parseQueryString，它的用途是把URL参数解析为一个对象，如： var url =“http://witmax.cn/index.php?key0=0&key1=1&key2=2″
JS15、下面两个函数的返回值是一样的吗？为什么？
JS16、下面的代码会输出什么？为什么？
JS17、解释下面代码的输出
JS18、给你一个 DOM 元素，创建一个能访问该元素所有子元素的函数，并且要将每个子元素传递给指定的回调函数。
JS19下面表达式的结果是：
JS20下列表达式的值
JS21下列表达式的值
JS22.写出下面的输出结果
JS23.Javascript作用链域?
JS24.new操作符具体干了什么呢?
JS25.用js实现千位分隔符?(来源：前端农民工，提示：正则+replace)
JS26.编写一个JavaScript函数，输入指定类型的选择器(仅需支持id，class，tagName三种简单CSS选择器，无需兼容组合选择器)可以返回匹配的DOM节点，需考虑浏览器兼容性和性能。
JS27.实现一个函数clone，可以对JavaScript中的5种主要的数据类型（包括Number、String、Object、Array、Boolean）进行值复制。
JS28.请评价以下代码并给出改进意见
JS29.直接在对象的原型上添加方法是否安全？尤其是在Object对象上。
JS30..在Javascript中什么是伪数组？如何将伪数组转化为标准数组？
JS31.对作用域上下文和this的理解，看下列代码：
JS32.原生JS的window.onload与Jquery的$(document).ready(function(){})有什么不同？如何用原生JS实现Jq的ready方法？
JS32.（设计题）想实现一个对页面某个节点的拖曳？如何做？（使用原生JS）
JS33.说出以下函数的作用是？空白区域应该填写什么？
JS34.看下面的代码？问a怎么变，匿名函数里的this是什么？怎么改变里面的this？匿名函数不能传参怎么改变obj.a的值？
JS35.移除数组中的元素
JS36.进制转换
JS37.关于console.log的小题

JS1. 下面这个JS程序的输出是什么：

function Foo() { 
  var i = 0; 
  return function() { 
    console.log(i++); 
  } 
}
var f1 = Foo(), 
f2 = Foo(); 
f1(); 
f1(); 
f2();

解析：输出为：0,1,0 Foo函数返回一个匿名函数，这个匿名函数对Foo的内部变量 i 存在引用，所以只要指向匿名函数的变量不释放（如 f1），i 的值就一直存在。故每次执行 f1() 都会增加 i 的值。而 f1，f2 指向的是两个不同闭包，所以两者执行时互不影响。

JS2.下面的JS程序输出是什么：

(function() { 
var a = b = 5; 
})(); 
console.log(b); 
console.log(a);

上面的输出结果是：5，undefined 注意连续赋值，b实际上是全局变量,如果启用了严格模式，代码就会引发ReferenceError的错误：B没有定义（b is not defined）。请记住，严格模式，则需要明确指定，才能实现全局变量声明。比如，你应该写：

(function() {
    'use strict';
     var a = window.b = 5;
  })();
 console.log(b);

JS3.页面有一个按钮button id为 button1，通过原生的js如何禁用？

A. document.getElementById("button1").readolny= true;

B. document.getElementById("button1").setAttribute(“readolny”,”true”);

C. document.getElementById("button1").disabled = true;

D. document.getElementById("button1").setAttribute(“disabled”,”true”);

解析：这题的标准答案是C,毋庸置疑，答案D虽然也能达到预期的效果，但是实际上不管第二个参数为什么值都会值都会使按钮处于禁用状态，及时设置成布尔型的false.所以这个答案存在异议，不算是标准答案

JS4.页面有一个按钮button id为 button1，通过原生的js 设置背景色为红色？

A.document.getElementById('button1').style.backgroundColor="red";

B.document.getElementById('button1').style.backgroundcolor="red";

C.document.getElementById('button1').style.backGroundColor="red";

D.document.getElementById('button1').style.bgcolor="red";

解析：正确答案是A，js里样式设置直接把css写法的的“-”去掉，再改写为驼峰写法即可。

JS5.处理a.html文件时，以下哪行伪代码可能导致内存越界或者抛出异常（）

         int totalBlank = 0;
         int blankNum = 0;
         int taglen = page.taglst.size();
A       for(int i = 1; i < taglen-1; ++i)
        {
                 //check blank
B             while(page.taglst[i] == "<br>" && i < taglen)
               {
C                       ++totalBlank;
D                       ++i;
               }
E             if(totalBlank > 10)
F                      blankNum += totalBlank;
G             totalBlank = 0;
        }

注意：以下代码中taglen是html文件中存在元素的个数，a.html中taglen的值是15，page.taglst[i]取的是a.html中的元素，例如page.taglst[1]的值是

a.html的文件如下：

<!--这里有一个空行-->
<html>
<title>test</title>
<body>
<div>aaaaaaa</div>
</body>
</html>
<br>
<br>
<br>
<br>
<br>

答案为B，因为while(page.taglst[i] == "<br>" && i < taglen)这个判断，先执行page.taglst[i] == "<br>"这个判断，如果这个判断返回值为true，再执行i < taglen这个判断。当i=taglen的时候，执行page.taglst[i] == "<br>"这个判断就会越界，所以B处，最先出现越界

JS6.下面的代码结果是

var f = function g(){ return 23; };
typeof g();

答案：会发生错误ReferenceError: g is not defined

因为function g(){ return 23; }是函数表达式,事实上只有事一个名字,不是一个函数声明,函数实际上是绑定到变量f，不是g。

JS7.下面的代码结果是

var x = 1;
if (function f(){} ){
    x += typeof f;
}
console.log(x);//1undefined

这里有个难点，if 中的 function f(){} 要如何处理？函数声明的实际规则如下：函数声明只能出现在程序或函数体内。从句法上讲，它们不能出现在Block（块）（{ … }）中，例如不能出现在 if、while 或 for 语句中。因为 Block（块）中只能包含Statement语句，而不能包含函数声明这样的源元素。另一方面，仔细看一看规则也会发现，唯一可能让表达式出现在Block（块）中情形，就是让它作为表达式语句的一部分。但是，规范明确规定了表达式语句不能以关键字function开头。而这实际上就是说，函数表达式同样也不能出现在Statement语句或Block（块）中（因为Block（块）就是由Statement语句构成的）。关于这题的结果的内在原理并不是很懂，仿佛if语句不存在直接执行了里面的语句，又或者因为无法解释就把括号内的一坨直接当成了字符串为真，f还是没有定义。

JS8.考察this(测试环境是浏览器，Node环境中全局对象有所不同)

var length = 10;
function fn() {
  console.log(this.length);
}

var obj = {
  length: 5,
  method: function(fn) {
    fn();
    arguments[0]();
  }
};

obj.method(fn, 1);

正确结果是输出：10 2

解析：牢记->JavaScript中函数调用一共有四种方式：方法调用模式、函数调用模式、构造器调用模式、apply/call调用模式.第一次调用fn()时是普通函数调用模式this指向全局window。我们知道取对象属于除了点操作符还可以用中括号，所以第二次执行时相当于arguments调用方法，this指向arguments，而这里传了两个参数，故输出arguments长度为2。

JS9、var和函数的声明提前

function fn(a) {
  console.log(a); 
  ①var a = 2;
  ②function a() {}
  console.log(a); 
}
fn(1);

输出：function a() {} 2 //chrome测试

我们知道var和function是会提前声明的，而且函数声明是优先于var声明的（如果同时存在的话），这里的优于可以理解为晚于变量声明后(先提升变量再紧跟着函数声明，函数声明提升相当于整个函数块包括代码一起移动到前面了)，如果函数名和变量名相同，函数声明就能覆盖变量声明，所以提前声明后输出的a是个function，然后代码往下执行a进行重新赋值了，故第二次输出是2。即使把第一句和第二句交换一下输出结果不变

JS10.给基本类型数据添加属性，不报错，但取值时是undefined

var a = 10;
a.pro = 10;
console.log(a.pro + a);
var s = 'hello';
s.pro = 'world';
console.log(s.pro + s);

答案：NaN undefinedhello

解析：给基本类型数据加属性不报错，但是引用的话返undefined，undefined+10返回NaN，这里运用的规则是：对于加性操作符，如果一个操作数是树值，另一个操作数是undefined、null、布尔值时，则先调用Number()将非树值转换成数值，undefined会转化成NaN,null转换成0，布尔值转化成1或者0.而undefined和字符串相加时转变成了字符串，所以结果是undefiendhello

JS11、判断一个字符串中出现次数最多的字符，并统计次数

hash table方式：

var s = 'aaabbbcccaaabbbaaa';
var obj = {};
var maxn = -1;
var letter;
for(var i = 0; i < s.length; i++) {
  if(obj[s[i]]) {
    obj[s[i]]++;
    if(obj[s[i]] > maxn) {
      maxn = obj[s[i]];
      letter = s[i];
    }
  } else {
    obj[s[i]] = 1;
    if(obj[s[i]] > maxn) {
      maxn = obj[s[i]];
      letter = s[i];
    }
  }
}
alert(letter + ': ' + maxn);

正则方式：

var s = 'aaabbbcccaaabbbaaabbbbbbbbbb';
var a = s.split('');
a.sort();
s = a.join('');
var pattern = /(\w)\1*/g;
var ans = s.match(pattern);
ans.sort(function(a, b) {
  return a.length < b.length;});;
console.log(ans[0][0] + ': ' + ans[0].length);

JS12.经典闭包-实现一段脚本，使得点击对应链接alert出相应的编号

dom污染法：

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<body>
  <a href='#'> 第一个链接 </a> </br>
  <a href='#'> 第二个链接 </a> </br>
  <a href='#'> 第三个链接 </a> </br>
  <a href='#'> 第四个链接 </a> </br>
  <script type="text/javascript">
    var lis = document.links;
    for(var i = 0, length = lis.length; i < length; i++) {
      lis[i].index = i+1;
      lis[i].onclick = function() {
        alert(this.index);
      };
    }
  </script>
</body>

闭包：

meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<body>
  <a href='#'> 第一个链接 </a> </br>
  <a href='#'> 第二个链接 </a> </br>
  <a href='#'> 第三个链接 </a> </br>
  <a href='#'> 第四个链接 </a> </br>
  <script type="text/javascript">
    var lis = document.links;
    for(var i = 0, length = lis.length; i < length; i++) {
      (function(i) {
        lis[i].onclick = function() {
          alert(i + 1);
        };
      })(i); 
    }
  </script>
</body>

JS13.事件处理程序中的this

function JSClass() {
  this.m_Text = 'division element';
  this.m_Element = document.createElement('div');
  this.m_Element.innerHTML = this.m_Text;
  this.m_Element.addEventListener('click', this.func);
  // this.m_Element.onclick = this.func;
}
JSClass.prototype.Render = function() {
    document.body.appendChild(this.m_Element);
}
JSClass.prototype.func = function() {
  alert(this.m_Text);
};
var jc = new JSClass();
jc.Render();  // add div
jc.func();  // 输出 division element

click添加的div元素division element会输出underfined，为什么？

答案：division element undefined

解析：第一次输出很好理解，func()作为对象的方法调用，所以输出division element，点击添加的元素时，this其实已经指向this.m_Element，也就是事件的目标元素（事件对象的currentTarget属性值-或者说是注册事件处理程序的元素），因为是this.m_Element调用的addEventListener函数，所以内部的this全指向它了，而这个元素并没有m_Text属性，所以输出undefined。

JS14.请编写一个JavaScript函数 parseQueryString，它的用途是把URL参数解析为一个对象，如： var url =“http://witmax.cn/index.php?key0=0&key1=1&key2=2″

 function parseQueryString(url) {
   var obj = {};
   var a = url.split('?');
   if(a.length === 1) return obj;
   var b = a[1].split('&');
   for(var i = 0, length = b.length; i < length; i++) {
     var c = b[i].split('=');
     obj[c[0]] = c[1];
   }
   return obj;
}
 ```
 下面给出一个实际常用的更严谨的写法（来自JavaScript高级程序设计）：
 ```javascript
 function getQueryStringArgs() {
    //取得查询字符串并去掉开头的问号（这里使用了BOM中的location对象）
    var qs=(location.search.length>0?location.search.substring(1):""),
    //保存数据的对象
    args={},
    //取得每一项
    items=qs.length?qs.split('&'):[],
    item=null,
    name=null,
    value=null,
    i=0,
    len=items.length;
    for (i = 0; i <len; i++) {
        item=items[i].split("=");
        name=decodeURIComponent(item[0]);
        value=decodeURIComponent(item[1]);
        if (name.length) {
            args[name]=value;
        }
    }
    return args;
}

还可以借助正则表达式

function getQueryObject(url) {
    url = url == null ? window.location.href : url;
    var search = url.substring(url.lastIndexOf("?") + 1);
    var obj = {};
    var reg = /([^?&=]+)=([^?&=]*)/g;
    search.replace(reg, function (rs, $1, $2) {
        var name = decodeURIComponent($1);
        var val = decodeURIComponent($2);                
        val = String(val);
        obj[name] = val;
        return rs;
    });
    return obj;
}

JS15、下面两个函数的返回值是一样的吗？为什么？

function foo1()
{
  return {
      bar: "hello"
  };
}

function foo2()
{
  return
  {
      bar: "hello"
  };
}

在编程语言中，基本都是使用分号（;）将语句分隔开，这可以增加代码的可读性和整洁性。而在JS中，如若语句各占独立一行，通常可以省略语句间的分号（;），JS 解析器会根据能否正常编译来决定是否自动填充分号：

var test = 1 + 
2
console.log(test);  //3

在上述情况下，为了正确解析代码，就不会自动填充分号了，但是对于 return 、break、continue 等语句，如果后面紧跟换行，解析器一定会自动在后面填充分号(;)，所以上面的第二个函数就变成了这样：

function foo2()
{
  return;
  {
      bar: "hello"
  };
}

所以第二个函数是返回 undefined。

JS16、下面的代码会输出什么？为什么？

var arr1 = "john".split('');
var arr2 = arr1.reverse(); 
var arr3 = "jones".split(''); 
arr2.push(arr3);
console.log("array 1: length=" + arr1.length + " last=" + arr1.slice(-1));
console.log("array 2: length=" + arr2.length + " last=" + arr2.slice(-1));

答案是array 1: length=5 last=j,o,n,e,s

array 2: length=5 last=j,o,n,e,s

解析：

数组的reverse方法会将原数组反转后返回，arr1指向反转后的数组

JS中当从一个变量向另一个变量复制引用类型的值时，会将存储在变量对象中的值复制一份放到为新变量分配的空间中。不同的是，这个值的副本实际上是一个指针，而这个指针指向存储在堆中的一个对象。复制操作结束后，两个变量实际上将引用同一个对象。因此，改变其中一个变量，就会影响另一个变量，如下图所示：

所以arr2和arr1实际上引用的是同一个对象。

JS17、解释下面代码的输出

var a={},
    b={key:'b'},
    c={key:'c'};
a[b]=123;
a[c]=456;
console.log(a[b]);

输出是 456，参考原文的解释：

javascript中给对象添加和访问属性时会隐式的把属性名转换成字符串，因为b和c都是都是对象，转换成字符串都是[object Object]，因此两次实际上是设置了同一属性a[[object Object]]

JS18、给你一个 DOM 元素，创建一个能访问该元素所有子元素的函数，并且要将每个子元素传递给指定的回调函数。

函数接受两个参数：

DOM
指定的回调函数

原文利用深度优先搜索(Depth-First-Search) 给了一个实现：

function Traverse(p_element,p_callback) {
   p_callback(p_element);
   var list = p_element.children;
   for (var i = 0; i < list.length; i++) {
       Traverse(list[i],p_callback);  // recursive call
   }
}

JS19下面表达式的结果是：

[1 < 2 < 3, 3 < 2 < 1]

这个题会让人误以为是 2 > 1 && 2 < 3 其实不是的.

这个解题思路是

 1 < 2 => true;
 true < 3 =>  1 < 3 => true;
 3 < 2 => false;
 false < 1 => 0 < 1 => true;

答案是 [true, true]

JS20下列表达式的值

var lowerCaseOnly =  /^[a-z]+$/;
console.log([lowerCaseOnly.test(null), lowerCaseOnly.test()])

执行时会使用toString方法将参数转化成字符串“null”,"undefined"，因此都返回true

JS21下列表达式的值

function captureOne(re, str) {
  var match = re.exec(str);
  return match && match[1];
}
var numRe  = /num=(\d+)/ig,
    wordRe = /word=(\w+)/i,
    a1 = captureOne(numRe,  "num=1"),
    a2 = captureOne(wordRe, "word=1"),
    a3 = captureOne(numRe,  "NUM=2"),
    a4 = captureOne(wordRe,  "WORD=2");
[a1 === a2, a3 === a4]

因为第一个正则有一个 g 选项它会‘记忆’他所匹配的内容, 等匹配后他会从上次匹配的索引继续, 而第二个正则不会，所以 a1 = '1'; a2 = '1'; a3 = null; a4 = '2'

JS22.写出下面的输出结果

function Foo() {
    getName = function () { alert (1); };
    return this;
}
Foo.getName = function () { alert (2);};
Foo.prototype.getName = function () { alert (3);};
var getName = function () { alert (4);};//声明提升，但是赋值却留在原地
function getName() { alert (5);}//会整体提升

//请写出以下输出结果：
Foo.getName();//2
getName();//4
Foo().getName();//1
getName();//1
new Foo.getName();//2
new Foo().getName();//3
new new Foo().getName();//3

答案参考：一道常被人轻视的前端JS面试题

JS23.Javascript作用链域?

外部函数无法查看内部函数的内部细节，但内部函数可以查看其外层的函数细节，直至全局细节。当需要从局部函数查找某一属性或方法时，如果当前作用域没有找到，就会上溯到上层作用域查找，直至全局函数，这种组织形式就是作用域链。

JS24.new操作符具体干了什么呢?

1、创建一个空对象，并且 this 变量引用该对象，同时还继承了该函数的原型。

2、属性和方法被加入到 this 引用的对象中。

3、新创建的对象由 this 所引用，并且最后隐式的返回 this 。

var obj  = {};
obj.__proto__ = Base.prototype;
Base.call(obj);

JS25.用js实现千位分隔符?(来源：前端农民工，提示：正则+replace)

function commafy(num) {
     num = num + '';
     var reg = /(-?d+)(d{3})/;

    if(reg.test(num)){
     num = num.replace(reg, '$1,$2');
    }
    return num;
}

JS26.编写一个JavaScript函数，输入指定类型的选择器(仅需支持id，class，tagName三种简单CSS选择器，无需兼容组合选择器)可以返回匹配的DOM节点，需考虑浏览器兼容性和性能。

var $= function(selector) {
    var reg = /^([#\.])?(\w+)$/ig;
    var match = reg.exec(selector);
    var result = [];
    if (!match) {//如果没有匹配
        return;
    }else if (match[1]==="#") {//如果是ID
        return document.getElementById(match[2]);
    }else{//如果是类或者标签选择器
        if (typeof document.querySelectorAll==='function') {//如果这个函数存在可以直接处理类和标签选择器
            return document.querySelectorAll(match[0]);
        }else{//如果上面牛逼的函数没有，则要对类和标签选择器分别处理
            if (match[1]) {//如果是类选择器                    
                return getElementsByClassName(match[2]);//自定义的类选择函数
            }else{
                return getElementsByTagName(match[0]);
            }
        }
    }
};

/*自定义一个通过类名获取元素的函数*/
var getElementsByClassName=document.getElementsByClassName||function(className){
    var tags=document.getElementsByTagName("*");
    var result=[];
    for (var i = 0,len=tags.length; i < len; i++) {
        if (tags[i].nodeType===1) {
            if (tags[i].className.split(/\s+/).indexOf(className)!==-1) {//因为可能存在多个类名以空格分隔，所以这样处理一下比较符合要求
                result.push(tags[i]);
            }

        }    
    }
    return result;
};

JS27.实现一个函数clone，可以对JavaScript中的5种主要的数据类型（包括Number、String、Object、Array、Boolean）进行值复制。

/**
 * 对象克隆
 * 支持基本数据类型及对象
 * 递归方法
 */
function clone(obj) {
    var o;
    switch (typeof obj) {
        case "undefined":
            break;
        case "string":
            o = obj + "";
            break;
        case "number":
            o = obj - 0;
            break;
        case "boolean":
            o = obj;
            break;
        case "object": // object 分为两种情况 对象（Object）或数组（Array）
            if (obj === null) {
                o = null;
            } else {
                if (Object.prototype.toString.call(obj).indexOf("Array")! == -1) {
                    o = [];
                    for (var i = 0; i < obj.length; i++) {
                        o.push(clone(obj[i]));
                    }
                } else {
                    o = {};
                    for (var k in obj) {
                        o[k] = clone(obj[k]);
                    }
                }
            }
            break;
        default:
            o = obj;
            break;
    }
    return o;
}

JS28.请评价以下代码并给出改进意见

if(window.addEventListener){
    var addListener = function(el,type,listener,useCapture){
        el.addEventListener(type,listener,useCapture);
  };
}
else if(document.all){
    addListener = function(el,type,listener){
        el.attachEvent("on"+type,function(){
          listener.apply(el);
      });
   } 
}

上述代码的本意是定义一个跨浏览器兼容的事件监听程序，主要有三个问题：一是addListener函数不应该在条件语句里声明和赋值，这样做封装性和移植性很不好；二是没有考虑DOM0级的兼容性；三是使用的能力检测不是很规范。改进如下：

var addListener=function(el,type,listener,useCapture){
    if (el.addEventListener) {
        el.addEventListener(type,handle,useCapture);
    }else if(el.attachEvent){
        el.attachEvent("on"+type,listener);
    }else{
        el["on"+type]=listener;
    }
}

JS29.直接在对象的原型上添加方法是否安全？尤其是在Object对象上。

既然都这样问了，肯定是不安全的

容易造成全局污染，和其他库冲突
出了Bug不太好定位问题
有可能出现代码向上不兼容的情况，比如定义了一个Object.prototype.clone。万一ES7、ES8也定义了这个函数，那旧代码不就会出现问题了嘛！
在原型上添加方法会被所有实例共享
for…in..会列举出添加在原型的方法

应该根据实际情况确定是否可以实施，或者在添加之前确定是否该方法是否存在

JS30..在Javascript中什么是伪数组？如何将伪数组转化为标准数组？

伪数组（类数组）：无法直接调用数组方法或期望length属性有什么特殊的行为，但仍可以对真正数组遍历方法来遍历它们。典型的是函数的argument参数，还有像调用getElementsByTagName,document.childNodes之类的,它们都返回NodeList对象都属于伪数组。可以使用Array.prototype.slice.call(fakeArray)将数组转化为真正的Array对象。要注意的是在IE8及以前，NodeList实现为一个COM对象，要想将其转换层数组，必须手动枚举所有成员。下面的实现兼容性较强。

 function converToArray(fakeArray){
     var array = null;         
     try{        
          array = Array.prototype.slice.call(fakeArray,0);
      }catch(ex){
          array = new Array();         
          for( var i = 0 ,len = nodes.length; i < len ; i++ ) { 
                   array.push(fakeArray[i])         
               }         
      }      
   return array;          
}

JS31.对作用域上下文和this的理解，看下列代码：

var User = {
    count: 1,

    getCount: function() {
        return this.count;
    }
};
console.log(User.getCount()); // what?
var func = User.getCount;
console.log(func()); // what?

问两处 console 输出什么？为什么？

答案是 1 和 undefined。

func 是在 winodw 的上下文中被执行的，所以会访问不到 count 属性。那么问题来了，如何确保Uesr总是能访问到func的上下文，即正确返回1。答案：正确的方法是使用Function.prototype.bind。兼容各个浏览器完整代码如下：

Function.prototype.bind = Function.prototype.bind || function(context) {
    var self = this;
    return function() {
        return self.apply(context, arguments);
    };
} 
var func = User.getCount.bind(User);
console.log(func())

JS32.原生JS的window.onload与Jquery的$(document).ready(function(){})有什么不同？如何用原生JS实现Jq的ready方法？

window.onload()方法是必须等到页面内包括图片、CSS文件、JS文件等所有资源加载完毕后才能执行。
(document).ready()是DOM结构绘制完毕后就执行，不必等到资源加载完毕。另外还有一点不同的是，window.onload只能绑定一个事件处理程序，" role="presentation" style="position: relative;">(document).ready()是DOM结构绘制完毕后就执行，不必等到资源加载完毕。另外还有一点不同的是，window.onload只能绑定一个事件处理程序，(document).ready()是DOM结构绘制完毕后就执行，不必等到资源加载完毕。另外还有一点不同的是，window.onload只能绑定一个事件处理程序，document.ready()可以多次调用，添加多个事件处理程序

document.ready=(function (){  
    var fns = [];  //为了支持多个事件处理函数，将添加的事件处理函数缓存在数组中 
    //执行所有缓存的事件处理函数
    var run = function(){
        for (var i = 0; i < fns.length; i++){
            fns[i](); 
        }         
    } ;     
    if (document.addEventListener) {//标准浏览器
        document.addEventListener("DOMContentLoaded",function(){
            // 注销事件，避免反复触发
            document.removeEventListener("DOMContentLoaded",arguments.callee,false);
            run();//执行函数
        },false);
    }else if (document.attachEvent) {//IE浏览器
        document.attachEvent('onreadystatechange',function(){
            if (document.readyState=="interactive" || document.readyState=="complete") {
                document.detachEvent("onreadystatechange",arguments.callee);
                run();
            }
        });
    } 
    //返回添加事件处理程序到缓存数组的函数，利用了闭包的特性
    return function(fn){
        fns.push(fn);
    }    
})(); 
//下面是测试代码
document.ready(function(){
    alert("1");
});
document.ready(function(){
    alert("2");
});

参考：

Running code when the document is ready

《JavaScript高级程序设计-第三版》P390页

JS32.（设计题）想实现一个对页面某个节点的拖曳？如何做？（使用原生JS）

万能的红宝书《JavaScript高级程序设计》在第16章介绍了HTML5原生支持的拖放，在第22章也实现了不需要HTML5特性支持的拖放，我们可以直接参考。

如果浏览器支持HTML5，为了使页面元素具有拖放功能，只需要设置元素的draggable="true"即可。下面主要介绍在不支持HTML5情况下的原生拖放。

设置需要拖拽的节点绝对定位
给需要拖拽的节点绑定mousedown, mousemove, mouseup事件
mousedown事件触发后，开始拖拽
mousemove时，需要通过event.clientX和clientY获取拖拽位置，并实时更新位置
mouseup时，拖拽结束

var DragDrop=function () {
    var dragging=null,
    diffx=0,
    diffy=0;
    function handleEvent(event){
        event=event||window.event;
        var target=event.target||event.srcElement;
        switch(event.type){
            case "mousedown":
            //如果该元素添加了draggable类,就认为其可以拖拽
                if (target.className.indexOf("draggable")>-1) {
                    dragging=target;
                    diffx=event.clientX-target.offsetLeft;
                    diffy=event.clientY-target.offsetTop;
                }
                break;
            case "mousemove":
                if (dragging!==null) {
                    dragging.style.left=(event.clientX-diffx)+"px";
                    dragging.style.top=(event.clientY-diffy)+"px";
                }
                break;
            case "mouseup":
                dragging=null;
                break;
        }
    }
    return{
        enable:function(){//这里偷懒未考虑事件监听的兼容性
            document.addEventListener("mousedown",handleEvent,false);
            document.addEventListener("mousemove",handleEvent,false);
            document.addEventListener("mouseup",handleEvent,false);
        },
        disable:function(){
            document.removeEventListener("mousedown",handleEvent,false);
            document.removeEventListener("mousemove",handleEvent,false);
            document.removeEventListener("mouseup",handleEvent,false);
        }
    }

}();

JS33.说出以下函数的作用是？空白区域应该填写什么？

//define
(function(window) {
    function fn(str) {
        this.str = str;
    }

    fn.prototype.format = function() {
        var arg = ______;
        return this.str.replace(_____, function(a, b) {
            return arg[b] || "";
        });
    }
    window.fn = fn;
})(window);

//use
(function() {
    var t = new fn('<p><a href="{0}">{1}</a><span>{2}</span></p>');
    console.log(t.format('http://www.alibaba.com', 'Alibaba', 'Welcome'));
})();

答案：访函数的作用是使用format函数将函数的参数替换掉{0}这样的内容，返回一个格式化后的结果：

第一个空是：arguments

第二个空是：/\{(\d+)\}/ig

JS34.看下面的代码？问a怎么变，匿名函数里的this是什么？怎么改变里面的this？匿名函数不能传参怎么改变obj.a的值？

var obj = {  
    a : 1, 
    func : function () {  

        (function () {  this.a = 2;  }).call(this);  
    } 
}; 
obj.func();

obj.a不变，匿名函数里的this指向全局对象(window)，相当于给window加了一个名为a的属性。

解决方案

使用call或者apply方法

var obj = {  
    a : 1, 
    func : function () {  

        (function () {  this.a = 2;  }).call(this);  
    } 
}; 
obj.func(); 
console.log(obj.a);

保存外部环境的上下文在内部使用

var obj = {  
    a : 1, 
    func : function () {  
        var self=this;
        (function () {  self.a = 2;  })();  
    } 
}; 
obj.func(); 
console.log(obj.a);

JS35.移除数组中的元素

返回新数组

function remove(arr, item) {
        return arr.filter(function(x) { 
            return x !== item; 
        });
    }

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

直接在原数组上操作

function removeWithoutCopy(arr, item) {
  for(var i = 0; i < arr.length; i++) {
    if(item === arr[i]) {
      arr.splice(i, 1);
      i--; // for循环逆序的话，i--可以省略
    }
  }
  return arr;
}

function removeWithoutCopy(arr, item) {
    var pos = arr.indexOf(item);
    while(pos !== -1) {
        arr.splice(pos, 1);
        pos = arr.indexOf(item);
    }
    return arr;
}

JS36.进制转换

十进制转换成其他进制

/**
 * [convert description]
 * @param  {[number]} num  [description]
 * @param  {[number]} base [转换后的基数]
 * @return {[type]}      [description]
 */
function convert(num, base) {
    return num.toString(base);
}
console.log(convert(16,2))//10000

其他进制转化成十进制

function convertFromD(num,base) {
    return parseInt(num,base);
}
console.log(convertFromD(11000,2))//24

JS37.关于console.log的小题

1.下面的表达式在浏览器中的结果是console还是window

console.log.apply(console,this);

解析：笔试时居然脑子短路判成了console,首先这里传入参数this时，这个this指向Window无疑，这里的this是实参，在console.log函数中打印的就是这个Window,并没有因为执行环境上下文是console而覆盖参数。本来单独执行console.log(),log方法就是作为console对象的方法来调用，现在传进去的环境还是console.log,上面的语句实际上就是console.log(this)

2.输出的字符串前统一加上(app) 这样的字符串(考察arguments->args;apply)

function log(){ 
    var args = Array.prototype.slice.call(arguments); 
    args.unshift('(app)'); 
    console.log.apply(console, args);
};

参考：

(由于很多题都是临时收集，很多没注意出处，请谅解)

你有必要知道的 25 个 JavaScript 面试题

 javascript-puzzlers

BAT及各大互联网公司2014前端笔试面试题–JavaScript篇

来自为知笔记(Wiz)