JS 对象、JSON、数组客观题

    1  以下代码输出什么？

    var name = 'sex'
    var company = {
        name: '饥人谷',
        age: 3,
        sex: '男'
    }
    console.log(company.name)  //饥人谷

    2  以下代码输出什么？

    var name = 'sex'
    var company = {
        name: '饥人谷',
        age: 3,
        sex: '男'
    }
    console.log(company['name'])  //饥人谷


    3  以下代码输出什么？

    var name = 'sex'
    var company = {
        name: '饥人谷',
        age: 3,
        sex: '男'
    }
    console.log(company[name])  //男


    4 写补全sortString函数，实现字符串倒序

    function  sortString(str){
        //补全
    }
    var str = 'jirenguhungervalley'
    var str2 = sortString(str)
    console.log(str2)

方法：
    function  sortString(str){
        return str.split('').reverse().join('');
    }

题干

JSON 格式的数据需要遵循什么规则？
回答内容

1.复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
2.简单类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和null（不能使用NaN, Infinity, -Infinity和undefined）。
3.字符串必须使用双引号表示，不能使用单引号。
4.对象的键名必须放在双引号里面。
 数组或对象最后一个成员的后面，不能加逗号。

遍历 company 对象，输出里面每一项的值

var company = {
name: '饥人谷',
age: 3,
sex: '男'
}

提示
for ... in
回答内容

   var company = {
   name: '饥人谷',
   age: 3,
   sex: '男'
   }
   for(var i in company){
   console.log(company[i]);
   }

使用 JSON 对象实现一个简单的深拷贝函数(deepCopy)。
提示
JSON.stringify 与 JSON.parse
回答内容

    var obj = {
    name: 'hunger',
    age: 3,
    friends: ['aa', 'bb', 'cc']
    }

    var obj2 = JSON.parse(JSON.stringify(obj))
    obj.age = 4
    console.log(obj2.age)

分别举例说明数组方法push、pop、shift、unshift、join、splice、sort、join、reverse、concat的作用？
回答内容

    1.push（值，...） （把它的参数顺序添加到 arrayObject 的尾部，返添加后 arrayObject 的新长度unmber）
    var colors = new Array("red","green");
    console.log(colors.push("blank")); // 3

    2.pop（没有值） （删除 arrayObject 的最后一个元素，返被删除的元素）
    var colors = new Array("red","green");
    console.log(colors.pop()); // green

    3.shift（没有值） （删除 arrayObject 的第一个元素，返被删除的元素）
    var colors = new Array("red","green");
    console.log(colors.pop()); // red

    4.unshift（值，...） （把它的参数顺序添加到 arrayObject 的开头，返添加后 arrayObject 的新长度unmber）
    var colors = new Array("red","green");
    console.log(colors.unshift("blank")); //3

    5.join（空 || " " || "-"） （把数组中所有元素放入一个字符串，返字符串）
    var nums = [1,2,3];
    var str = nums.join("-");
    console.log(str); //"1-2-3"

    6.（1）splice（index索引, count个数） （1.删除数组项，返被删除元素数组）
    var a = [1,2,3,4,5];
    console.log(a.splice(1,3)); //[2, 3, 4]

    （2）splice（index索引, 0删除，item1,...插入的值） （2.插入数组项，返新数组）
    var a = [1,2,3,4,5];
    a.splice(1,0,"a",99,999);
    console.log(a); //[1, "a", 99, 999, 2, 3, 4, 5]

    （3）splice（index索引, count个数, item...替换的值） （3.替换数组项，返新数组）
    var a = [1,2,3,4,5];
    a.splice(1,3,"a","b","c");
    console.log(a); //[1, "a", "b", "c", 5]

    7.sort（fn） （数组元素进行排序）
    var arr = [2,3,1,5,-3];
    arr.sort(function(a,b){
    return a<b
    })
    console.log(arr); // arr.sort(function(a,b){

       return a<b

    })

    console.log(arr); //[5, 3, 2, 1, -3]

    8.reverse（） （颠倒数组的元素）
    var num = [a,b,c];
    cosole.log(num.reverse()); //c,b,a

    9.concat（值，...） （链接多个数组）
    var arr = [2,3];
    var sum = [11,55,77]
    console.log(arr.concat(sum)); //[2, 3, 11, 55, 77]

写一个函数，操作数组，返回一个新数组，新数组中只包含正数。

function filterPositive(arr){
}
var arr = [3, -1, 2, '饥人谷', true]
filterPositive(arr)
console.log(arr) //[3, 2]

回答内容

    function filterPositive(arr){
    var newArr=[]
    for(var i=0;i<arr.length;i++){ if(typeof arr[i]=="number"){ if(arr[i]>0){
    newArr.push(arr[i])
    }
    }

    } return newArr
    }
    var arr = [3, -1, 2, '饥人谷', true]
    console.log(filterPositive(arr))// [3, 2]
    console.log(arr)//[3, -1, 2, "饥人谷", true]

用 splice函数分别实现 push、pop、shift、unshift方法。
如:

function push(arr, value){
arr.splice(arr.length, 0, value)
return arr.length
}
var arr = [3, 4, 5]
arr.push(10) // arr 变成[3,4,5,10]，返回4

改进版

function push(arr){
for(var i=1; i<arr.length;i++){
arr.splice(arr.length, 0, arr[i])
}
return arr.length
}
//下面的写法有兴趣的同学可自行了解 //http://es6.ruanyifeng.com/#docs/array
function push(arr, ...args){
arr.splice(arr.length, 0, ...args)
return arr.length
}

回答内容

    1.push、
    console.log(arr.length) // 4 添加数组最后新长度

    2.pop、
    console.log(arr.splice(2,1)) //[5] 删除数组最后一个元素

    3.shift、
    console.log(arr.splice(0,1)) //[3] 删除数组第一个元素

    4.unshift
    arr.splice(0,0,"a")
    console.log(arr.length); //5 添加数组第一个新长度 //["a", 3, 4, 5, 10]

对以下代码 users中的对象，分别以 name 字段、age 字段、company 字段进行排序

var users = [
{ name: "John", age: 20, company: "Baidu" },
{ name: "Pete", age: 18, company: "Alibaba" },
{ name: "Ann", age: 19, company: "Tecent" }
]
回答内容

    var users = [
    { name: "John", age: 20, company: "Baidu" },
    { name: "Pete", age: 18, company: "Alibaba" },
    { name: "Ann", age: 19, company: "Tecent" }
    ]
    //定义一个比较器
    function compare(propertyName) {
    return function(object1, object2) {
    var value1 = object1[propertyName];
    var value2 = object2[propertyName];
    if (value2 < value1) {
    return 1;
    } else if (value2 > value1) {
    return -1;
    } else {
    return 0;
    }
    }
    }
    //使用方法
    users.sort(compare("age"));
    console.log(users);

分别举例说明ES5数组方法 indexOf、forEach、map、every、some、filter、reduce的用法？
回答内容

    1.indexOf（项元素-必须，index-可选） （从数组开头（项），开始向后查找，返索引位置--number）
    var a = [1,2,3,3,2,1];
    console.log(a.indexOf(2)); //1
    console.log(a.lastIndexOf(2)); //4

    2.forEach（element, index, array） （遍历数组，参数为一个回调函数）
    var a = new Array(1,2,3,4,5,6);

    a.forEach(function(e,i,array){
    array[i]= e + 1;
    });

    console.log(a); //[2, 3, 4, 5, 6, 7]

    3.map（function(element)） （与forEach类似，遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变）
    var a = new Array(1,2,3,4,5,6);

    console.log(a.map(function(e){
    return e * e;
    })); // [1, 4, 9, 16, 25, 36]

    console.log(a); //[1, 2, 3, 4, 5, 6]

    4.every(function(element, index, array)) （every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false）
    var a=new Array(1,2,3,4,5,6);

    console.log(a.every(function(e, i, arr){
    return e < 5;
    })); //false

    console.log(a.some(function(e,i,arr){
    return e > 4;

    })); //true
    5.some(function(element, index, array)) （ some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false

    在空数组上调用every返回true，some返回false）

    6.filter(function(element)) （返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加

    新数组只包含返回true的值，索引缺失的不包括，原数组保持不变）
    var a = new Array(1,2,3,4,5,6);

    console.log(a.filter(function(e){
    return e % 2 == 0;
    })); // [2, 4, 6]

    console.log(a); //[1, 2, 3, 4, 5, 6]

 7.reduce(function(v1, v2), value) （遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始，reduceRight反向，方法有两个参数

    1..回调函数：把两个值合为一个，返回结果

    2..value，一个初始值,可选

    ）

    var a = new Array(1,2,3,4,5,6);

    console.log(a.reduce(function(v1, v2){
    return v1 + v2;
    })); // 21

    console.log(a.reduceRight(function(v1, v2){
    return v1 - v2;
    }, 100)); // 79

题目2

实现一个flatten函数，将一个嵌套多层的数组 array（数组） (嵌套可以是任何层数)转换为只有一层的数组，数组中元素仅基本类型的元素或数组，不存在循环引用的情况。 Ex: flatten([1, [2], [3, [[4]]]]) => [1, 2, 3, 4];

解答：

var arr = [3, [2, -4, [5, 7]], -3, ['aa', [['bb']]]]
var arr2 = flatten(arr)
console.log(arr2)


function flatten(arr){
  return arr.reduce(function(initArr, currentArr){
    return initArr.concat(Array.isArray(currentArr)?flatten2(currentArr):currentArr)
  }, [])
}

function flatten2(arr){
  var newArr = []
  function _flat(arr){
    arr.forEach(val=>{
      if(Array.isArray(val)){
        _flat(val)
      }else{
        newArr.push(val)
      }
    })    
  }
  _flat(arr)
  return newArr
}

flatten函数.png

flatten函数.png