day17_字符串，数组的常规方法，字符串常见的面试题，简单排序算法

字符串方法

名称,功能,返回值，是否改变原值

1. 字符串拼接a.concat(b).concat(c)…可以连续拼接多个

2. 查找字符 str.indexof

1. 单个参数，默认从0开始直接查找字符，字符串也可以遍历，和数组方法一样
   找到返回索引，失败返回-1
2. 两个参数：第二个参数表示起始位置
3. 可以查找字符串，按照字符的方法返回起始索引
4. lastindexof:从右往左找，但是字符的索引不变，还是从左往右0开始

3. str.charAt:根据索引返回对应字符,也可以通过索引查找字符

charCodeAt() 把字符转换为ascii码
String.fromcharCode: 把ascii码转换为字符
eg:

  var str = "abcdefg";
    console.log(str.charCodeAt(0));//97
    //怎么把ascii 值转化为 字符   fromCharCode
    console.log(String.fromCharCode(97));//a

4. str.substr: 两个参数：开始位置，截取长度；

返回值为截取字符，原字符串没有影响

str.substring: 两个参数都是索引（从0开始），对 原字符串没有影响

5. str.replace的返回值为替换后的字符串，只能替换一个，不改变原字符串

多个字符替换需要使用正则

  var str="a,b,c,def,ga";
    console.log(str.replace("a", "m"));
    console.log(str);

6. str.search:只有一个参数，找字符位置返回索引

    var str="a,b,c,def,ga";
    console.log(str.search('a'));

结果返回0

7. str.slice:起始索引——结束索引的字符串

slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分。（取小不取大）

   //slice
    var str="abcdefga";
    console.log(str.slice(0,3));//abc
        a=[1,2,3];
    console.log(a.slice(1, 2));//[2]

str.split:以指定字符分割，字符串转数组

   var str="a+b+c+def+ga";
    //split  将字符串转化为数组
    console.log(str.split("+"));// ["a", "b", "c", "def", "ga"]

8.str. length 返回字符串长度

9. 大小写转换

toLowerCase, toUpperCase
toLocalLowerCase, toLocalUpperCase:转为本地方式（浏览器语言）

数组:

1. new:实例化——将抽象转化为具体对象的过程、新建对象（初始化对象）

2. Array:是js的内置对象

3. 有唯一属性：length

4. 数组检测类型时显示object的原因：原型链中数据类型顶级都是object,子类继承父类，所以里面存值对类型没有约束

    arr[0]=1;
    arr[1]="a";
    arr[2]=null;
    arr[3]={};
    arr[4]=true;
    arr[5]=undefined;
    arr[6]=function(){};
    console.log(arr[0]);//[1, "a", null, Object, true, undefined, function]

5. 数组的赋值和取值

除了上面使用的方法外
第二种方式直接赋值，如果是数字，一个参数代表长度，多个才显示内容，长度自己计算
其他类型都是直接显示内容
var arr=new Array(1);//[]
var arr=new Array(1,2);//[1,2]
var arr=new Array({});//[Object]
简化声明：var a=[];

数组的方法(map和reduce面试重点)

a) a.concat(b):合并数组,返回新的数组，不改变原有数组的值

    var  a=[1,2,3,4];
    var b=[4,5,6];
    //concat  也可以合并数组  返回新的数组
    console.log(a.concat(b));//[1, 2, 3, 4, 4, 5, 6]
    console.log(a);//[1, 2, 3, 4]
    console.log(b);// [4, 5, 6]

b) filter:过滤：里面具体的函数根据需要写，过滤掉其他不满足条件的数

对原数组无影响
不知道函数调用参数时可以实践查看
eg:

var  a=[1,2,3,4];
    console.log(a.filter(function (a,b,c) {
        console.log(a, b, c);
    }));

从浏览器的输出情况可以看到：共有3个参数：值，索引，数组，且函数又返回值

（一般参数为：值，索引，数组）

c) foreach,也是有回调函数，没有返回值，遍历数组，跟for循环相似，只是对里面的值操作,可以操作到原数组

eg:每个元素*2

d) indexof：返回索引或-1

e) join:数组转化为字符串，以指定方式拼接

   var  a=[1,2,3,4];
    console.log(a.join("")) ;// 1234

f) map:相当于遍历，映射一个新的数组（可以通过返回值映射新数组），不会影响到原数组

  var  a=[1,2,3,4];
    var b=a.map(function (val, index, arr) {
        return val*val;
    })
    console.log(b,a);//[1, 4, 9, 16] [1, 2, 3, 4]

g) slice:返回截取值，对原数组无影响，两个参数指明索引的起始和终止位置

slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。使用 start（包含） 和 end（不包含） 参数来指定数组提取的部分。（取小不取大）

var  a=[1,2,3,4];
    console.log(a.slice(1, 3));//[2, 3]
     console.log(a);//[1, 2, 3, 4]

h) splice:对原数组有影响，两个参数的含义是：索引+截断长度

 var  a=[1,2,3,4];
    console.log(a.splice(0, 3));//[1,2,3]
    console.log(a);//[4]

i) 追加：a.push:向后追加返回数组长度；a.unshift:向前追加，返回数组长度

 var  a=[1,2,3,4];
    a.push(9)
    console.log(a);//[1, 2, 3, 4, 9]

j) 删除：a.shift:数组前删；a.pop:数组后删，删除中间元素用splice:索引+截断长度

删除中间元素

  var  a=[1,2,3,4];
    a.splice(1, 1);//截取索引1指向的元素，对原数组有影响
    console.log(a);//[1, 3, 4]

k) reverse: 反转，对原数组有影响

l) 排序:a.sort()

默认升序，对原数组有影响；如果想降序，在函数里改为n2-n1为降序

 var b=[2,1,4,3,6,5];
    b.sort(function (n1,n2){
        return n1-n2;
    });
    console.log(b);//[1, 2, 3, 4, 5, 6]

m) 检测数组里的值：a.some(function(){}),返回true或false

var b=[2,1,4,3,6,5];
    console.log(b.some(function (val, index, arr) {
        return val == 11;
    }));
    //false

n) 累加器：reduce

total初始值为数组第一个元素，current初始值为数组第二个元素
对于空数组不执行回调函数

eg:计算1-100的和

8. 进程由多个线程组成，js为单线程

问题

slipt的用法

s = "12222345";
console.log(s.split("2"));//["1", "", "", "", "345"]
sr="|h|e|l|l|o";
console.log(sr.split("|"));//["", "h", "e", "l", "l", "o"]

三种简单排序算法（快排面试重点）

1.冒泡排序

实现思路如下，使用两个for循环，控制冒泡趟数（数组长度-1）和一趟比较次数，每趟冒泡会将最大值或最小值冒泡至最顶端

 var arr = [3, 2, 0, 1, 7, 5, 4, 6, 9, 8];
    function maopao(array) {
        if (array.length == 1) {
            return array;
        }
        var temp;
        for (var i = 0; i < array.length - 1; i++) {
            for (var k = 0; k < array.length - i - 1; k++) {
                if (array[k] < array[k + 1]) {
                    temp = array[k];
                    array[k] = array[k + 1];
                    array[k + 1] = temp;
                }
            }
        }
        return array;
    }
    console.time();//测试运行时间
    console.log(maopao(arr));// [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    console.timeEnd();

2.快速排序

找到中间值，以中间值分为左数组和右数组，左数组右数组又找到中间值继续划分左右，递归调用，其中取中间值使用splice(索引，个数）

  var arr = [3, 2, 0, 1, 7, 5, 4, 6, 9, 8];
 function quickSort(array) {
        if (array.length <= 1) {
            return array;
        }
        var center = array.splice(parseInt(array.length / 2), 1);
        var left = []; //相对于中间值  左边放  右边放
        var right = [];
        for (var i = 0; i < array.length; i++) {
            if (array[i] < center) {
                left.push(array[i]);
            }
            else {
                right.push(array[i]);
            }
        }
        return quickSort(left).concat(center).concat(quickSort(right));
    }
    console.time();
    console.log(quickSort(arr));
    console.timeEnd();

选择排序

默认第一个为最小值，如果之后遇到了比他更小的值则交换位置（或先缓存，比较结束后在交换位置）

  var arr = [3, 2, 0, 1, 7, 5, 4, 6, 9, 8];
  
 function selectSort(array){
        if(array.length<=1)
        {
            return array;
        }
        
        //默认一个值  数组里面第一个
        for(var i=0;i<array.length;i++)
        {
            var temp;
            for(var k=i+1;k<array.length;k++)
            {
                if(array[k]>array[i])
                {
                    temp=array[i];
                    array[i]=array[k];
                    array[k]=temp;
                }
            }

        }
        return array;
    }
    console.time();
    console.log(selectSort(arr));
    console.timeEnd();

字符串，数组面试题

1. 找到最长的字符（split+快排）

因为字符串中相邻单词以空格隔开所以使用split将字符串分隔为单个字符串，然后使用快速排序选出长度最大单词

 var st = "The quick brown fox jumped bcaked jumped abscefg over the lazy dog 15625765675276";
    function showDanci(str) {
        var arr = st.split(" ");
        var temp = arr[0];
        for (var i = 1; i < arr.length; i++) {
            if (temp.length < arr[i].length) {
                temp = arr[i];
            }
        }
        return temp;
    }
    console.log(showDanci(st));

2. 数组去重 注意要 k - -

选择排序的应用，splice(索引，删除长度)；
k–是为了避免有连续多个重复出现的数字时会跳过其中一些索引

    var arr = [1, 1, 2, 3, 4, 3, 5, 5, 6, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9];
    function moveNumber(array) {
        for (var i = 0; i < array.length - 1; i++) {
            var temp = array[i];
            for (var k = i + 1; k < array.length; k++) {
                if (temp == array[k]) {
                    array.splice(k, 1);
                    k--;//为了遍历到所有元素，即使数组索引更新后也能遍历到所有元素
                }
            }
        }
        return array;
    }
    console.log(moveNumber(arr));

3. 字符串翻转（两种方法）

方法一：jion将字符串转化为数组再将数组倒置再将数组转化为字符串

    var str = "abcdefghi";
    console.log(str.split("").reverse().join(""));

方法二：从后往前输出单个字符

var str = "abcdefghi";
    var s = "";
    for (var i = str.length - 1; i >= 0; i--) {
        s += str.charAt(i);
    }
    console.log(s);

4. 找到出现最多的字符并统计个数

1. 先将字符串去重后，转换为数组并保存在ss变量中，for in循环遍历原字符串，通过索引查找值str.charAt(index)，记录每个元素出现的次数，将ss[i]和对应字符出现的次数存放在二维数组中[ss[i],count];

2. 定义临时变量初值为1，记录出现次数最大的元素个数，即list[i][1]相同的个数

3. 比较list二维数组中count的大小，如果当前元素的count值大于下一元素的count值则删除下一元素即splice(i+1,1);否则删除当前元素splice(i,1),若相等临时变量加1，i++进行下一元素的比较，当数组长度小于等于相等临时变量时退出循环

4. 输出统计结果

   var str1 = "cccccccccasdfssaaasasasasaadddddddd";
    function findChar(str) {
        var ss = moveNumber(str.split(""));
        /*[a,c,f,h]*/
        var list = [];
        for (var i = 0; i < ss.length; i++) {
            var count = 0;
            for (var index in str) {
                if (ss[i] == str.charAt(index)) {
                    count++;
                }
            }
            list.push([ss[i], count]);
        }
        var tong = 1;
        for (var i = 0; i < list.length; i++) {
            if (list.length <= tong)break;
            if (list[i][1] > list[i + 1][1]) {
                list.splice(i + 1, 1);
                i--;
            }
            else if (list[i][1] < list[i + 1][1]) {
                list.splice(i, 1);
                i--;
            }
            else {
                tong++;
            }
        }
        return function () {
            var strlist = "";
            for (var i = 0; i < list.length; i++) {
                strlist += list[i][0] + "---" + list[i][1] + "个"
            }
            return strlist;
        }

    }
    console.log(findChar(str1)());

5. 阶乘

递归

    function jiecheng(n) {
        if (n <= 1) {
            return 1;
        }
        return n * jiecheng(n - 1);
    }
    console.log(jiecheng(5));//120

6. 判断质数

元素在2~根号下本身的范围内没有因数则说明该数为质数

  function zhishu(x){
       var s ="";
       for (var i = 2; i <=Math.floor(Math.sqrt(x)) ; i++) {
           if (x % i === 0) {
               s ="合数";
           }
           else {
               s = "质数";
           }
       }
       return s;
   }
   console.log(zhishu(9));//合数