原生JS封装函数

封装一个isNaN函数

function myIsNaN(n) {
    var num = Number(n);
    if (num + '' === 'NaN') {
        // 把处理出来的数字转化成字符串，在去和NaN做比较
        return true
    }
    return false //打断函数的执行
}      

封装一个myPush方法

function myPush(ary,n){
    ary[ary.length] =n;
}
var ary=[1,2];
myPush(ary,222);
console.log(ary);        

封装一个方法，可以获取某个元素下的所有元素子节点

function getChildren(ele){
    // 从childNodes中筛选出元素子节点即可
    var ary=[];
    for(var i=0;i<ele.childNodes.length;i++){
        if(ele.childNodes[i].nodeType == 1 ){
            ary.push(ele.childNodes[i])
        }
    }
    return ary;
}         

封装一个函数，使用splice 实现 push pop unshift shift

function mypush2(arr,...abc){   //剩余运算符...在函数中
    //abc是个数组，存储的是除了第一项之后的所有项   
    <!-- var ary=arguments[0];  我们要操作的数组   -->
    arr.splice(arr.length,0,...abc)
    //在数学中，就叫扩展运算符（解构）,把abc数组拆开  
    return arr.length;
}
var ary=[1,2]
mypush2(ary,4,5,[6,7,8],9)
 
function mypop(arr){
    return arr.splice(arr.length-1,1)[0]
}
mypop2=ary      

封装一个函数，mypush，返回值是改变后的数组长度

function mypush(arr){
    var ary=arguments[0]; // 我们要操作的数组
    for(var i=1;i<arguments.length;i++){
        arr[arr.length]=arguments[i]
    }
return arr.length
}   
var ary=[1,2]
mypush(ary,4,5,[6,7,8],9)
console.log(ary); //[1,2,4,5,[6,7,8,],9]      

封装一个myReverse方法(翻转函数)

function myReverse(arr) {        
    var a = [];
    for (var i = 0; i < arr.length; i++) {
        var temp = arr[i];
        a.unshift(temp)
    }
    return a;
}
var ary = [1,2,3,4];
var res2 = myReverse(ary);
console.log(res2, ary);
//这个方法不改变原来数组，新数组是倒叙输出。        

封装一个方法，和join()用法一样，按照指定字符拼接成字符串，不穿餐厨，默认逗号拼接。

var res2=ary.join('+')
var ary = [1,2,3,4];
function myjoin(arr,str){
    var s='';
    //把数组中的每一项拿出来，跟指定字符拼接即可
    for(var i=0;i<arr.length-1;i++){
        s += arr[i] +str
    }
    return s
}   
var res=myjoin(ary,'+');