const menus = [{
                code:"4S200401",
            },{
                code:"4S200402",
            },
            {
                code:"4S200403",
            },
            {
                code:"4S200404",
            }
        ];

        const reqs = 
            [{
                code:"4S200403",
            },
            {
                code:"4S200404",
            }
        ];

只寻找一位数组的情况

        function getSame(muArr,reqArr){
            return muArr.filter(menu =>{
                   for(let i=0;i<reqArr.length;i++){
                            if(menu.code == reqArr[i].code){
                                return true;
                            } 
                    }
                    return false;
                }
            )
        }

        var list = getSame(menus,reqs)
        console.log(list)

寻找多维数组的情况，递归

        const menus =[{
                code:"1",
                nodes:[{code:"1-1",id:"id1-1"},{code:"1-2",id:"id1-2"}],
            },{
                code:"2",
                nodes:[{code:"2-1",id:"id2-1"},{code:"2-2",id:"id2-2"}],
            },
            {
                code:"3",
                nodes:[{code:"3-1",id:"id3-1"},{code:"3-2",id:"id3-2"}],
            },
            {
                code:"4",
                nodes:[{code:"4-1",id:"id4-1"},{code:"4-2",id:"id4-2"}],
            }
        ];

        const reqs = [ {
                code:"3",
                nodes:[{code:"3-1",id:"id3-1"},{code:"3-2",id:"id3-2"}],
            },
            {
                code:"4",
                nodes:[{code:"4-1",id:"id4-1"},{code:"4-2",id:"id4-2"}],
            }
        ];

 //nodes 数组里面是对象的情况，使用递归可以多重嵌套
        function getSame(muArr,reqArr){
            return muArr.filter(menu =>{
                    for(let i=0;i<reqArr.length;i++){
                        do {
                                if(menu.code != reqArr[i].code){
                                    break;
                                }
                                if('nodes' in menu){
                                    menu.nodes = ('nodes' in reqArr[i])?getSame(menu.nodes,reqArr[i].nodes):null;
                                }
                                return true;
                            } while (false);
                        // if(menu.code == reqArr[i].code){
                        //     if('nodes' in menu){
                        //         // if('nodes' in reqArr[i]){
                        //         //     menu.nodes = getSame(menu.nodes,reqArr[i].nodes);
                        //         // }else{
                        //         //     //menu.nodes = getSame(menu.nodes,null); //返回一个Array(0)
                        //         //     menu.nodes = null;
                        //         // }   
                        //         menu.nodes = ('nodes' in reqArr[i])?getSame(menu.nodes,reqArr[i].nodes):null;
                        //     }
                        //     return true;
                        // } 
                    }
                    return false;
                }
            )
        }

        var list = getSame(menus,reqs)
        console.log(list)

注意问题

  //for循环可以直接return false返回函数的值，在foreach中，只能在循环中累似（break）
        var nii= function(){
            for(let i=0;i<menus.length;i++){
                if(i ==2){
                    return false;
                }
                console.log(menus[i])
            }

            menus.forEach(
                item =>{
                    if(item.code == '2'){
                        return false;
                    }
                    console.log(item)
                }
            )
            console.log("woeiwioi")
        }
        nii()