原生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,'+');