1.引用类型有哪些？非引用类型有哪些

引用是指：指的是那些保存在堆内存中的对象，变量中保存的实际上只是一个指针，这个指针执行内存中的另一个位置，由该位置保存对象
引用类型有：对象，数组，函数，正则
非引用类型有：字符串，数字，布尔，null和undefined

2.如下代码输出什么？为什么

var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2);
console.log(obj1 = obj2);
console.log(obj1 ==obj2);

结果为：false object{a:1,b:2},true

obj1和obj2指向的地址不一样，即指向的堆内存的地址是一样的并不一样，为false

obj2赋值给了obj1，obj2和obj1指向的地址是一样的，二者指向了同一个堆内容区域。

obj1 ==obj2因为指向的堆内存的地址是一样的

3.如下代码输出什么? 为什么

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) 
//结果是11，因为a是基本类型值，传值给aa，不会影响a的值。

console.log(bb) 
//结果是22，因为b是基本类型值，传值给bb，不会影响b的值。

console.log(cc)
//结果是{ name: ' 'hello'', age: 3 }，因为c是引用类型，c对cc赋值是因此cc和d[2]指向了一个堆内容区域，c的内容发生变化，cc也发生变化。d[2]["age"]发生变化，那么cc也都发生了变化。

console.log(dd)
//结果是{11，22，{name："hello",age:"3"}}数组的赋值也是引用传递

4.如下代码输出什么? 为什么

var a = 1 
var c = { name: 'jirengu', age: 2 }
function f1(n){
  ++n
}
function f2(obj){
  ++obj.age
}
f1(a) 
f2(c) 
f1(c.age) 

console.log(a) 
//结果为1，因为f1(a)是传值，不改变a的值

console.log(c)
//结果是{name:"jirengu",age:3}
//因为f2(c) 是引用传值，age+1=2；
//f1(c.age) 是传值为f1(2),然后obj.age+1=3,

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

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

image.png

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

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr)
{
  var arr_new=[];
  if( arr instanceof Array)
  {
   for(var i=0;i<arr.length;i++)
   {
     arr_new[i]=arr[i];
   }
   var b=function(arr_new)
   {
     for(var i=0;i<arr_new.length;i++)
      {
          if(arr_new[i]<=0)
         {
             arr_new.splice(i,1);
             b(arr_new);
          }
        }
     }
   b(arr_new);
   }
 return arr_new;
}
var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr)  // [3,1,0,-1,-2,2,-5]

image.png

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

实现浅拷贝如下:

//浅拷贝方法
  function shallowCopy(oldObj) {
        var newObj = {};
        for(var i in oldObj) {
            if(oldObj.hasOwnProperty(i)) {
                newObj[i] = oldObj[i];
            }
        }
        return newObj;
    }

image.png

当拷贝的对象只有一层的时候，主要是依据值传递，当被拷贝bei对象中有多层对象的时候，就会出现引用的问题。如obj1的family对象发生变化的时候，拷贝对象s也会发生变化，这就是需要深拷贝的原因。

 /**深拷贝方法1**/

function deepCopy(obj){
  var obj_new={};
   for( var key in obj){
    if(obj.hasOwnProperty(key))
     {
      if(typeof obj[key]==='number'||typeof obj[key]==='string'||typeof obj[key]==='boolean'|| obj[key]===undefined||obj[key]===null)
      { 
       obj_new[key]=obj[key];
      }
      else
     {
      obj_new[key]=deepCopy(obj[key]);//递归调用，层层拷贝
     }
   }
  }
  return obj_new;
}

var f=deepCopy(obj1);

/**深拷贝方法2 **/
function deepCopy(obj){
 var new_obj={};
 new_obj =JSON.parse(JSON.stringify(obj))
return new_obj;
}

 /**深拷贝方法3 **/

function deepCopy(obj){
  var new_obj={};
  for( var key in obj)
  {
    if(obj.hasOwnProperty(key))
    {
      if(typeof obj[key]==="object"|| obj[key]！==null )
      {
        new_obj[key]=deepCopy(obj[key]);//递归调用，层层拷贝
      }
      else
      {
        new_obj[key]=obj[key];
      }
    }
  }
  return new_obj;
}

深拷贝