前端知识点补充（常用前端面试题）

一：数组去重复（注意数组中有复杂类型的数据）

     简单版本：hash形式

     复杂版本：需要对数据类型进行判断

    如：先判断基本类型（值类型）   undefined|number|string|boolean

           然后判断引用类型： Date,Number,Array,Object,Function，RegExp, JSON等

 

 

二：事件委托

 

某个父类下面有数量庞大的子类节点。

怎么处理在子类节点上的事件

 

事件委托-----addEventListener/attachEvent(ie需要加on);event = event || window.event

 

三：AJAX的几个流程,每个状态代表什么意思

 

属性 描述

onreadystatechange	存储函数（或函数名），每当 readyState 属性改变时，就会调用该函数。
readyState	存有 XMLHttpRequest 的状态。从 0 到 4 发生变化。 0: 请求未初始化 1: 服务器连接已建立 2: 请求已接收 3: 请求处理中 4: 请求已完成，且响应已就绪
status	200: "OK" 404: 未找到页面

var XMLHttpReq;  
function createXMLHttpRequest() {  
    try {  
        XMLHttpReq = new ActiveXObject("Msxml2.XMLHTTP");//IE高版本创建XMLHTTP  
    }  
    catch(E) {  
        try {  
            XMLHttpReq = new ActiveXObject("Microsoft.XMLHTTP");//IE低版本创建XMLHTTP  
        }  
        catch(E) {  
            XMLHttpReq = new XMLHttpRequest();//兼容非IE浏览器，直接创建XMLHTTP对象  
        }  
    }  
  
}  
function sendAjaxRequest(url) {  
    createXMLHttpRequest();                                //创建XMLHttpRequest对象  
    XMLHttpReq.open("post", url, true);  
    XMLHttpReq.onreadystatechange = processResponse; //指定响应函数  
    XMLHttpReq.send(null);  
}  
//回调函数  
function processResponse() {  
    if (XMLHttpReq.readyState == 4 && XMLHttpReq.status == 200 ) {  
       //业务逻辑处理
    }  
  
}  

四：对象深度克隆并且用树状形式打印出来

 

 

 

五：优化网站访问速度的方法。

六：为什么我们要用空函数做继承。

 

var F = function(){};
F.prototype = Parent.prototype;
Son.prototype = new F();//这样只继承父类的原型上的属性和方法，通过for in可以遍历获得父类的属性
Son.prototype.constructor = Son;//指回自己

为什么要这么做？
而不直接
Son.protype = Parent.prototype;
Son.prototype.construtor = Son;

//摘自MSDN
var newObj = Object.create(null, {
            size: {
                value: "large",
                enumerable: true
            },
            shape: {
                value: "round",
                enumerable: true
            }
        });

document.write(newObj.size + "<br/>");
document.write(newObj.shape + "<br/>");
document.write(Object.getPrototypeOf(newObj));

 

七：new  Function()---这货有撒用，什么时候用？

http://davidwalsh.name/new-function  打不开的可以看附件

1. 1. Creating dynamic functions on the fly.

   You can, for example, let a savvy end-user define script hooks to be executed when
   triggered by an event.

   2. Parsing script without executing it.

   Passing wrong syntax to the Function constructor will throw a syntax error, but
   will not execute it unless you call the resulting function object. (this opposed
   to eval, which will always execute the passed script).

   Building on the example above, you can alert your end-user if his syntax is
   wrong.

   3. and most importantly, you can hide your local variables from the end-user
   script.

   The function objects created by the Function constructor have an empty scope
   chain, and the current closure will not be saved in them.
   Basically, you get nothing but the global object.

   Continuing our example, even script with correct syntax can be problematic.

   for example, consider the following code:

   (function() {
     // my scope
     var a = 'my a';
   
     // test hook
     /* ... */
     // run hook
     new Function("a = 'user a'; var b = 'user b''")();
   
     console.log(a); // 'my a'
     console.log(b); // ReferenceError: b is not defined
     console.log(window.a) // 'user a'
     console.log(window.b) // ReferenceError: b is not defined
   })();
   

   A simple mistake as forgetting a `var` will not cause the outer scope’s
   local variables to change, but instead go directly to the global scope.

   This is why Function(‘return this’)() will return the global object.

   So why don’t we always use the wonderful Function constructor ?
   Because it’s less efficient than declaring functions normally.

   Hope I managed to answer your question.

    
2. Nir Leibovitch

   @Andrew Gaspar
   while putting the following code into the global scope will work

   (function(global) {
     // global is now the global
   })(this);
   

   Assume that you need the global object in a function within an object (or an object constructor)

   obj = {
     a: function(){
       (function(global){console.log(global)})(this);
     }
   }
   obj.a(); // Object {a: function}
   

   if you use the Function constructor, you can get the global object in this case

   obj = {
     a: function(){
       (function(global){console.log(global)})(Function('return this;')());
     }
   }
   obj.a(); // Window {...}