JS基础知识总结2——JS字符串方法以及JS对象

知识点：
1.JS字符串方法；
2.JS的内置对象：String和Array；
3.数组的方法；
4.JS中常用排序；
5.Math对象；
6.Date对象。

一、JS字符串的方法

1.类型的强制转换
字符串类型和数字类型相互转化
①字符串类型的数字，转化为数字类型

parseInt("123")   //123

parseInt("98.8")   //98.8

②待转化的值是前数字后字符串，转化出其中的数字

parseInt("98￥")  //98

③数字类型转字符串类型

var a = 123;
a.toString();  //"123"

2.在字符串中检测字符的方法
（1）indexOf：若存在，返回字符串中检索指定字符第一次出现的位置；若不存在，返回-1。从左向右查找
①一个参数：参数为要检索的字符

var str = "abcdefa";
console.log( str.indexOf("a") );  //0

②两个参数：第一个参数为检索的字符，第二个为起始查找的索引位置。

var str = "abcdefa";
console.log(str.indexOf("a", 3));

（2）lastIndexOf：若存在，返回字符串中检索指定字符最后一次出现的位置；若不存在，返回-1。功能与indexof类似，从右向左查找。

var str = "abcdefa";
console.log(str.lastIndexOf("a"));   //6
console.log(str.lastIndexOf("a", 3));   //0

3.拼接字符的方法
（1）使用+拼接

var str = "abcdefa";
var m = "kljh";
console.log((m + str));  //kljhabcdefa

（2）使用concat拼接
①两个字符串拼接：

var str = "abcdefa";
var m = "kljh";
console.log(str.concat(m));  //abcdefakljh

②多个字符串拼接：如三个

var str = "abcdefa";
var m = "kljh";
var k = "123df";
console.log(str.concat(m).concat(k));  //abcdefakljh123df

4.字符的替换方法
replace:第一个参数是需替换的字符，第二个参数是替换后的值

var str = "abcdefa";
console.log(str.replace("f", 0));  //abcde0a

当直接使用replace方法时，只能替换字符串中相同字符中的一个。

var str = "abcdefa";
console.log(str.replace("a", 1));  //1bcdefa

5.查找字符方法
search：参数为查找的字符，返回的是字符的索引值，若没有此字符，返回-1

console.log(str.search("a"));   //0

6.ASCII值和字符之间的相互转化
（1）字符转化ASCII值

var s = "a";
//charCodeAt  指定索引位置字符的 Unicode 值  
console.log(s.charCodeAt(0));  //97

（2）ASCII值转化为字符

console.log(String.fromCharCode(97));//a

7.字符串的遍历
charAt：返回指定索引位置的字符
charCodeAt()：返回指定索引位置字符的 Unicode 值

var n = "abcdefgh";
for (var i = 0; i < n.length; i++) {
    console.log(n.charAt(i));
    console.log(n.charCodeAt(i));
}

for (var key in n) {
    console.log(n.charAt(key));
}

8.字符串转化为数组的方法
split ：将字符串转化为数组

var s1 = "abcdefg";
console.log(s1.split(""));  //(7) ["a", "b", "c", "d", "e", "f", "g"]

9.字符串里面的截取方法
slice：参数是起始索引和结束索引，索引值取小不取大
substr：参数是起始索引值和截取的长度
substring：参数是起始索引和结束索引，索引值取小不取大

    var k1 = "abcdefgh";
    console.log(k1.slice(0, 3));  //abc 
    console.log(k1.substr(0, 4));  //abcd 
    console.log(k1.substring(0, 4));  //abcd 

10.字符串去空格的方法
trim()：默认只去除一个空格

var user = " a b c d e f ";
console.log(user.trim());  //a b c d e f

11.大小写字符串转化

var s2 = "ABCdefg";
console.log(s2.toLocaleLowerCase());  //abcdefg
console.log(s2.toLowerCase());  //abcdefg
console.log(s2.toUpperCase());  //ABCDEFG
console.log(s2.toLocaleUpperCase());  //ABCDEFG

二、JS的内置对象：String和Array

1、String对象：也是字符串

var s1="abc";
console.log(s1);//abc

（1）声明一个新的字符串，new创建一个实例

    var str=new String(s1);
    console.log(str);
    var s2=new String("abcdefg");
    console.log(s2);

（2）获取字符

var s2=new String("abcdefg");
console.log(s2[0]);  //a

（3）检测类型

var s1="abc";
var s2=new String("abcdefg");
console.log(typeof s2);   //object
console.log(typeof s1);   //string

（4）常规定义的字符串与使用new String创建的字符串区别
常规定义的字符串是原始值，而使用new String创建的字符串是对象型

var m="abc";
var m1=new String(m);
console.log(m==m1);//true
console.log(m === m1);//false m为string，m1为object

（5）检测类型，返回值是true/flase

console.log(m1 instanceof String); //true

2.Array(数组）
（1）创建新数组

var arr = new Array();
console.log(arr);
//简单写法
var array = [];
console.log(array);

（2）数组赋值
注意参数的个数，写一个值表示数组的长度，写多个值才是数组里面的值

    var arr1 = new Array(1);
    console.log(arr1);//数组的长度是1，并且为空数组
    var arr2 = new Array(1, 2, 3, 4, 5);
    console.log(arr2);//输入多个值

（3）数组取值：按照key：value

console.log(arr2[0]);
console.log(arr2[1]);
console.log(arr2[2]);
console.log(arr2[3]);

（4）数组的某个索引位赋值

    arr2[0] = "a";
    console.log(arr2);

（5）数组属性：length

var s = [1, 2, 3, 4, 5];
console.log(s.length);  //5

三、数组的方法
1.join:将数组的每一位进行拼接 ,参数是符号。将数组转化为字符串

 var s = [1, 2, 3, 4, 5];
 console.log(s.join(""));//12345

2.数组翻转的方法
翻转之后对原数组有影响

console.log(s.reverse());

3.数组的截取方法
slice,splice
slice:返回截取的值,参数是索引,截取后对原数组没有影响

console.log(s.slice(0, 3));//543

splice ：参数是起始索引和截取长度，返回值是截取的结果，对原数组有影响

console.log(s.splice(0, 3));//543

4.拼接数组：concat

var a1 = [1, 2, 3];
var a2 = [4, 5, 6];
console.log(a1.concat(a2));//[1,2,3,4,5,6]

5.拷贝数组到另一位置
三个参数为放的位置、 起始复制位置、终止复制位置

var str = ["a", "b", "c", "d"];
str.copyWithin(2, 0, 1);
console.log(str);// ["a", "b", "a", "d"]

6.every() 检测数组里面的每一个值 是否满足条件
返回值true/false

var array = [2, 6, 3];
console.log(array.every(function (currentValue, index, arr){
    return currentValue % 2 == 0;
}));
//false
 

7.数组的过滤

 var arr2 = [1, 2, 3, 4, 5, 6];
    console.log(arr2.filter(function (cvalue, index) {
        console.log(this);
        return cvalue % 2 == 0;
    }, array));

8.find：根据条件找满足条件的
检测每一个元素值，当遇到满足条件的一个值，直接返回，不会再执行

var t1 = [1, 2, 3, 4, 5];
console.log(t1.find(function (current, index){
    return current % 2 == 0;
}));
//2

9.findIndex:根据条件 ,返回满足条件的第一个元素值的索引

var t1 = [1, 2, 3, 4, 5];
console.log(t1.findIndex(function (current, index) {
    return current % 2 == 0
}));
//1

10.检测数组里面是否包涵某个值
返回值：true/false

var t2 = [1, 2, 3, 4, 5, 6, 7];
 console.log(t2.includes(5));//true

11.检测当前的对象是否是数组
返回值：true/false
isArray() 是数组类对象的方法
t2.isArray() 会报错：isArray is not a function

 console.log(Array.isArray(t2));//true

12.映射方法：map
map:将一个数组映射为一个新的数组

 var t2 = [1, 2, 3, 4, 5, 6, 7];
 console.log(t2.map(function (current, index) {
        return current * 2;
    }));
    //[2, 4, 6, 8, 10, 12, 14]

13.累计方法
totle是数组的第一位
reduce 从左-右累计
reduceRight 从右-左 累计

var t3 = [2, 1, 3, 5, 4];
console.log(t3.reduce(function (totle, current, index) {
    console.log(totle, current);
    return totle + current;
}));
console.log(t3.reduce(function (totle, current, index) {
    console.log(totle, current);
    return totle * current;
}));

console.log(t3.reduceRight(function (totle, current) {
    console.log(totle, current);
    return totle * current;
}));

四、JS中常用排序
1.冒泡排序

var array = [1, 9, 7, 8, 2, 5, 3, 6, 4];
    function bubbleSort(arr) {
        if (arr.length <= 1)return arr;
        if (Array.isArray(arr)) {
            var temp;
            for (var i = 0; i < arr.length; i++) {
                for (var k = 0; k < arr.length - 1; k++) {
                    if (arr[k] > arr[k + 1]) {
                        //交换位置
                        temp = arr[k + 1];
                        arr[k + 1] = arr[k];
                        arr[k] = temp;
                    }

                }
            }
            console.log(arr);//[1,2,3,4,5,6,7,8,9]
        }
    }
    console.time();
    bubbleSort(array);
    console.timeEnd();

2.快速排序

var array1 = [1, 9, 2, 7, 8, 2, 5, 3, 6, 4];
    function quickSort(arr) {
        if (arr.length <= 1) return arr;
        if (Array.isArray(arr)) {
            var center = parseInt(arr.length / 2);
            //在取中间值的时候 得让原数组发生变化
            var centerNum = arr.splice(center, 1);//使用截取去掉中间值

            var left = [];
            var right = [];
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] <= centerNum) {
                    left.push(arr[i]);
                }
                else {
                    right.push(arr[i]);
                }
            }
            //使用递归
            return quickSort(left).concat(centerNum).concat(quickSort(right));
        }
    }
    console.time();
    console.log(quickSort(array1));//[1,2,3,4,5,6,7,8,9]
    console.timeEnd();

3.插入排序

var array2 = [1, 9, 7, 8, 2, 5, 3, 6, 4];
    function insertSort(arr) {
        if (!Array.isArray(arr)) return;
        for (var i = 1; i < arr.length; i++) {
            var nowNum = arr[i];  //记录当前的值
            var prevIndex = i - 1;  //前面的索引
            //进行判断
            while (prevIndex >= 0 && arr[prevIndex] < nowNum) {
                //交换位置
                arr[prevIndex + 1] = arr[prevIndex];
                prevIndex--;
            }
            arr[prevIndex + 1] = nowNum;
        }
        console.log(arr);//[9,8,7,6,5,4,3,2,1]
    }
    insertSort(array2);

4.选择排序

var array3 = [3, 1, 9, 7, 8, 2, 5, 6, 4];
    function selectSort(arr) {
        if (!Array.isArray(arr)) return;
        //选择性排序
        var temp;
        for (var i = 0; i < arr.length - 1; i++) {
            //默认记录最小索引
            var minindex = i;
            for (var k = i + 1; k < arr.length; k++) {
                //比对  和最小索引的值
                minindex = arr[k] > arr[minindex] ? k : minindex;
            }
            //交换位置
            temp = arr[i];
            arr[i] = arr[minindex];
            arr[minindex] = temp;
        }
        console.log(arr);//[9,8,7,6,5,4,3,2,1]
    }
    selectSort(array3);

五、Math对象
1.固定值

console.log(Math.E);//2.718281828459045
console.log(Math.PI);//3.141592653589793

2.取绝对值

console.log(Math.abs(-1));//1

3.三角函数值
参数不能直接写角度，需转化为弧度
弧度= 角度 * Math.PI / 180;
角度 = 弧度 * 180 / Math.PI;

    console.log(Math.cos(45*Math.PI/180));//0.7071067811865476
    console.log(Math.sin(45*Math.PI/180));//0.7071067811865475
    console.log(Math.tan(45*Math.PI/180));//0.9999999999999999
	反三角函数值：
    console.log(Math.acos(45*Math.PI/180));//0.6674572160283838
    console.log(Math.asin(45*Math.PI/180));//0.9033391107665127
    console.log(Math.atan(45*Math.PI/180));//0.6657737500283538

4.向上或向下取整

    console.log(Math.floor(4.9));//4
    console.log(Math.ceil(4.1));//5

5.四舍五入

    console.log(Math.round(4.4));//4
    console.log(Math.round(4.5));//5

6.返回最大最小值

console.log(Math.max(1, 2, 3, 4));//4
console.log(Math.min(1, 2, 3, 4));//1

7.随机数方法
0-1,取小不取大

  console.log(Math.random());

8.幂方法

console.log(Math.pow(2, 3));//8

9.开平方方法

console.log(Math.sqrt(4));//2

10.找出一个数组里面的最小值

var str=[7,3,1,2,4,5,0,8];
console.log(Math.min.apply(null, str));//0

六、Date对象
1.创建Date对象

var time = new Date();
console.log(time);//输出中国标准时间

2.Date方法
set** 设置； get**获取； to **转化
设置时间：

var nowtime = new Date();
    nowtime.setDate(12); //设置日期
    //nowtime.setFullYear(2021,2,12); //  使用该方法，输出月份为设置值+1
    nowtime.setYear(2021);//设置年
    nowtime.setMonth(2);//设置月，实际+1
    nowtime.setHours(20);//设置小时
    nowtime.setMinutes(59);//设置分钟
    nowtime.setSeconds(59);//设置秒
    nowtime.setMilliseconds(999);//设置毫秒
    console.log(nowtime);
    
    //设置时间，同样设置时月-1
    //var gotime=new Date(2020,5,12,15,0,0);
    //下面写字符串的格式时直接写当前设置时间
    var gotime = new Date("2020-9-12 15:00:00");
    console.log(gotime.toLocaleString());//2020/9/12 下午3:00:00

转换时间：

    console.log(nowtime.toDateString());//Sat Jun 12 2021
    console.log(nowtime.toISOString());//获取的时间是iso时间，与中国时间-8时差
    console.log(nowtime.toLocaleDateString()); //2021/3/12
    console.log(nowtime.toLocaleString());//2021/3/12 下午8:59:59
    console.log(nowtime.toLocaleTimeString());//下午8:59:59
    console.log(nowtime.toTimeString());//20:59:59 GMT+0800 (中国标准时间)
    console.log(nowtime.toUTCString());//Fri, 12 Mar 2021 12:59:59 GMT 同样减8个时差

获取时间：

var stime = new Date();
    console.log(stime.getFullYear());//2020
    console.log(stime.getYear());//120  从1900年开始计算的
    console.log(stime.getMonth());//5  使用的时候+1
    console.log(stime.getDate());//日
    console.log(stime.getDay());//周几，0表示周日
    console.log(stime.getHours());//小时
    console.log(stime.getMinutes());//分钟
    console.log(stime.getSeconds());//秒
    console.log(stime.getMilliseconds());//毫秒
    console.log(stime.getTime());//当前时间到1970年1月1日的总毫秒数