JS处理数据

JS对数据的处理（数字，字符串，数组）

    Math.random();      |     生成一个[0:1) 的随机数 有0 无1
    Math.ceil(x)        |     对 数x 进行向上取整
    Math.floor(x)       |     对 数x 进行向下取整
    Math.round(x)       |     对 数x 四舍五入
    附： Math.floor(Math.random()*10);     可均衡获取 0 到 9 的随机整数。

// 数字
var data = Math.random()*10;        console.log("[0,10)的随机数: " + data)
    data = Math.ceil(data);         console.log("向上取整: " + data)
    data = Math.random()*(-5);      console.log("(-5,0]的随机数: " + data)
    data = Math.floor(data);        console.log("向下取整: " + data)
    data = (Math.random()-0.5)*10;  console.log("[-5,5)的随机数: " + data)
    data = Math.round(data);        console.log("四舍五入取整: " + data)

结果：

	.toLowerCase()      |     内容小写
    .toUpperCase()      |     内容大写
    .indexOf(searchvalue,fromindex)     检索字符串或数组 是否包含searchvalue，有则返回第一次出现的位置，没有就返回-1，  
                                        fromindex   可选，决定字符串的开始检索的位置   默认0 从头开始检索

    .lastindexOf()                      从后往前检索，返回第一次出现的位置（位置是从前往后的），    "aabbae".lastindexOf('a') 返回 4

    .match(regexp)                      字符串内检索指定的值，或找到一个或多个正则表达式的匹配。
                                        返回匹配成功的数组， 或者null

    .startsWith('Hi')                   检查字符串是否是以 'Hi' 开头            返回  true false
    .substring(beginIndex,endIndex)     返回字符串的子字符串 包括从beginIndex， 到endIndex（不包括）   

    .trim()             		|     用于删除字符串的头尾空格      兼容性(IE9+)

    .replace(regexp/substr,replacement)
                                        regexp/substr   子字符串或者regexp对象（正则表达式），即需要替换的数据
                                        replacement     替换成的 文本 或者 函数
                                        
    .split(separator,howmany)   |       字符串分割成数组，      
                                        separator  指定分割符（',' '|'等）    若separator 不指定，则每个字符都分割成数组 
                                        howmany 可选 指定分割后的数组长度，即分割成多少个数组，多余的部分会被舍弃

// 字符串
var Str = " How are you, Lovell? How are you, Lovell?   "
    console.log("转大写: "+Str.toLowerCase());
    console.log("转小写: "+Str.toUpperCase());

    console.log("检索字符串:" + Str.indexOf('o'))           //   2          从头开始检索,   返回字符所在位置索引值
    console.log("检索字符串:" + Str.indexOf('o',4))         //   10          从第5个字符‘a’开始检索 
    console.log("检索字符串:" + Str.indexOf('ok'))          //   -1         检索失败 
    console.log("检索字符串:" + Str.lastIndexOf('o'))       //   36         从尾往头检索,   返回从头往尾的位置索引值
    console.log("检索字符串:" + Str.lastIndexOf('o',4))     //   2          从第5个字符‘a’开始往前检索

    console.log(Str.match('o').index)                     //    2         检索字符串，返回索引值
    console.log(Str.match(/Lovell/g))                     //    ["Lovell","Lovell"]

    console.log(Str.startsWith('How'))                    //    false      检索开头   因为有‘ ’，
    console.log(Str.startsWith(' H'))                     //    true      

    console.log(Str.substring(21,))                       //    ' How are you, Lovell?   '       返回子字符串， 第22个字符到结束
    console.log(Str.substring(5,21))                      //    are you, Lovell?                 返回子字符串，包含5， 不包含21
    console.log(Str.trim())                               //    How are you, Lovell? How are you, Lovell?       去掉头尾空格

    console.log(Str.replace(/Lovell/g,'Nacy'))            //    ' How are you, Nacy? How are you, Nacy?   '  保留空格，Lovell 换成了Nacy

    console.log(Str.split('?'))                           //    [" How are you, Lovell", " How are you, Lovell", "   "]     字符串中间有两个‘？’ 返回3个数组
    console.log(Str.split('?',2))                         //    [" How are you, Lovell", " How are you, Lovell"]            设置返回数组长度为2, 自动舍去多余的部分

 	.length             	|     	返回数组长度
    .join(separator)        |     	将数组合并为字符串
                                  	separator    指定分隔符，  字符串内的内容之间的分隔符  默认 ''(没有)

    .shift()                |       移除数组第一个元素       返回值是移除的元素。

    .pop()                  |       移除数组最后一个元素     返回值是移除的元素。   

    .unshift(item1,item2)   |       数组的开头添加一个或多个元素        返回值是新的长度。

    .push(item1,item2)      |       数组的末尾添加一个或多个元素，      返回值是新的长度。

    .splice(index,howmany,"item1",...,"itemX")      添加或删除数组中的元素
                                                    index       规定从何处添加/删除元素
                                                    howmany     可选, 规定应该删除多少元素。必须是数字，但可以是 "0", 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
                                                    item1, ..., itemX   可选, 要添加到数组的新元素 

    .sort()                 |       对数组的元素进行排序。  排序顺序可以是字母或数字，并按升序或降序。   默认排序顺序为按数字，字母升序  数字在字母前面
                                        A.sort(function(a,b){return a-b});     //  数字和升序
                                        A.sort(function(a,b){return b-a});     //  数字和降序
    .reverse()              |       颠倒数组中元素的顺序 

// 数组
    // 拼接数组, 生成字符串
    var Arr = ["A","B","C","D"]
    console.log(Arr.join())                                  //    A,B,C,D          默认 拼接符','
    console.log(Arr.join('-'))                               //    A-B-C-D          指定 拼接符'-'

    // 移除元素
    var Arr = ["A","B","C","D"]
    console.log(Arr.shift())                                 //    A                移除数组第一个元素，并返回这个元素 
    console.log(Arr)                                         //    ["B", "C", "D"]
    var Arr = ["A","B","C","D"]
    console.log(Arr.pop())                                   //     D               移除数组最后元素，并返回这个元素
    console.log(Arr)                                         //     ["A", "B", "C"]

    // 添加元素
    var Arr = ["A","B","C","D"]
    console.log(Arr.unshift('1','2'))                        //     6               在数组 起始位置 添加新的元素，返回添加新数组的长度
    console.log(Arr)                                         //     ["1", "2", "A", "B", "C", "D"]
    var Arr = ["A","B","C","D"]
    console.log(Arr.push('E','F','G'))                       //     7               在数组 结束位置 添加新的元素，返回添加新数组的长度
    console.log(Arr)                                         //     ["A", "B", "C", "D", "E", "F", "G"]

    // 综合操作数组
    var Arr = ["A","B","C","D"]
    console.log(Arr.splice(2,2))                             //     ["C", "D"]      在第3个字符开始移除两个元素，返回移除被移除的数组，         只移除一个也是返回数组
    console.log(Arr)                                         //     ["A", "B"]
    var Arr = ["A","B","C","D"]
    console.log(Arr.splice(2,0,'1','2'))                     //     []              添加元素时，返回空数组
    console.log(Arr)                                         //     ["A", "B", "1", "2", "C", "D"]

    var Arr = ["A","B","C","D"]                              
    console.log(Arr.splice(2,1,'1','2'))                     //     ["C"]           添加删除元素一起操作，在第3个字符开始移除1个元素，并在同一位置添加新元素，返回移除后的数组
    console.log(Arr)                                         //     ["A", "B", "1", "2", "D"]

    // 数组排序
    var Arr = ["B","A",'1',"D","C",'2'] 
    console.log(Arr.sort())                                  //     ["1", "2", "A", "B", "C", "D"]      默认字母,数字升序，  数字在字母之前
    console.log(Arr.sort(function(a,b){return b-a}))         //     ["2", "1", "A", "B", "C", "D"]      数字倒序

    var Arr = ["A","B","C","D"] 
    console.log(Arr.reverse())                               //     ["D", "C", "B", "A"]                数组倒序

练习小题目：

1、用递归算法实现，数组长度为8且元素的随机数在5-30间不重复的值

    var arrOut = Array();                   // 输出的数组
    var arrAll = Array();                   // 总数组
    var end_num = 8;                        // 输出数组的长度
    var min = 5;                            // 随机数的最小值
    var max = 30;                           // 随机数的最大值
    var num = 0                             // 随机数
    function randomNumber(min,max){                         // 随机生成一个 [min:max] 的数   
        return parseInt((Math.random()*(max-min+1)) + min);      
    }
    num = randomNumber(min,max)
    randomArr(arrOut,arrAll,num);
    function randomArr(arrOut,arrAll,num) {
        if (arrAll.indexOf(num) === -1){                    // 检索 arrAll数组里面是否有 随机数 num， 没有就塞进 arrOut 和 arrAll 内
            arrOut[arrOut.length] = num;
            arrAll[arrAll.length] = num;
            if(arrAll.length >= max-min+1){                 // 当[min:max] 全部生成过后，退出函数，结束递归
                console.log(arrOut)
                console.log(arrAll);
                return
            }
        }
        if (arrOut.length >= end_num){                      // 当 arrOut 数组塞满end_num个之后，输出
            console.log(arrOut);
            if(arrAll.length < max-min+1){                  // 此时，若allAll没有全部填满，清空 arrOut 再次运行函数
                arrOut = Array();
                randomArr(arrOut,arrAll,num);
            }
        }
        else{                                               // 生成了重复的随机数num 则生成新的随机数，再次运行函数      
            num = randomNumber(min,max);
            randomArr(arrOut,arrAll,num);
        }
    }