• 引用类型有哪些？非引用类型有哪些？

JS中的数据类型分为基本类型和引用类型。
基本类型：数值（number）、字符串（string）、布尔值（Boolean）、null、undefined。
基本类型的访问是按值访问的，就是说你可以操作保存在变量中的实际的值。

引用类型：除去上面的基本类型，其余的都是引用类型或称为是对象。对象是属性和方法的集合。也就是说引用类型可以拥有属性和方法，属性又可以包含基本类型和引用类型。

• 如下代码输出什么？为什么？

var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2);    //false
console.log(obj1 = obj2);    // Object  {a:1,b:2}
console.log(obj1 == obj2);    //true
//obj1和obj2是两个对象，对象的比较是栈区中对象地址的比较，obj1和obj2是两个独立的对象，栈区对象地址不一样，因此输出false；
//对象之间的赋值是栈区地址的赋值，把obj2栈区地址赋给obj1，obj1和obj2就拥有了相同的对象地址，指向同一个对象，故输出Object  {a:1,b:2}；
//由于经过obj1=obj2，obj1和obj2拥有了相同的对象地址，故输出true；

var a = 1
var b = 2
var c = { name: '饥人谷', age: 2 }
var d = [a, b, c]

var aa = a
var bb = b
var cc = c
var dd = d

a = 11
b = 22
c.name = 'hello'
d[2]['age'] = 3

console.log(aa)    //1;
console.log(bb)     //2;
console.log(cc)     //Object { name: 'hello', age: 2 }
console.log(dd)    //[1,2,Object {name: 'hello', age: 3 }]

/*基本类型之间的赋值，在从一个变量向另一个变量赋值基本类型时
会在该变量上创建一个新值，然后再把该值复制到为新变量分配的位置上，
此后两个变量之间相互独立，互不影响，因此aa=1，bb=2，此后a=11，b=22，并不影响
aa、bb的值*/

/*c是一个对象，c向cc赋值时，赋的是对象的地址，因此cc和c有相同的对象地址，指向同一个对象c*/

/*d是一个数组，a、b的赋值原理同上，c是一个对象
c.name='hello' 和 d[2]['age']=3改变了c中的对象，但是地址没变，依然指向这个对象
因此有这一个输出*/

var a = 1
var c = { name: 'jirengu', age: 2 }

function f1(n){
 ++n
}
function f2(obj){
 ++obj.age
}

f1(a)    //隐式var n=a；
f2(c)     //隐式var obj=c，把c的地址赋给obj；
f1(c.age)     //隐式 var n=c.age；
console.log(a)    //1; 
console.log(c)    //Object {name: 'jirengu', age: 2}

 //函数操作后都没有return，运行完成后函数销毁，并未改变a与c的值

• 过滤如下数组，只保留正数，直接在原数组上操作

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
}
filter(arr)
console.log(arr) // [3,1,2]

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
  for (i=0; i<arr.length;i++)    {
      if (arr[i]<=0)    {      
          arr.splice (i,1);    //从数组第i个开始删除，删除个数1个（arr[i]被删掉）
          filter(arr);    //删除后，数组序号发生变化，重新执行一次函数
      }
  }
  return arr;
}
filter(arr)
console.log(arr)

• 过滤如下数组，只保留正数，原数组不变，生成新数组

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
}
var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr)  // [3,1,0,-1,-2,2,-5]

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
    var newArr = [];
    var k = 0;
    for (i=0; i<arr.length;i++) {
        if (arr[i]>0) {
            newArr[k] = arr[i];
            k++;
        }
    }
    return newArr;
}
var arr2 = filter(arr)
console.log(arr2) 
console.log(arr) 

• 写一个深拷贝函数，用两种方式实现

//方法1
var obj = {};
function deepCopy (obj) {
    var newObj = {};
    for (i=0; i<obj.length; i++) {
        if (typeof obj[i] === "number" || typeof obj[i] === "string" || typeof obj[i] === "boolean" || obj[i] === null || typeof obj[i] === "undefined") {
            newObj[i] = obj[i];
        }else   {
            newObj[i] =  deepCopy(obj[i]);
        }
    }
    return newObj;
}
//方法2
var obj = {};
var newObj = JSON.parse(JSON.stringify(obj));
//JSON.stringify(): 将对象解析为字符串；
//JSON.parse(): 将字符串解析为对象；