百度IFE2018任务--22-24天 - 《web前端》

计算textarea中的内容的行数
方法：匹配回车符出现的次数
代码：

stringB.value.match(/(\r|\n|\r\n)/g).length

半角空格和全角空格
参考：https://blog.csdn.net/clmmei_123/article/details/81180991
半角：一个英文空格，正则表达式： /(^\s)/g /g 表示全部的半角，Unicode编码 32
全角：两个英文空格，正则表达式： /(\s$)/g /g 表示全部的全角，Unicode编码 12288

去掉半角空格
用filter() 函数创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素
思路：将字符串用split()以空格切开成数组，数组中的非空字符串用filter过滤出来重新组合成新字符串就可以了

stringA.value.split(/(\s)/g).filter(function(s){
            return s.trim() != '';
        }).join('');

实现一个字符串头尾去除空格的函数
注意需要去除的空格，包括全角、半角空格
暂时不需要学习和使用正则表达式的方式
思路：一个for循环从前往后遍历，遇到非空字符，获取它的索引；同理，获取最后一个非空字符的索引。将前后索引中间这一段字符串截取出来就可以了。
代码：

function diyTrim(str) {
    var result = "";
    var startStringIndex,endStringIndex;
    // do something
    for(var i=0;i<str.length;i++){
        if(str[i] != ' ' && str[i] != '　'){
            startStringIndex = str.indexOf(str[i]);
            break;
        }
    }
    for(var j=str.length-1;j>=0;j--){
        if(str[j] != ' ' && str[j] != '　'){
            endStringIndex = str.lastIndexOf(str[j]);
            break;
        }
    }
    result = str.slice(startStringIndex,endStringIndex+1);
    return result;
}

去掉字符串str中，连续重复的地方
思路：前后两个相邻的字符，在for循环中从头往后一个个遍历，每次都对比相邻是否一样，根据对比结果来判断如何根据这两个字符来保存进入新字符串。
代码：

function removeRepetition(str) {
    var result = "";
    // var newStr = diyTrim(str);
    var tempChar = '';
    // do something
    for(var i=1;i<str.length;i++){
        tempChar = '';
        if(i == 1){
            if(str[i] != str[i-1]){
                tempChar = str[i-1]+str[i];
            }else{
                tempChar = str[i];
            }
            result += tempChar;
        }
        if(i>1){
            if(str[i] != str[i-1]){
                tempChar = str[i];
            }
            result += tempChar;
        }
    }
    return result;
}

三元运算符用在字符串连接中时，要括号包围，否则会出错

(this.gender == 'male'?'He':'She')

JavaScript有个内嵌的方法[create()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create), 它允许您基于现有对象创建新的对象。缺点是比起构造函数，浏览器在更晚的时候才支持create()方法（IE9, IE8 或甚至以前相比）

var person3 = Object.create(person2);
console.log(person3.age);

前序、中序、后序遍历对象的属性
前序遍历、中序遍历、后序遍历的区别：该节点本身在前、中、后位置输出，这个位置就是前序、中序、后序
有如上对象，分别实现代码下方的几个函数，满足以下需求：
假设id和name均不会重复，根据输入name找到对应的id
假设id和name均不会重复，根据输入id找到对应的name
把这个对象中所有的名字以“前序遍历”的方式全部输出到console中
把这个对象中所有的名字以“中序遍历”的方式全部输出到console中
把这个对象中所有的名字以“后序遍历”的方式全部输出到console中

var tree = {
    "id": 0,
    "name": "root",
    "left": {
        "id": 1,
        "name": "Simon",
        "left": {
            "id": 3,
            "name": "Carl",
            "left": {
                "id": 7,
                "name": "Lee",
                "left": {
                    "id": 11,
                    "name": "Fate"
                }
            },
            "right": {
                "id": 8,
                "name": "Annie",
                "left": {
                    "id": 12,
                    "name": "Saber"
                }
            }
        },
        "right": {
            "id": 4,
            "name": "Tony",
            "left": {
                "id": 9,
                "name": "Candy"
            }
        }
    },
    "right": {
        "id": 2,
        "name": "right",
        "left": {
            "id": 5,
            "name": "Carl",
        },
        "right": {
            "id": 6,
            "name": "Carl",
            "right": {
                "id": 10,
                "name": "Kai"
            }        
        }
    }
}

假设id和name均不会重复，根据输入name找到对应的id
思路：用递归，参数为obj节点，而不是name或id。根据obj节点递归，从left到right或者反向也都可以。
代码：

function findIdByName(name) {
    var id;
    function find(obj){
        if(obj !=null){
            if(obj.name == name){
                id = obj.id;
            }
            find(obj.left);
            find(obj.right);
        }
    }
    find(tree);
    console.log(id);
}

假设id和name均不会重复，根据输入id找到对应的name
代码：

function findNameById(id) {
    var name;
    function find(obj){
        if(obj != null){
            if(obj.id == id){
                name = obj.name;
            }
            find(obj.left);
            find(obj.right);
        }
    }
    find(tree);
    console.log(name);
}

把这个对象中所有的名字以“前序遍历”的方式全部输出到console中
前序遍历：先输出该节点，然后输出他的左孩子，最后输出他的右孩子
思路：根据节点递归，先打印该节点，再递归左孩子，最后是右孩子
代码：

function getListWithDLR() {
    function con(obj){
        if(obj != null){
            console.log(obj.name);
            con(obj.left);
            con(obj.right);
        }
    }
    con(tree);
}

把这个对象中所有的名字以“中序遍历”的方式全部输出到console中，与上面类似
代码：

function getListWithLDR() {
    function con(obj){
        if(obj != null){
            con(obj.left);
            console.log(obj.name);
            con(obj.right);
        }
    }
    con(tree);
}

后序遍历就不用展示了

队列：先进先出
插入元素的那一端是队尾，删除元素的那一端是队头
百度IFE任务中，头和尾的方向自定义了
栈：先进后出
一般是从上往下压栈，上面为顶，下面为底
百度IFE任务中，顶和底的方向自定义了

当排序非 ASCII 字符的字符串（如包含类似 e, é, è, a, ä 等字符的字符串）。一些非英语语言的字符串需要使用 String.localeCompare。这个函数可以将函数排序到正确的顺序。

var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
items.sort(function (a, b) {
  return a.localeCompare(b);
});

var arr = [[10, 14], [16, 60], [7, 44], [26, 35], [22, 63]];

将上面的二维数组，按照每个元素中第二个数从大到小的顺序进行排序输出，输出结果应该为：

[[22, 63], [16, 60], [7, 44], [26, 35], [10, 14]]

var arr = [[10, 14], [16, 60], [7, 44], [26, 35], [22, 63]];
//将上面的二维数组，按照每个元素中第二个数从大到小的顺序进行排序输出，输出结果应该为
//用map函数生成一个新数组：[{14,0},{60,1},{44,2},{35,3},{63,4}]
var mapped = arr.map(function(el,i){
    //输出一个object对象，value为排序的数字的值，index为数字所在的数组在一维数组中的索引值
    //value:14,60,44,35,63
    //index:0,1,2,3,4
    return {value:el[1],index:i};
});
//比较新数组的每个对象的第一个value的值,从大到小排列，注意，sort是修改原数组
mapped.sort(function(a,b){
    return b.value - a.value;
})
//以新数组mapped的从大到小的顺序的index，来取出arr数组里的项，赋给新数组result
var result = mapped.map(function(ar){
    console.log(ar.index);
    return arr[ar.index];
})
console.log(result);

将下面的对象

var scoreObject = {
    "Tony": {
        "Math": 95,
        "English": 79,
        "Music": 68
    }, 
    "Simon": {
        "Math": 100,
        "English": 95,
        "Music": 98
    }, 
    "Annie": {
        "Math": 54,
        "English": 65,
        "Music": 88
    }
}

将其转为如下的二维数组：

var scoreArray = [
    ["Tony", 95, 79, 68],
    ……
];

这题做的不完善，先放上来：

function objToArr(obj){
    var newArr = [];
    for(var name in obj){
        var eveArr = [];
        eveArr.push(name);
        eveArr.push(obj[name]['Math']);
        eveArr.push(obj[name]['English']);
        eveArr.push(obj[name]['Music']);
        newArr.push(eveArr);
    }
    console.log(newArr);
}
objToArr(scoreObject);

有一个用来存储多级菜单数据的数组

var menuArr = [
    [1, "Area1", -1],
    [2, "Area2", -1],
    [3, "Area1-1", 1],
    [4, "Area1-2", 1],
    [5, "Area2-1", 2],
    [6, "Area2-2", 2],
    [7, "Area1-2-3", 4],
    [8, "Area2-2-1", 6],
];

编写一个函数，将其转为如下的对象：

var menuObject = {
    "1": {
        name: "Area1",
        subMenu: {
            "3": {
                name: "Area1-1"
            },
            "4": {
                name: "Area1-2",
                subMenu: {
                    "7": {
                        name: "Area1-2-3"
                    }
                }
            }
        }
    }
    ……
}

思路：递归，只要先实现单个值找后代，后面的就好办了。创建一个空对象。遍历数组，根据每个元素第三项的数字判断子对象对应的是哪个父对象，如果找到对应的父子对象，生成新对象的内容并赋值给空对象，同时对下级的subMenu对象递归赋值
代码：

function arrTurnObj(softNum = 0) {
    var newObj = new Object();
    for(var i in menuArr){
        if(menuArr[i][2] == softNum){
            newObj[menuArr[i][0]] = {
                'name': menuArr[i][1],
                'subMenu': arrTurnObj(menuArr[i][0])
            }
        }
    }
    return newObj;
}
console.log(arrTurnObj(-1));