深复制、数组的静态方法

递归

深复制 浅复制 代码实现
二叉树 前中后序遍历实现

深查找

广度遍历 深度遍历

对象的广度遍历用for in
对象的深度遍历用递归

var obj = {
    a:1,
    b:2,
    c:3,
    d:{
        e:4,
        f:5,
        g:6,
        h:{
            i:7,
            j:8,
            k:9
        }
    }
}
function fn(o,value){
    for(prop in o){
        if(o[prop] === value) return prop;//广度遍历
        if(typeof o[prop] ==="object"&&o[prop]!==null){ //深度遍历
            var s = fn(o[prop],value);//递归
            if(s) return s;
        }
    }
}

console.log(fn(obj,9));

深复制

function fn(source,target){
    if(target===undefined)
    target={};
    for(var prop in source){
        if (typeof source[prop] === "undefined"&&source[prop]!==null){
            target[prop]={};
            fn(source[prop],target[prop]);
        }
        else{
            target[prop]=source[prop];
        }
    }
    return target;
}

二叉树的前中后序遍历

var node = {
    value:0,
    left:{
        value:1,
        left:{
            value:3,
        }
        right:{
            value:4,
        }
    }
    right:{
        value:2,
        left:{value:5}
        right:{value:6}
    }
}
function fn(obj){
    console.log(o.value);//先序遍历
    if(obj.left) fn(obj.left)
    <!-- console.log(o.value);//中序遍历 -->
    if(obj.right) fn(obj.right)
    <!-- console.log(o.value);//后序遍历 -->

}

数组

数组的创建

1、字面量创建 var arr = [1,2,3];
2、构造函数创建 var arr=new Array(1,2,3,4);
var arr=Array(1,2,3,4)；
3、对象创建 var arr=new Object([1,2,3,4]);

js中数组的元素可以类型不同
var arr=[1,2,3];
arr=[];
因为空元素就是下标没有对应的值，所以可以通过 下标 in 数组 这种方式判断

var arr=[1,,3,undefined,5];
for(var i=0;i<5;i++){
    if(!(i in arr))continue;
    console.log(arr[i]);
}

如果构造函数中的元素数量大于1个，则所有的元素都是这个数组的元素
// new Array(1,2,3,4,5);
注：构造函数中的参数只有一个时，这个参数代表的就是数组的长度；如果仅有一个参数，并且这个参数是数值类型，但是并不是正整数，就会报错；如果仅有一个参数，但是这个参数不是数值类型，则会将这个参数放在数组的第0位

数组的长度

arr.length
有值或者空元素的数量
arr[0]数组的第一个元素
arr[arr.length-1] 数组最后一个元素
arr.length 是一个可读可写的属性
如果当前数组的长度小于设置的长度，则增加（新长度-原长度）数量的空元素
如果新长度小于原长度，就会从后删除（原长度-新长度）数量的元素
清空数组的方法 arr.length = 0;
arr.length–删除尾部的最后一个元素
arr.length-=-5; length不能小于0或者是负数，必须为正整数
数组里面可以存字符串、布尔值、对象、数组和函数

数组的方法

push 尾部添加一个或者多个元素，并且返回数组的新长度

var arr=[];
var len=arr.push(1);
arr.push(1,2,3);
console.log(arr);
push()重构
throw new Erorr() 抛出错误 中断后续代码的执行
     function array_push(arr){
         if(arr==undefined || arr.constructor!==Array) throw new Error("错误参数");
         if(arguments.length===1) return arr.length;
         for(var i=1;i<arguments.length;i++){
             arr[arr.length]=arguments[i];
         }
    // 给数组尾部一旦添加元素，arr.length就会自动重设
         return arr.length;
     }
var arr=[];
var len=array_push(arr,3,4,6,2,1);
console.log(len,arr);

pop()删除数组尾部的一个元素，并且返回被删除的元素(该方法修改原有数组)。

pop方法的重构
      function array_pop(arr){
          var item=arr[arr.length-1];
          arr.length--;
          return item;
      }

      var arr=[4,3,2,1];
      var item=array_pop(arr);
      console.log(arr,item);

unshift 向数组的头部添加一个元素，并且返回数组的新长度(该方法修改原有数组)。

function array_unshift(arr) {
if (arr == undefined || arr.constructor !== Array)
    throw new Error("错误参数");
if (arguments.length === 1) return arr.length;
var len = arguments.length - 1; //当前添加参数数量
arr.length = len = len + arr.length; //添加元素后数组的新长度
while (len > 0) {
    if (len > arguments.length - 1) {
    arr[len - 1] = arr[len - arguments.length];
    } else {
    arr[len - 1] = arguments[len];
    }
    len--;
}
return arr.length;
}

var arr = [1, 2, 3, 4];
array_unshift(arr, 0,1,23,5);
console.log(arr);

shift 删除数组头部的一个元素，并且返回被删除的元素,如果数组为空则返回undefined 此方法更改数组的长度

function array_shift(arr){
    if(arr.length===0) return;
    var item=arr[0];
    for(var i=0;i<arr.length-1;i++){
        arr[i]=arr[i+1];
    }
    arr.length--;
    return item;
}

var arr=[];
var item=array_shift(arr);
console.log(item,arr);

concat 合并数组，可以将一个数组和另外一个数组合并成一个数组，合并成的是新数组，原数组不变

可以用一个数组合并多个元素，产生一个新数组
如果不填写参数，则复制原数组，产生一个新数组

function array_concat(arr){
    if(arr==undefined || arr.constructor!==Array) throw new Error("不是一个数组");
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        arr1[i]=arr[i];
    }
    if(arguments.length===1) return arr1;
    for(var j=1;j<arguments.length;j++){
        if(arguments[j] && arguments[j].constructor===Array){
            for(var k=0;k<arguments[j].length;k++){
                arr1[arr1.length]=arguments[j][k];
            }
        }else
        arr1[arr1.length]=arguments[j];
    }
    return arr1;
}


var arr=[1,2,3,4];
// var arr1=array_concat(arr);
// arr[0]=100;

join([separator]) 连接字符串,用符号连接数组的元素并且生成字符串

指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符

function array_join(arr,separator){
    if(arr==undefined || arr.constructor!==Array) throw new Error("不是一个数组");
    if(separator===undefined) separator=",";
    separator=String(separator);
    var str="";
    for(var i=0;i<arr.length-1;i++){
        str+=arr[i]+separator;
    }
    str+=arr[arr.length-1];
    return str;
}

var arr=[1,2,3,4];
var str=array_join(arr,"");
console.log(str);

fill(item，start，end) 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素,不包括终止索引

注：如果 start 是个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length 属性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end。start的默认值为0，end的默认值为数组的长度length

fill重构
function array_fill(arr,item,start,end){
    if (arr==undefined|| arr.constructor!==Array) throw new Error("不是一个数组");
    if(start===undefined) start=0;
    if(end===undefined) end=arr.length
    for(var i=start;i<end;i++){
                arr[i]=item;
            }
            return arr;
        }
        var arr=Array(10);
        arr=array_fill(arr,1,2,5);
        console.log(arr);
}

数组的静态方法

Array.from将一个列表转换位数组 Array.isArray判断元素是否是数组

Array.from_1=function(list){
    var arr=[];
    if(!list.length) return arr;
    for(var i=0;i<list.length;i++){
        arr[i]=list[i];
    }
    return arr;

Array.isArray 判断元素是否是数组

Array.isArray_1=function(list){
            return (list && list.constructor===Array) ? true :false
        }