一些JavaScript面试题（一）

给数字加上千分位。

字符串方法：

function toThousands(num) {
    var num = (num || 0).toString(), result = '';
    while (num.length > 3) {
        result = ',' + num.slice(-3) + result;
        num = num.slice(0, num.length - 3);
    }
    if (num) { result = num + result; }
    return result;
}

正则表达式：

1
2
3

function toThousands(num) {
    return (num || 0).toString().replace(/\B(?=(\d{3})+$)/g,",");
}

数组去重

方法一（IE8及以下不支持）：

var arr = [0,0,1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3];
    function uniqueArr(arr) {
        var result = [];
        for (var i = 0; i < arr.length; i++) {
            if (result.indexOf(arr[i]) == -1) {
                result.push(arr[i])
            }
        }
        return result;
    }
    console.log(uniqueArr(arr));//[0, 1, 2, 3]

方法二：

var arr = [0,0,1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3];
    function uniqueArr(arr) {
    	var temp={}, //这个对象是数组伴随对象，能够方便检索数组中是否存在某一个数字
       	    result = [];
        for(var i=0;i<arr.length;i++){
        //检查对象中有没有这个属性，如果没有这个属性，那么推入结果数组，并且让对象添加这个属性。属性值设置为1。
        	if (!temp[arr[i]]) {
        		result.push(arr[i]);
        		temp[arr[i]]=1;
        	}
        }
        return result;
    }
    console.log(uniqueArr(arr));//[0, 1, 2, 3]

方法三：先排序，再去重

var a = [1, 1,11,12,12,2, 3, 4, 4, 3, 2];
a = a.sort();
var b = [];
for (var i = 0; i < a.length; i++) {
    if (a[i] !== a[i - 1]) {
        b.push(a[i]);
    }
}
console.log(b);

typeof都返回哪些数据类型

1	undefined、string、number、Boolean、object、function

字符串反转，例如abcdefg返回gfedcba。用两种方法实现。

方法一：

var str = "abcdefg";
    function revStr(str) {
        var result = "";
        for (var i = str.length - 1; i >= 0; i--) {
            result += str[i];
        }
        return result;
    }
    console.log(revStr(str));//gfedcba

方法二：

var str = "abcdefg";
   function revStr(str) {
       var arr = str.split("");
       arr.reverse();
       return arr.join("");
       
        //return str.split("").reverse().join("");
   }
   console.log(revStr(str)); //gfedcba

判断一个JavaScript对象是数组

第一，使用 typeof加length属性，因为数组有length属性。第二，使用instanceof可以判断一个变量是不是数组。

var arr = ["a", "b", "c"];
   function isArr(arr) {
       if (typeof arr.length == 'number' && arr instanceof Array) {
           return "arr is Array"
       } else {
           return "arr is not Array"
       }
   }
   console.log(isArr(arr)); //arr is Array

继承和多态

继承：继承就是子类的prototype指向父类的一个实例。

JS实现继承的几种方式

借用构造函数实现继承

function Parent1(){
    this.name="parent1";
}
function Child1(){
    Parent1.call(this);
    this.type="child1";
}

缺点：Child1无法继承Parent1的原型对象，并没有真正的实现继承（部分继承）

借用原型链实现继承

function Parent2() {
    this.name = "parent2";
    this.play = [1, 2, 3];
}

function Child2() { 
    this.type = "child2"; 
} 
Child2.prototype = new Parent2();

缺点：原型对象的属性是共享的

组合式继承

function Parent3() {
     this.name = "parent3";
     this.play = [1, 2, 3]; 
 }

function Child3() { 
    Parent3.call(this);
    this.type = "child3"; 
} 
Child3.prototype = Object.create(Parent3.prototype);
Child3.prototype.constructor = Child3;

多态：多态就是子类改变了父类的方法，就是多态。

function Super() {

   }
   Super.prototype.haha = function() {
       console.log("哈哈")
   }

   function Child() {

   }
   Child.prototype = new Super();
   Child.prototype.haha = function() {
       console.log("这就是多态")
   }
   var c = new Child();
   c.haha();

关于闭包

闭包： 能够读取其他函数内部变量的函数。由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成”定义在一个函数内部的函数”。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。

闭包的用途：一个是可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。

学习JavaScript闭包

详解JS闭包

下列JavaScript代码执行后，依次alert的结果是：

(function test( ){
  var a=b=5;
  alert(typeof a);   //number
  alert(typeof b);   //number
})()
alert(typeof a);  //undefined 有var 的声明
alert(typeof b)   //number   没有var声明

描述一下事件冒泡，介绍事件委托（事件代理）的实现方法，以及它的原理和优点。

事件从最大的元素开始捕获，往下传输，就是捕获过程。然后开始冒泡。事件委托，给父元素添加点击事件，通过事件冒泡，点击子元素的时候会冒泡到父亲上。节约内存。

如何实现数组的随机排序？

方法一：

var arr = [1,2,3,4,5,6,7,8,9,10];
    function randSort1(arr){
        for(var i = 0,len = arr.length;i < len; i++ ){
            var rand = parseInt(Math.random()*len);
            var temp = arr[rand];
            arr[rand] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }
    console.log(randSort1(arr));

方法二：（不推荐，因为不能真正地随机打乱数组）

var arr = [1,2,3,4,5,6,7,8,9,10];
arr.sort(function(){
    return Math.random() - 0.5;
})
console.log(arr);

方法三：

var arr = [1,2,3,4,5,6,7,8,9,10];
function randSort(arr){
        var mixedArray = [];
        while(arr.length > 0){
            var randomIndex = parseInt(Math.random()*arr.length);
            mixedArray.push(arr[randomIndex]);
            arr.splice(randomIndex, 1);
        }
        return mixedArray;
    }
  console.log(randSort(arr));

当new Foo()时发生了什么

创建了一个新对象
将this指向这个新对象
执行构造函数里面的代码
返回新对象（this）

参考《JS高程》6.6.2