数组的方法

  • 使用new Array这种方式创建数组的时候,有一个很大的缺陷,不同的参数个数会导致的行为不同 无参数时,返回一个空数组

var arr=new Array(); 创建一个空数组并赋值给变量arr 参数为单个正整数表示的时创建的数组的长度,每个值为空的数组元素 new Array(2) // [ empty x 2 ] 参数为多个时,所有参数都是返回的新数组的成员

new Array(1, 2) // [1, 2]  等见于使用字面量来创建数组,里面有两个数组元素分别是1和2
new Array('a', 'b', 'c') // ['a', 'b', 'c']

因为Array对象作为构造函数创建数组时行为很不一致,所以不推荐使用这种方式来生成新的数组,推荐直接使用字面量的方式创建数组

检测是否为数组的方法

  • Array.isArray(参数)方法返回一个布尔值,表示参数是否为数组

    var arr = [1, 2, 3];
    
    typeof arr // "object"
    Array.isArray(arr) // true

    这个方法是h5新增的方法,可以祢补typeOf的不足,ie9以上版本支持

  • instanceof 运算符,他可以用来检测是否为数组

    var arr=[];
    var obj={};
    console.log(arr instanceof Array);
    console.log(obj instanceof Array);

    函数案例,翻转数组和检测数组结合,for循环遍历数组中的元素倒序的放入一个新的数组中

    function reverse(arr){
        var newArr=[];
        if(Array.isArray(arr)){
        for(var i=arr.length-1;i>=0;i--){
          newArr[newArr.length]=arr[i];
        }
        return newArr;
        }else{
            return "你穿的参数不是一个数组"
        }
        
    }
    console.log(reverse(1,2,3));

添加删除数组中元素的方法

push

Push()方法用于在数组的最后面添加一个或多个元素,并返回添加新元素后的数组长度。

注意:该方法会改变原数组

参数为要添加进去的新元素,一个或多个

var arr = [];

arr.push(1) // 1  参数为要添加进去的新元素
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]
pop

pop()方法用于删除数组的最后一个元素,并返回该元素。

注意:该方法会改变原数组

没有参数,一次只能删除一个数组元素

var arr = ['a', 'b', 'c'];

arr.pop() // 'c'
arr // ['a', 'b']

空数组使用pop方法不会报错,而是返回undefined.

[].pop() // undefined

pushpop结合使用,就构成了“后进先出”的结构

shift

shift()方法用于删除数组的第一元素。并返回该元素。

注意在;该方法会改变原数组

没有参数,一次只能删除一个数组元素

var a = ['a', 'b', 'c'];

a.shift() // 'a'
a // ['b', 'c']
unshift

unshift()方法用于在数组的最前面添加一个或多个元素,并返回添加新元素后的数组长度。

注意:该方法会改变原数组。

参数为要添加进去的新元素,一个或多个

var arr = [ 'c', 'd' ];

arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

concat

作用:用于多个数组合并 返回值:追加数据后的新数组 ,原数组不变

如果参数是数组,它将参数数组的成员拆开,将里面的每一个元素添加到数组的后面,返回一个新的数组,原数组不变

如果参数是单个数据,直接追加到数组的后面,返回一个新的数组,原数组不变

var arr=[1,3];
arr.concat({a:1,b:2},{name:"66"});  // [1,3,{a:1,b:2},{name:"66"}]

map

格式:数组.map(function(item[, index,arr]){})

这个函数会根据数组里有多少个元素就循环执行参数函数多少回

作用:将数组的元素依次传入参数函数(回调函数),在参数函数内对数组的元素进行操作,然后将每次循环操作后的元素组成一个新的数组返回 不会改变原数组

返回值:是一个新的数组,新数组的长度一定和原始数组的长度一样

var arr=[1,true,3,'hello',7];
var newArr=arr.map(function(item){
    return item+1;
})
console.log(newArr); // [2, 2, 4, "hello1", 8] 数据类型转换了

map方法的接受一个函数作为参数,该函数调用时,map()方法向它传入三个参数,分别是 当前的成员 当前的位置 和 数组本身

map()方法可以接受第二个参数,绑定参数函数(回调函数内部)的this变量

(map的底层封装(工作原理):1 准备一份新的数组 2遍历原始数组,分别执行函数 3:把每次函数执行的返回值放到新的数组里 4:把新的数组当做map的返回值给出来)

forEach

forEach方法不返回值,只是用来操作数据,所以,如果遍历数组的目的是为了得到返回值,那么使用map()方法,否则使用forEach()方法

这个函数会根据数组里有多少个元素就循环执行多少回

这个函数每一次执行的时候,item分别的是数组里的每一个元素,index分别是数组里的每一个元素的索引,arr每一次都是原始数组

var arr=[1,2,3,45,7];
arr.forEach(function(item,index,arr){
 	console.log(item,'-----',index,'-----',arr)
})
  • forEach()方法可以接受第二个参数,绑定参数函数的this变量

var arr=[1,true,3,'hello',7];
var newArr=[];
arr.forEach(function(item,index,arr){
 //  this.push(item);//按正序将数组arr的元素推送到空数组中
    newArr.unshift(item);
 // this.unshift(item); //颠倒数组到一个新的数组里
},newArr)
console.log('新数组',newArr)
console.log('原数组',arr)
//统计数组中各个元素出现的次数
var a=[2,34,'7',true,'7','7']
var obj={};
a.forEach(function(item,index){
    if(obj[a[index]]){
        obj[a[index]]++
    }else{
        obj[a[index]]=1; 
    }
})
console.log(obj);   //{2: 1, 7: 3, 34: 1, true: 1}

注意:map和forEach无法中断执行,总是会将所有成员遍历完,如果希望符合某种条件时就中断遍历,要使用for循环

filter

作用:filter方法用于过滤数组成员,将满足条件的成员组成一个新的数组返回

他的参数是一个函数,所有数组的成员依次执行该函数,将返回结果为true的原数组中的成员组成一个新的数组返回

该方法不会改变原数组

var arr=[1,3,45,64,642,22,4]
var newArr=arr.filter(function(item,index,arr){
    return item>10
})
console.log(newArr);// [45, 64, 642, 22]
//返回数组的索引是偶数的位置上的元素
var arr=[1,3,45,64,642,22,4]
var newArr=arr.filter(function(item,index){
    return index%2==0
})
console.log(newArr);// [1, 45, 642, 4]

splice

作用:删除原数组中的一部分成员 返回值:被删除的数组元素 直接操作原数组

格式1: 数组.splice(开始索引,n个)

从开始索引的,删除n个元素

如果只提供一个参数,第二个参数不写则表示直接到末尾等同于将原数组在指定位置拆分成了两个数组

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

格式2: 数组.splice(开始索引,n个,替换数据1,替换数据2….)

将替换的数据按照书写的顺序插入到你截取得位置,从哪个索引开始删除,替换数据的第一个就插入到哪个位置

var a=[1,2,3,4];
a.splice(2,0,'新来的');      //[]
a;                          //[1,2,"新来的",3,4]
// 数组去重
var arr=[1,true,1,3,3,'hello',7,7];
for(var i=0;i<=arr.length-1;i++){
  
    for(var j=i+1;j<=arr.length-1;j++){
        if(arr[i]===arr[j]){
            console.log(arr[i],arr[j])
            arr.splice(j,1);
            j--;

        }
    }
}

console.log(arr);  //[1, true, 3, "hello", 7]
var arr=[1,true,1,3,3,'hello',7,7];
var newArr=[];
arr.forEach(function(item,index){
    if(newArr.indexOf(item)===-1){
        newArr.push(item)
    }
})
console.log(newArr); //[1, true, 3, "hello", 7]

slice

作用:获取数组中的一部分元素,返回一个新的数组,原数组不改变

格式:数组.slice(开始索引,结束索引) 包前不包后

返回值:从数组中获取的元素组成的新数组,如果在原数组中没有获取元素则返回一个空数组

第二个参数可以不写,表示从开始索引一直返回到原数组的最后一个元素

var arr=[1,2,3,45,7];
console.log(arr.slice(1,3),'------',arr);   // [ 2, 3] -------- [1, 2, 3, 45, 7]
console.log(arr.slice(1),arr);  // [2, 3, 45, 7] --------- [1, 2, 3, 45, 7]

参数可以是一个负整数,表示倒数计算的第几个位置,表示 length+负整数

数组排序

reverse翻转数组

reverse方法用于颠倒排列数组元素,返回改变后的数组。

注意:该方法会改变原数组

var a = ['a', 'b', 'c'];

a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]
  • 数组排序(冒排序,由小到大)

sort

作用:Sort方法对数组成员进行排序,默认是按字典ASCII码的顺序排序,

返回值:排序后原数组

直接操作原数组

[11, 101].sort()
// [101, 11]     
['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']

[4, 3, 2, 1].sort()
// [1, 2, 3, 4]

[10111, 1101, 111].sort()
// [10111, 1101, 111]
返回结果有问题,对个位数值没有问题,超过个位的一些数组会有问题

想要让解决上述的问题,可以传入一个函数作为参数

[10111, 1101, 111].sort(function (a,b) {
 return a - b;    //升序的顺序排列
})
// [111, 1101, 10111]

sort的参数函数本身接受两个参数,表示进行比较的两个数组成员。如果该函数的返回值大于0,将第一个成员排在第二个成员后面;其他情况下,都是第一个元素排在第二个元素的前面。

[10111, 1101, 111].sort(function (a,b) {
 return b - a;    //降序的顺序排列
})
//[10111, 1101, 111]
[
  { name: "张三", age: 30 },
  { name: "李四", age: 24 },
  { name: "王五", age: 28  }
].sort(function (o1, o2) {
  return o1.age - o2.age;
})

// [
//   { name: "李四", age: 24 },
//   { name: "王五", age: 28  },
//   { name: "张三", age: 30 }
// ]

返回给定元素在数组中的索引号

indexOf

indexOf方法返回给定元素在数组中第一次出现的index索引号,如果在数组中没有找到该元素则返回-1

从数组的前面开始找(正向查找)

var a = ['a', 'b', 'c'];

a.indexOf('b') // 1
a.indexOf('y') // -1

indexOf方法还可以接受第二个参数,表示从哪一个索引开始向后查找

['a','b','c'].indexOf('a',1) //-1
lastIndexOf

lastIndexOf方法返回给定元素在数组中最后一次出现的位置,如果在数组中没有找到该元素则返回-1

从数组的后面开始找 ,注意:数组的索引依然是从前面第一位开始为0,1,2,3…(正常的索引)

lastIndexOf方法还可以接受第二个参数,表示从哪一个索引开始向前查找

var a = [2, 5, 9, 2];
a.lastIndexOf(2) // 3
a.lastIndexOf(7) // -1

注意这两个方法不能用来检索NaN的位置,即他们无法确认数组中是否包含NaN

[NaN].indexOf(NaN) // -1
[NaN].lastIndexOf(NaN) // -1

这是因为这两个方法内部,使用严格相等运算符(===)进行比较,而NaN是唯一一个不等于自身的值

重点案例,数组去重

案例分析:

目标将数组中的不重复的元素取出来,重复的元素只保留一个。放到新数组中去

方法:遍历旧数组,然后拿旧数组中的元素依次和在新数组中查找,如果没有查找到该元素就放进新数组,如果找到了就不放入新数组

要点:使用indexOf方法判断新数组中有没有目标元素 返回值为-1则表示新数组中没有该目标元素

function delCel(arr){
	var newArr=[];
	for(var i=0;i<arr.length;i++){
		if(newArr.indexOf(arr[i])===-1){
		 newArr.push(arr[i]);
		}
	}
	return newArr;
}
//--------------将数组中的0全部去掉
var arr=[4,0,7,0,9,0,7,3,0,0,2,0];
var index=arr.indexOf(0);
while(index!=-1){
  arr.splice(index,1);
  index=arr.indexOf(0)
}
console.log(arr)

数组转化为字符串

toString() 将数组转化为字符串
join

join()方法以指定的参数作为分隔符,将所有的数组成员链接为一个字符串返回,如果不提供参数默认使用逗号分隔

var a = [1, 2, 3, 4];

a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
  • 以上操作数组的方法中有不少返回值是数组,所以可以链式使用

案例看如阮一峰es5

作业:

      var a=  {
                "男明星": [
                        { "name":"梁朝伟","age":"40"},
                        { "name":"刘德华","age":"42"},
                        { "name":"彭于晏","age":"29"}
                    ],
                "女明星": [
                        { "name":"刘嘉玲","age":"40"},
                        { "name":"张敏","age":"41"},
                        { "name":"张柏芝","age":"30"},
                        { "name":"朱茵","age":"38"}
                    ]
             }

        /* 
        把下列对象按要求遍历
        1.页面里实现
                男明星:
                name-->梁朝伟     age--->40
                name-->刘德华     age--->42
                name-->彭于晏     age--->29
                
                女明星:
                name-->刘嘉玲     age--->40
                name-->张敏        age--->41
                name-->张柏芝      age--->30
                name-->朱茵       age--->38

        2.过滤出所有40岁以上的明星
        3.求所有明星的年龄之和


        */

包装对象

js中Number 、String、Boolean这三个原生的函数(对象),作为普通函数调用时(不带new),常常用于将任意类型的值转为相对应的数值,字符串和布尔值。(即数值类型转换)

// 字符串转为数值
Number('123') // 123

// 数值转为字符串
String(123) // "123"

// 数值转为布尔值
Boolean(123) // true

Number 、String、Boolean这三个原生对象作为构造函数使用的时候(调用时带new),可以将原始类型的值转为(包装)对象

var v1 = new Number(123);
var v2 = new String('abc');
var v3 = new Boolean(true);

typeof v1 // "object"
typeof v2 // "object"
typeof v3 // "object"

v1 === 123 // false
v2 === 'abc' // false
v3 === true // false

可以看到基于原始类型的值,生成了三个对应的包装对象,且与原来的基本类型的值不在相等

将基本类型的值转为包装对象的原因是:基本类型的值是没有属性和方法的,只有对象才有属性和方法,为了方便操作基本类型的数据使得基本类型的值也可以调用自己(对象)的属性和方法

  • 包装对象各自提供了许多的属性和方法,他们共有的方法是:

    • valueOf()方法返回包装对象实例对应的基本类型的值

    new Number(123).valueOf()  // 123
    new String('abc').valueOf() // "abc"
    new Boolean(true).valueOf() // true
    • toString()方法返回对应的字符串形式

      数值,布尔值,字符串都可以使用toString(),因为数字,布尔值,字符串都是包装数据类型,undefined和null不是包装数据类型,不能使用

      new Number(123).toString() // "123"
      new String('abc').toString() // "abc"
      new Boolean(true).toString() // "true"
  • 基本数据类型与实例对象的自动转换

    在基本类型的值上直接调用包装对象的属性和方法时,js引擎会自动将基本类型的值先转换为包装对象,调用包装对象的属性和方法,并在使用后销毁实例

    数值,字符串,布尔值是包装数据类型,在使用的时候会自动转换成复杂数据类型,当使用完毕自动转换为基本数据类型

    基本数据类型在堆里没有空间,当使用字符串.length的时候,会自动转换为复杂数据类型,在堆内存里开辟一个空间,按照索引将字符串的每一个字符排列进去,等访问结束,拿到我们要使用的内容后,这个开辟的临时空间就销毁了

    基本数据类型是不会被改变的只能覆盖 var num=10;num+=20;

var str="abc";
str.lengrh //3

上面色代码等同于,先把str转换为其对应的包装对象,这是一个临时对象
var strObj=new String(str)
// String {
//   0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"
// }
在这个临时对象上调用length属性
strOj.length;
调用包装对象的方法或属性后再销毁这个临时对象
strObj=null;

自动生成的包装对象是只读的,无法修改,所以,字符串无法添加新的属性

var s = 'Hello World';
s.x = 123;
s.x // undefined

另一方面,调用结束后,包装对象实例会自动销毁。这意味着,下一次调用字符串的属性时,实际是调用一个新生成的对象,而不是上一次调用时生成的那个对象,所以取不到赋值在上一个对象的属性

操作字符串

操作字符串的案例

反转字符串
方法1:
var a='adgfshj gggggfsg';
var res=a.split('').reverse().join('')
console.log(res); // gsfggggg jhsfgda

方法2:
var a='adgfshj gggggfsg';
var s='';
for(var i=a.length-1;i>=0;i--){
    // console.log(a[i])
    // console.log(a.charAt(i))
    s += a[i];
}
console.log(s)

基本数据类型在堆里没有空间,当使用字符串.length的时候,会自动转换为复杂数据类型,在堆内存里开辟一个空间,按照索引将字符串的每一个字符排列进去,等访问结束,拿到我们要使用的内容后,这个开辟的临时空间就销毁了

基本数据类型是不会被改变的只能覆盖

基本数据类型在堆里没有空间,当使用字符串.length的时候,会自动转换为复杂数据类型,在堆内存里开辟一个空间,按照索引将字符串的每一个字符排列进去,等访问结束,拿到我们要使用的内容后,这个开辟的临时空间就销毁了

var str='啊函数的佛罗伦萨定时发个hasdf a'
console.log(new String(str))
//
0: "啊"
1: "函"
2: "数"
3: "的"
4: "佛"
5: "罗"
6: "伦"
7: "萨"
8: "定"
9: "时"
10: "发"
11: "个"
12: "h"
13: "a"
14: "s"
15: "d"
16: "f"
17: " "
18: "a"
length: 19
//---------------------------循环遍历字符串
var str='啊函数的佛罗伦萨定时发个hasdf a'
console.log(new String(str));//看看字符串包装对象怎么存储的
for(var i=0;i<=str.length-1;i++){
    console.log(str[i])
}

//-----------------------------统计字符串传中各个字符出现的次数
var a='11adgfshjf gggggfsg22';
var obj={}
for(var i=0;i<=a.length-1;i++){
    if(obj[a[i]]){       //a[i] 是字符串里每一个字符,判断对象里有没这个属性,没有就以字符作为属性名
        obj[a[i]]++       // 并赋值为1,如果有就自增1
    }else{
        obj[a[i]]=1;
    }
}

console.log(obj)


//--------------------------出现最多次的字符

var a='11adgfshjf gggggfsg22';
var obj={}
for(var i=0;i<=a.length-1;i++){
    if(obj[a[i]]){
        obj[a[i]]++
    }else{
        obj[a[i]]=1;
    }
}

console.log(obj)
var max=0;
var j;
for(var i in obj){
    if(obj[i]>=max){
        max=obj[i]
        j=i
    }

}
console.log('出现次数最多的字符是:',j,'出现多少次:',max)  //g 次

//-------------------------------统计指定字符出现的次数
//-----------先找出第一次出现的位置,然后只有返回值不是-1,就继续向后查找,因为indexof,只能查找到第一个,后面的查找可以使用indexof的第二个参数,设置下次查找从上次返回值的下一位开始查找

var a='11adgfshjf gggggfsg22';
var index=a.indexOf('s');
var num=0;
while (index!=-1) {
    console.log(index)               // 出现的索引位置 6 17
    num++
    index=a.indexOf('s',index+1);
}
console.log('出现多少次:',num);            // 2次

模版字符串

es5中使用+拼接字符串,es6中新增了以反引号定义字符串 dgfgd,我们将反引号定义的字符串叫做模版字符串

模版字符串和单双引号字符串的区别

在单双引号字符串中不能换行,不能使用变量,模版字符串可以换行且换行效果可以输出,可以使用变量

var a=`<p>
      <a>不错不错</a>
      <span>你好<span>
     </p>`

模版字符串有兼容性问题,但是不用考虑,打包工具会转换为es5的语法

(…字符串的不可变

(字符串的不可变指的是里面的值不可变,变量的值虽然看上去可以改变内容,但其实是地址变了,在内存中开辟了新的内存空间)

var str="abc";
在内存中开辟一个内存空间存储字符串“abc”,将变量的指针指向这个字符串的内存空间
str="123";
当给str变量重新赋值为“123”字符串实际是,在内存中重新开辟了一个内存空间用来存储新的字符串“123”,并将变量str的指针指向这个新的内存空间,而原来的"abc"常量字符串依然在内存空间中。只不过是变量str的指针指向发生了改变

由于字符串的不可变,在大量拼接字符串时会有效率问题

var str='';
for(var i=0;i<10000000000;i++){
 //str+=i;
   str=str+i; //'0'  ‘01’  ‘012’ ‘0123’ 
}
console.log(str) //这个结果需要大量的时间来显示,因为会不断的开辟新的内存空间

由于字符串时不可变的,所以字符串的 所有方法都不会修改字符串本身,操作完成会返回一个新的字符串…)

字符串实例的属性

字符串实例的length属性返回字符串的长度,字符串的lengrh属性是一个制度属性,你如你要设置不会报错

基本数据类型是不会被改变的只能覆盖

字符串里的空格也算一个字符

'abc'.length

字符串实例方法

根据字符返回返回位置

indexOf **

作用:indexOf方法用于确定一个字符串在另一个字符串中第一次出现的位置(从原字符串头部开始向后查找)。如果找不到就返回-1

格式:字符串.indexOf('要查询的字符',[开始的index索引])

开始的索引可以省略,省略即是在整个原字符串中查找

//可以匹配一个字符串片段,返回开始索引
var a='adgfshj gggggfsg';
console.log(a.indexOf('shj'))
lastIndexOf **

字符串.lastIndexOf(‘要查询的字符’) 从原字符串尾部开始向前查找,返回第一个符号条件的index,没有找到则返回-1

字符串的这两个方法同数组的indexOf和lastIndexOf用法一样

案例:。。。

includes **

格式:字符串.includes(‘字符串片段’)

作用:查找字符串里有没有匹配的字符串片段,返回 true或false

search

格式:字符串.search(‘字符串片段’)

作用:查找字符串里有没有匹配的字符串片段

返回值:有 返回指定索引

没有 返回-1

和indexof的区别,search没有第二个参数,search可以使用正则

match

格式:字符串.match(‘字符串片段’)

作用:查找字符串里匹配的字符串片段

返回值:返回一个数组,里面是找到的字符串片段

实际应用:参数不是传入字符串而是传入正则

match可以使用正则

trim **

去除首位空格

返回去除空格后字符串

trimStart() 去除开始空格。trimEnd() 去除尾部空格

根据位置返回字符

  • 字符串.charAt(index) index是字符串的索引号,返回该索引号位置上的字符

    如果没有该索引位置,返回空

    var a='adgfshj fsg';
    console.log(a.charAt(87))
    //循环遍历字符串
    var a='adgfshj gggggfsg';
    for(var i=0;i<=a.length-1;i++){
        // console.log(a[i])
        console.log(a.charAt(i))
    }
  • 字符串.charCodeAt(index) 返回该索引号上的字符的ASCII码(索引)

  • 字符串[index] 返回index位置上的字符 该方法有兼容性问题 ,IE8+才支持,与charAt方法等效

案例:统计一个字符串中出现次数最多的字符

ASCII码

读作:as key码

一个编码,用来表示计算机输入的所有内容,最早把所有可以输入的内容全部转换成二进制数字保存,给电脑上的每一个键,每一个输入都编了一个二进制码,一共128个,起了名字叫做ASCII码

unicode编码

随着计算机的发展,128个不够用了,又在ascii码的基础上新增了世界上大部分国家的文字,即万国码(统一码),取名叫做unicode编码,前128个就是ascII码

随着web技术的发展,在浏览器中统一使用一种八位的unicode编码,我们叫做UTF-8

不同的编码,在不同的字符集里面,同一个序号的内容不一样GBK

concat

concat方法用于拼接两个或多个字符串,返回一个新的字符串,不改变原字符串

字符串1.concat(字符串2[,字符串3,....])

'a'.concat('b','c') //'abc'

如果参数不是字符串会先将其转化为字符串再拼接

var one = 1;
var two = 2;
var three = '3';

''.concat(one, two, three) // "123"
one + two + three // "33"

作为比对,加号运算符在两个运算数都是数值的,不会转换类型,所以的到的是一个两个字符的字符串

var one = 1;
var two = 2;
var three = '3';

''.concat(one, two, three) // "123"
one + two + three // "33"
slice ***

字符串实例的slice方法用于从原字符串取出子字符串并返回子字符串,不改变原字符串

字符串.slice(star,end),它的第一个参数是子字符串开始的位置(包含该开始的位置),第二个参数是子字符串结束的位置但不包含该结束的位置(包前不包后)

如果省略第二个参数,则表示子字符串一直到原子符串的结尾

'JavaScript'.slice(4) // "Script"

如果参数为负值,则表示从结尾开始倒数计算的位置,即该负值加上字符串的长度

'JavaScript'.slice(-6) // "Script"
'JavaScript'.slice(0, -6) // "Java"
'JavaScript'.slice(-2, -1) // "p"

如果第一个参数大于第二个参数(正值的情况下),则slice方法返回一个空字符串、

'JavaScript'.slice(2, 1) // ""

substring方法和slice放法很像,但是substring方法有些规则很违反直觉,推荐使用slice方法,substring方法不讲了,感兴趣的自己查找

substring和slice的区别,substring可以使用负整数

substring 不建议使用,优先使用slice

substr ***

作用:从原字符串中取出子字符串并返回子字符串,不改变原字符串

格式:字符串.substr(star, length)

返回值:截取出来的字符串

第一个参数是子字符串开始的位置(从0开始计算)包含该开始位置,第二个参数是子字符串的长度

'JavaScript'.substr(4, 6) // "Script"

如果省略第二个参数则表示子字符串从开始位置一直到原字符串的结束

'JavaScript'.substr(4) // "Script"

如果第一个参数是负数则表示倒数计算的字符位置,如果第二个参数是负数则会自动被转化为0,表示子字符串的长度是0,因此会返回一个空字符串

'JavaScript'.substr(-6) // "Script"
'JavaScript'.substr(4, -1) // ""

##

split ***

作用:split方法按照给定规则分隔字符串,返回一个由分隔出来的子字符串组成的数组。

格式:字符串.split(分隔符,保留多少个)

第二个参数是选填,作用是设置切割完后,保留多少个,默认是全部

返回值:以数组的形式保存每一段的内容,返回值总是一个数组

'a|b|c'.split('|') // ["a", "b", "c"]

如果分隔规则为空字符串,按照一位一位的切割,则返回数组的成员是原字符串的每一个字符

'a|b|c'.split('') // ["a", "|", "b", "|", "c"]

如果省略参数,则返回数组的唯一成员就是原字符串

'a|b|c'.split() // ["a|b|c"]

案例:2021-12-09 转为 2021/12/09 格式

将url地址 https://www.baidu.com/index.html?a=12&b=345&c=678; 的查寻字符串放到对象里

{a:12,b:345,c:678}

replace ***

replace方法用于替换字符串中的字符,一般情况只替换第一个匹配的字符

格式:字符串.replace(‘被替换的字符’,’要替换为的字符’)

"aaa".replace('a','b')  //"baa"

案例:将’abcabcabc’中的所有a替换为w(关键字隐藏)

  • toUpperCase() //转换大写 **

  • toLowerCase() //转换小写 **

垃圾回收机制

程序在长期运行中也会产生垃圾,垃圾积攒过多会导致程序的运行过慢,我们需要一种垃圾回收机制来处理来处理程序在运行过程中产生的垃圾

  • 当一个对象没有任何的变量或者属性对他进行引用,此时我们将永远无法再对该对象进行操作,这个对象就是一个垃圾数据,这种对象过多会占用大量的内存空间,需要对这种对象进行清理,在js中拥有自动的垃圾回收机制,会自动将这种对象从内存中销毁,我们不需要也无法手动的进行垃圾回收操作,我们需要做的就是将不再使用的对象设置为null即可,就像是放到了垃圾箱一样,到时垃圾回收机制就会自动将垃圾清理掉

    var obj=new Object();  
    obj=null;  //对象不在使用后赋值为null