第一题

id查询

 // 需求 : 两个数组，最终输出：
        //      ['员工张三，29岁，工作于百度', '员工李四，26岁，工作于阿里巴巴'，...]

        var employees = [
            {
                name: "张三", // 员工名字
                empId: 0, // 员工id
                age: 29, // 员工年龄
                compId: 1, // 所属公司id
            },
            {
                name: "李四",
                empId: 1,
                age: 26,
                compId: 2,
            },
            {
                name: "王五",
                empId: 2,
                age: 28,
                compId: 1,
            },
            {
                name: "小明",
                empId: 3,
                age: 32,
                compId: 3,
            },
        ];

        var companies = [
            {
                name: "百度", // 公司名称
                id: 1, // 公司id
            },
            {
                name: "阿里巴巴",
                id: 2,
            },
            {
                name: "腾讯",
                id: 3,
            },
        ];

        /* 
        目标数据结构
        ['员工张三，29岁，工作于百度',
          '员工李四，26岁，工作于阿里巴巴'，
          ...] */

      

第一种方法：

  // 1.employees 列表的  compId 字段   去  companies 列表中查询name
        // 参数: id    返回值是 name
        function getCompName(id) {
            /* let name = null;
            companies.forEach(item=>{
                if(item.id == id){
                    name = item.name;
                }
            })
            return name; */
            for (let i = 0; i < companies.length; i++) {
                if (companies[i].id == id) {
                    return companies[i].name;
                }
            }
        }

        // console.log(getCompName(2));

        // 2. 遍历员工列表,将一个特定的字符串 放进一个新数组中

        function getNewArr(arr) {
            let newArr = [];
            arr.forEach(item => {
                // console.log(`员工${item.name}，${item.age}岁，工作于${getCompName(item.compId)}`);
                newArr.push(`员工${item.name}，${item.age}岁，工作于${getCompName(item.compId)}`);
            })
            return newArr;
        }
        console.log(getNewArr(employees));

第二种方法：

var arr = []
        employees.forEach(e => {
            companies.forEach(el => {
                if (e.compId == el.id) {
                    arr[arr.length] = ('员工' + e.name + '，' + e.age + '岁，工作于' + el.name)
                    // arr.push('员工' + e.name + '，' + e.age + '岁，工作于' + el.name)
                    // console.log('员工'+e.name+'，'+e.age+'岁，工作于'+el.name);
                }
            })
        })
        console.log(arr);

第二题

对象转数组

// 需求: 请把下列的数组变成是: [['苹果','胡萝卜', '花生'], ['梨', '西芹', '坚果']....]
        var basket = [
            { fruit: "苹果", veg: "胡萝卜", nut: "花生" },
            { fruit: "梨", veg: "西芹", nut: "坚果" },
            { fruit: "香蕉", veg: "土豆", nut: "杏仁" },
            { fruit: "西瓜", veg: "豆芽", nut: "核桃" }
        ];

第一种：

        // 1. 遍历数组
        /*  var newArr = [];
         basket.forEach((item,index)=>{
             // console.log(item);
             // 2. 初始化 二维数组
             // 预期数据结构 [[],[],[],[]]
             newArr.push([]);
             // 3. 对象遍历
             for(let key in item){
                 newArr[index].push(item[key])
             }
         })
         console.log(newArr); */
 

第二种：

        /* var newArr = [];
        basket.forEach(item=>{
            // console.log(Object.values(item));
            // 对象转数组 之后 push 进新数组
            newArr.push(Object.values(item))
        })
        console.log(newArr); */

第三种

       /* // ****map方法 功能: 将每一次遍历时候返回的结果 合并成 一个新数组 整体返回
        var arr = [1, 2, 3, 4, 5];
        var newArr =  arr.map((item,index)=>{
            // console.log(item,index);
            return item+"你好强啊!!!"
        })

        console.log(newArr); */

        var newArr = basket.map(item=>{
            return Object.values(item);
        })
        console.log(newArr);

第四种

 var arr = []
        var list = []
        basket.forEach(e => {
            for (key in e) {
                list[list.length] = e[key]
            }
            arr[arr.length] = list
            list = []
        })
        console.log(arr);

第三题

数据统计

/*需求:
         程序实现对数据统计其出现的次数并按出现次数进行排序，
         [1到4] 作为参数（**参数可变**）传入js方法中，控制台输出如下结果
            1 出现了 3 次
            2 出现了 2 次
            4 出现了 2 次
            3 出现了 1 次 */

 // 1. 数组中参数可变 
        function getRandomArr(min, max, total) {
            let arr = [];
            for (let i = 0; i < total; i++) {
                arr.push(Math.floor(Math.random() * (max - min + 1) + min))
            }
            return arr;
        }

        let randomArr = getRandomArr(1, 5, 10);
        console.log(randomArr);

        // 2. 函数封装(程序)
        // 参数:randomArr   不需要返回值
        function countNum(arr) {
            // 3.初始化对象
            // 思想: 初始化一个值为1 然后做累加 
            // 预期的数据类型：
            /*
                {
                    1：2，
                    2：2；
                    4：1
                    。。。。。。。
                }
            */
            let obj = {};
            // 4.遍历数组
            arr.forEach(item => {
                // 对象添加/修改属性值, 
                // obj.name = xxx 如果没有这个key 是添加, 如有是修改
                // 5. 判断什么时候初始化为某个 key 次数1
                if (obj[item]) {
                    obj[item]++;
                } else {
                    obj[item] = 1;
                }
            })
            
            // console.log(obj);
            // 6. 对象遍历,打印需求文字
            // 7.排序
            let newArr= [];

            for(let k in obj){
                // console.log(`${k} 出现了 ${obj[k]} 次`);
                newArr.push({num:k,count:obj[k]})
            }
            // console.log(newArr);

            newArr.sort((a,b)=>{
                return a.count-b.count;
            }).forEach(item=>{
                // console.log(item);
                console.log(`${item.num} 出现了 ${item.count} 次`);
            })
        }
        countNum(randomArr);

第四题

数组行转列

 // 需求: 实现二维数组行转列
        var arr = [
            ["前端", "3人", "8-15k", "本科"],
            ["后端", "5人", "10-25k", "研究生"],
            ["UI", "2人", "9-11k", "大专"],
            ["ETL工程师", "10人", "6-12k", "大专"],
        ];

 /* 转换 =>
        var newArr = [
            ["前端", "后端", "UI", "ETL工程师"],
            ["3人", "5人", "2人", "10人"],
            ["8-15k", "10-25k", "9-11k", "6-12k"],
            ["本科", "研究生", "大专", "大专"],
        ]; */

方法一

        // 思路: 两次遍历   1 行转列  2 列转行
        let newArr = [];
        // 1. 遍历行  arr[0]
        for (let i = 0; i < arr[0].length; i++) {
            // 预期数据类型:
            //     [
            //         []
            //         []
            //         []
            //         []
            //     ]
            
            // 2. 列的初始化
            newArr[i] = [];
            // 3. 列转行
            for (let j = 0; j < arr.length; j++) {
                // 预期数据类型: 
                //     [
                //         ["前端", "后端", "UI", "ETL工程师"]
                //         []
                //         []
                //         []
                //     ]
                // 4. 列数据 塞进 行内
                newArr[i][j]= arr[j][i];
            }
        }

        console.log(newArr);

方法二

// 1 行转列  2 列转行
        let newArr = arr[0].map((col, index) => {
            // 这个return 类似于 newArr[i] = [];
            return arr.map(row=>{
                // 这里return 类似于  ["前端", "后端", "UI", "ETL工程师"]
                return row[index];
            })
        })

        console.log(newArr);

方法三

var arr2 = []
        var arr3 = []
        function list(num) {
            arr.forEach(function (e) {
                arr2[arr2.length] = e[num]
            })

            arr3[arr3.length] = arr2
            arr2 = []
        }
        for (var i = 0; i < arr.length; i++) {
            list(i)
        }
        console.log(arr3);

第五题

对象数组去重排序

      // 需求:对以下数据 取出每人(name)最大的销售量(sales)数据 ( 对sales排序对name去重)
        var arr = [
            { name: "小明", year: 2019, sales: 53 },
            { name: "小明", year: 2020, sales: 234 },
            { name: "小明", year: 2018, sales: 24 },
            { name: "小强", year: 2019, sales: 31 },
            { name: "小强", year: 2020, sales: 567 },
            { name: "小强", year: 2018, sales: 678 },
            { name: "小红", year: 2019, sales: 465 },
            { name: "小红", year: 2020, sales: 82 },
            { name: "小红", year: 2018, sales: 576 },
            { name: "小马", year: 2019, sales: 4567 },
            { name: "小马", year: 2020, sales: 832 },
            { name: "小马", year: 2018, sales: 674 },
        ];

       /*  var arr = [1,2,1,7,4,6,4,6,4,7];
        // 数组的原型方法 sort  默认是升序排列
        console.log(arr.sort((a,b)=>{
            // 升序
            // return a-b;
            // 降序
            return b-a;
        })); */

        // 1. 函数封装   参数 arr  返回值 新数组
        function getArrayObject(arr){
            let obj = {};
            // 2. 对sales属性进行排序(升序)
            arr.sort((a,b)=>{
                // a b 对应的是数组的值{}
                return a.sales-b.sales;
                // 3. 对name去重 保留最大销售数据
            }).forEach(item=>{
                // console.log(item);
                // 对象的特性: 给key进行赋值,如果存在,会修改(覆盖)
                /*
                    预期的数据类型:
                    {
                        "小明":{ name: "小明", year: 2020, sales: 234 },
                        "小马":{ name: "小马", year: 2019, sales: 4567 },
                    }
                */
                obj[item.name] = item;
            })
            // console.log(arr);

            // console.log(obj);
            // 4. 返回新数组
            return Object.values(obj);
            // return 新数组
        }

        console.log(getArrayObject(arr));

方法二

 // 设置需要的变量
        var list = [], arr2 = [], num = 0
        // 先存第一个数据
        list[0] = arr[0]
        // console.log(list);
        for (var i = 1; i < arr.length; i++) {
            // 判断name值是否相等，相等就放list数组里面如何排序取最大那个给到arr2
            if (list[list.length - 1].name == arr[i].name) {
                list[list.length] = arr[i]
                // 排序
                list.sort(function (min, max) {
                    return min.sales - max.sales
                })
                // 赋值给arr2第num个
                arr2[num] = list[list.length - 1]
            } else {
                // 如果name等，那么使用第arr[i]个覆盖list前面的数据，并且num++
                list = [arr[i]]
                num++
            }
        }
        // 给取好的值按sales排序
        arr2.sort(function (min, max) {
            return min.sales - max.sales
        })
        console.log(arr2);