5. 数组对象
5.1 数组对象的创建
创建数组对象的两种方式
字面量方式
new Array()
字面量方式，new Array();
5.2 检测是否为数组
instanceof 运算符，可以判断一个对象是否属于某种类型
Array.isArray()用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法
Array.isArray()用于判断一个对象是否为数组，判断一个对象是否伪书组
var arr = [1, 23];
var obj = {
};
console.log(arr instanceof Array); // true
console.log(obj instanceof Array); // false
console.log(Array.isArray(arr)); // true
console.log(Array.isArray(obj)); // false
5.3 添加删除数组元素的方法
unshift()像数组的开头添加一个或者更多的元素，注意修改原数组，向数组的开头添加一个或者更多的元素，注意修改原数组，shift()删除数组的第一个元素，删除数组的第一个元素，unshift()向数组的开头添加一个或者更多的元素，
shift()删除数组的第一个元素，数组的长度减1无参数，修改原数组
案例： 筛选数组
有一个包含工资的数组[1500, 1200, 2000, 2100, 1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面
var arr = [1500, 1200, 2000, 2100, 1800];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] < 2000) {
newArr.push(arr[i]);
}
}
console.log(newArr);
newArr.push(arr[i]);
5.4 数组排序
reverse();颠倒数组当中元素顺序无参数，该方法会改变原数组，返回新数组
sort()对数组元素进行排序，该方法会改变原来的数组，返回新的数组
var arr = [1, 64, 9, 6];
arr.sort(function(a, b) {
return b - a; // 降a序
// return a - b; // 升序
});
console.log(arr);
var arr=[1,64,9,6];
arr.sort(function(a,b0{return b-a’});
console.log(Arr);
5.5 数组索引方法
indexOf()数组当中查找给定元素的额第一个索引
lastIndexOd()在数组当中最后一个索引
案例： 数组去重（重点案例）
有一个数组[‘c’, ‘a’, ‘z’, ‘a’, ‘x’, ‘a’, ‘x’, ‘c’, ‘b’]，要求去除数组中重复的元素。
案例分析
目标：把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重。
核心算法：我们遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。
我们怎么知道该元素没有存在？ 利用 新数组.indexOf(数组元素) 如果返回时 -1 就说明 新数组里面没有改元素
遍历旧的数组，然后拿着就数组元素取查询新的数组，indexOf()数组当中查找元素的第一索引
旧数组[‘c’, ‘a’, ‘z’, ‘a’, ‘x’, ‘a’, ‘x’, ‘c’, ‘b’]
新数组 [ ]
5.6 数组转换为字符串
toString()把数组转换成为字符串，逗号分割每一项，
join(）方法把数组当中所有的元素转换成为一个字符串
toString()把数组转换成为字符串，逗号分割每一项
join()方法把数组当中所有元素转换成为一个字符串
5.7 课下查询
concat()链接两个或者多个数组，影响原数组，slice(begin,end)数组截取返回被截取项目的新数组
splice(第一个开始，要删除的个数）
slice() 和 splice() 目的基本相同，建议同学们重点看下 splice()
11-创建数组的两种方式
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 创建数组的两种方式
// 1. 利用数组字面量
var arr = [1, 2, 3];
console.log(arr[0]);
// 2. 利用new Array()
// var arr1 = new Array(); // 创建了一个空的数组
// var arr1 = new Array(2); // 这个2 表示 数组的长度为 2 里面有2个空的数组元素
var arr1 = new Array(2, 3); // 等价于 [2,3] 这样写表示 里面有2个数组元素 是 2和3
console.log(arr1);
</script>
</head>
<body>
</body>
</html>
12-检测是否为数组方法
Array.isArray(),Array.isArray()arr instanceof Array
function reverse(arr){
if(Arrar.isArray(arr){
var newArr=[];
for(var i=arr.length-1;i>=0;i–){newArr[newArr.length]=arr[i];}return newArr;}else{reurn ‘error这个参数要求必须时数组格式’}}
function reverse(arr){if(Array.isArray(arr)){var newArr=[];
for(var i.arrlength-1;i>=0;i–){newArr[newArr.length=arr[i];}return newArr;}else{rteurn ‘errpr’;}
}}
function reverse(arr){if(Array.isArray(arr)){avar newArr=[];
for(var i.arrlnegth-1;i>=0i–){newArr[newArr.length]=arr[i];}}return newArr;}else{return ‘error’}}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 翻转数组
function reverse(arr) {
// if (arr instanceof Array) {
if (Array.isArray(arr)) {
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
newArr[newArr.length] = arr[i];
}
return newArr;
} else {
return 'error 这个参数要求必须是数组格式 [1,2,3]'
}
}
console.log(reverse([1, 2, 3]));
console.log(reverse(1, 2, 3));
// 检测是否为数组
// (1) instanceof 运算符 它可以用来检测是否为数组
var arr = [];
var obj = {
};
console.log(arr instanceof Array);
console.log(obj instanceof Array);
// (2) Array.isArray(参数); H5新增的方法 ie9以上版本支持
console.log(Array.isArray(arr));
console.log(Array.isArray(obj));
</script>
</head>
<body>
</body>
</html>
13-添加删除数组元素的方法
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 添加删除数组元素方法
// 1. push() 在我们数组的末尾 添加一个或者多个数组元素 push 推
var arr = [1, 2, 3];
// arr.push(4, 'pink');
console.log(arr.push(4, 'pink'));
console.log(arr);
// (1) push 是可以给数组追加新的元素
// (2) push() 参数直接写 数组元素就可以了
// (3) push完毕之后，返回的结果是 新数组的长度
// (4) 原数组也会发生变化
// 2. unshift 在我们数组的开头 添加一个或者多个数组元素
console.log(arr.unshift('red', 'purple'));
console.log(arr);
// (1) unshift是可以给数组前面追加新的元素
// (2) unshift() 参数直接写 数组元素就可以了
// (3) unshift完毕之后，返回的结果是 新数组的长度
// (4) 原数组也会发生变化
// 3. pop() 它可以删除数组的最后一个元素
console.log(arr.pop());
console.log(arr);
// (1) pop是可以删除数组的最后一个元素 记住一次只能删除一个元素
// (2) pop() 没有参数
// (3) pop完毕之后，返回的结果是 删除的那个元素
// (4) 原数组也会发生变化
// 4. shift() 它可以删除数组的第一个元素
console.log(arr.shift());
console.log(arr);
// (1) shift是可以删除数组的第一个元素 记住一次只能删除一个元素
// (2) shift() 没有参数
// (3) shift完毕之后，返回的结果是 删除的那个元素
// (4) 原数组也会发生变化
</script>
</head>
<body>
</body>
</html>
push()在数组末尾，添加一个或者多个数组元素，
arr.push(4,‘pink’);
push()参数直接写，数组元素就可以了，返回的时新数组长度
unshift()在数组开头添加一个或者多个数组元素
pop()删除数组最后一个元素，
shift()删除数组第一个元素，删除数组的第一个元素，一次只能删除一个，shift()没有参数，
shift()完毕之后，返回的结果时删除的哪个元素，
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 有一个包含工资的数组[1500, 1200, 2000, 2100, 1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面
var arr = [1500, 1200, 2000, 2100, 1800];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] < 2000) {
// newArr[newArr.length] = arr[i];
newArr.push(arr[i]);
}
}
console.log(newArr);
</script>
</head>
<body>
</body>
</html>
var arr=[1500,1200,200,2100,1800];
var new Arr=[];
for(var i=0;i<arr.length;;i++){
if(Arri]<200){newArr.push(Arr[i]);}}
for(var i=0;i<arr.length;i++){if(Arr[i]<200){newArr.push(Arr[i]));
15-数组排序
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 数组排序
// 1. 翻转数组
var arr = ['pink', 'red', 'blue'];
arr.reverse();
console.log(arr);
// 2. 数组排序（冒泡排序）
var arr1 = [13, 4, 77, 1, 7];
arr1.sort(function(a, b) {
// return a - b; 升序的顺序排列
return b - a; // 降序的顺序排列
});
console.log(arr1);
</script>
</head>
<body>
</body>
</html>
var arr1=[13,4,77,1,7];
arr1.sort(function(a,b）{return b-a;});
indexOf()返回的时数组的索引号
17-数组去重
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 数组去重 ['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'] 要求去除数组中重复的元素。
// 1.目标： 把旧数组里面不重复的元素选取出来放到新数组中， 重复的元素只保留一个， 放到新数组中去重。
// 2.核心算法： 我们遍历旧数组， 然后拿着旧数组元素去查询新数组， 如果该元素在新数组里面没有出现过， 我们就添加， 否则不添加。
// 3.我们怎么知道该元素没有存在？ 利用 新数组.indexOf(数组元素) 如果返回时 - 1 就说明 新数组里面没有改元素
// 封装一个 去重的函数 unique 独一无二的
function unique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
// var demo = unique(['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'])
var demo = unique(['blue', 'green', 'blue'])
console.log(demo);
</script>
</head>
<body>
</body>
</html>
如果该元素在新的数组里面没有出现过，
function unique(arr){var newArr=[];for(var i=0;i<arr.length;i++){if(newArr.indexOf(arr[i])==-1）{newArr.push(arr[i]);
18-数组转换成为字符串
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 数组转换为字符串
// 1. toString() 将我们的数组转换为字符串
var arr = [1, 2, 3];
console.log(arr.toString()); // 1,2,3
// 2. join(分隔符)
var arr1 = ['green', 'blue', 'pink'];
console.log(arr1.join()); // green,blue,pink
console.log(arr1.join('-')); // green-blue-pink
console.log(arr1.join('&')); // green&blue&pink
</script>
</head>
<body>
</body>
</html>
arr.toString(),arr.toString();
arr1.join(),arr1.join(‘-’);arr1.join(‘;#’);
arr.toString();将我们的数组转换成为字符串，将我们的数组转换成为字符串
toString();将我们呢的数组转换成为字符串
啊让人.join(‘#’);
19-基本包装类型
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 基本包装类型
var str = 'andy';
console.log(str.length);
// 对象 才有 属性和方法 复杂数据类型才有 属性和方法
// 简单数据类型为什么会有length 属性呢？
// 基本包装类型： 就是把简单数据类型 包装成为了 复杂数据类型
// (1) 把简单数据类型包装为复杂数据类型
var temp = new String('andy');
// (2) 把临时变量的值 给 str
str = temp;
// (3) 销毁这个临时变量
temp = null;
</script>
</head>
<body>
</body>
</html>
对象才有属性和方法，复杂数据类型才有属性和方法，
var temp=new String(‘andy’);
str=temp;//把临时变量的值给str
temp=null;
20-字符串的不可变性
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 字符串的不可变性
var str = 'andy';
console.log(str);
str = 'red';
console.log(str);
// 因为我们字符串的不可变所以不要大量的拼接字符串
var str = '';
for (var i = 1; i <= 1000000000; i++) {
str += i;
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
6.1 基本包装类型
为了方便操作基本数据类型，JavaScript 还提供了三个特殊的引用类型：String、Number和 Boolean。
基本包装类型就是把简单数据类型包装成为复杂数据类型，这样基本数据类型就有了属性和方法。
String,Number,Boolean,基本包装类型就是把简单数据类型包装成为复杂数据类型，基本包装类型就是把简单的数据类型包装成为复杂的数据类型
// 下面代码有什么问题？
var str = 'andy';
console.log(str.length);
按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为 js 会把基本数据类型包装为复杂数据类型，其执行过程如下 ：
基本数据类型时没有属性和方法，对象才有属性和方法
// 1. 生成临时变量，把简单类型包装为复杂数据类型
var temp = new String('andy');
// 2. 赋值给我们声明的字符变量
str = temp;
// 3. 销毁临时变量
temp = null;
var temp=new String(‘andy’);
str=temp=nul
6.2 字符串的不可变
指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。
值不可变，看上去可以改变内容，地址变了，内存当中开辟一个内存空间
var str=‘abc’;
str=‘hello’;
var str = 'abc';
str = 'hello';
// 当重新给 str 赋值的时候，常量'abc'不会被修改，依然在内存中
// 重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变
// 由于字符串的不可变，在大量拼接字符串的时候会有效率问题
var str = '';
for (var i = 0; i < 100000; i++) {
str += i;
}
console.log(str); // 这个结果需要花费大量时间来显示，因为需要不断的开辟新的空间
重新给字符串复制，会重新在内存当中开辟空间，这个特点就是字符串的不可变
var str=‘avc’;
tr=“hello”;
当重新给str赋值的时候，常量abc不会修改，依然在内存当中，重新给字符串赋值，会重新在内存当中开辟空间，
var str=‘’;
for(var i=0;i<10000;i++){str+=i;}
6.3 根据字符返回位置
字符串所有的方法，都不会修改字符串本身(字符串是不可变的)，操作完成会返回一个新的字符串。
字符串的所有方法，
indexOf(‘要查找字符’,开始的位置)
lastIndexOf()从后往前找，执照第一个匹配的
案例：返回字符位置
查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
21-根据字符返回位置
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 字符串对象 根据字符返回位置 str.indexOf('要查找的字符', [起始的位置])
var str = '改革春风吹满地，春天来了';
console.log(str.indexOf('春'));
console.log(str.indexOf('春', 3)); // 从索引号是 3的位置开始往后查找
</script>
</head>
<body>
</body>
</html>
22-查找某个字母出现的次数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
// 核心算法：先查找第一个o出现的位置
// 然后 只要indexOf 返回的结果不是 -1 就继续往后查找
// 因为indexOf 只能查找到第一个，所以后面的查找，一定是当前索引加1，从而继续查找
var str = "oabcoefoxyozzopp";
var index = str.indexOf('o');
var num = 0;
// console.log(index);
while (index !== -1) {
console.log(index);
num++;
index = str.indexOf('o', index + 1);
}
console.log('o出现的次数是: ' + num);
// 课后作业 ['red', 'blue', 'red', 'green', 'pink','red'], 求 red 出现的位置和次数
</script>
</head>
<body>
</body>
</html>
var index=str.indexof(‘o’);
var num=0;
while(index!=-1){console.log(index);
num++;
index=str.indexof(‘o’,index+1);
while(index!-1){console.log(index);num++;index=str.indexOf(‘o’,index+1);}consolelog(‘o出现的次数时’+num);
while(index!-1){console.log(index);num++;index=str.index
while(index1==-1）{console。log(index);num++;index=str.indexof(‘o’,index+1);
var str=“”;
var index=str.indexOf(‘o’);
var num=0;
while(index!-1){console.log(index);num++;index=str.indexOf(‘o’,index+1);
while(index!-1){console.log(index);num++;index=str.indexOf(‘o’,index+1);
while(index!==-1){console.log(index);num++;index=str.indexOf(‘o’,index+1);}
23-根据位置返回字符
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 根据位置返回字符
// 1. charAt(index) 根据位置返回字符
var str = 'andy';
console.log(str.charAt(3));
// 遍历所有的字符
for (var i = 0; i < str.length; i++) {
console.log(str.charAt(i));
}
// 2. charCodeAt(index) 返回相应索引号的字符ASCII值 目的： 判断用户按下了那个键
console.log(str.charCodeAt(0)); // 97
// 3. str[index] H5 新增的
console.log(str[0]); // a
</script>
</head>
<body>
</body>
</html>
str.charAt(3)’
charCodeAt(index)返回相应索引号的字符ACIIzhi
charCodeAt(),charCodeAt();charCodeAt();返回相应的索引号的字符 ASCII值，判断用户按照下了按个键
for(var i=0;i<str.lnegth;i++){console.log(str.charAt(i); charCode(0);
str[0];
var o={}
for(var i=0;i<str.length;i++){var chars=str.charAt(i);
if(o[chars]){o[chars]++++;}else{o[chars]=1;}
var str=‘abcoefoxyozzopp’;
var o={}for(var i=0;i<str.length;i++){var chars=str.charAt(i);
if(o[chars]){o[chars]++;}
varmax=0;
var ch=‘’;
for(var k in o){if(o[k]>max){max=o[k];
ch=k;}
if(o[k]>max){max=o[k];ch=k;}
25-字符串操作方法
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 字符串操作方法
// 1. concat('字符串1','字符串2'....)
var str = 'andy';
console.log(str.concat('red'));
// 2. substr('截取的起始位置', '截取几个字符');
var str1 = '改革春风吹满地';
console.log(str1.substr(2, 2)); // 第一个2 是索引号的2 从第几个开始 第二个2 是取几个字符
</script>
</head>
<body>
</body>
</html>
var str=‘andy’;
console.log(str.concat(‘red’);
var str1=‘改革开放吹满地’;
console.log(str1.substr(2,2));
案例：思路
查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
核心算法：先查找第一个o出现的位置
然后 只要indexOf 返回的结果不是 -1 就继续往后查找
因为indexOf 只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找
只要indexOf返回的结果不是-1就继续往后查找
因为indexOf只能查找到第一个，所以后面的查找，利用第二个参数，当前索引+1，从而继续往后查找
6.4 根据位置返回字符（重点）
charCodeAt();获取指定位置处的字符的str[index]获取指定位置处的字符
str[index]获取指定位置处的字符，
charCodeAt()获取指定位置处的字符的Ascii码index索引号
6.4 根据位置返回字符（重点）
判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数。
核心算法：利用 charAt(） 遍历这个字符串
把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
遍历对象，得到最大值和该字符
把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在就+1;
判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数。
对象 o { }
var o=={age:18}
if(o[‘sex’]){console.log(‘里面有该属性’);}else{console.log(‘没有改属性’);}
charAt()遍历这个字符串
把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就+1；
var str=‘abcoefoxyozzopp’;
var o={};
for(var i=0;i<str.length;i++){
var chars=str.charAt(i）；
if（哦【chars]){o[chars]++;}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
// 有一个对象 来判断是否有该属性 对象['属性名']
var o = {
age: 18
}
if (o['sex']) {
console.log('里面有该属性');
} else {
console.log('没有该属性');
}
// 判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数。
// o.a = 1
// o.b = 1
// o.c = 1
// o.o = 4
// 核心算法：利用 charAt(） 遍历这个字符串
// 把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
// 遍历对象，得到最大值和该字符
var str = 'abcoefoxyozzopp';
var o = {
};
for (var i = 0; i < str.length; i++) {
var chars = str.charAt(i); // chars 是 字符串的每一个字符
if (o[chars]) {
// o[chars] 得到的是属性值
o[chars]++;
} else {
o[chars] = 1;
}
}
console.log(o);
// 2. 遍历对象
var max = 0;
var ch = '';
for (var k in o) {
// k 得到是 属性名
// o[k] 得到的是属性值
if (o[k] > max) {
max = o[k];
ch = k;
}
}
console.log(max);
console.log('最多的字符是' + ch);
</script>
</head>
<body>
</body>
</html>
var max=0;
var ch=‘’;
for(var k in o){if(o[k]>max){max=o[k];ch=k;}}
6.5 字符串操作方法（重点）
substr(star,length);substr(start,length)substr(start,length);
slice(start,end);从start位置开始，截取到end位置，
substring(start,end);substring(start,end);从start位置开始截取到end位置，
6.6 replace()方法
replace() 方法用于在字符串中用一些字符替换另一些字符。
其使用格式如下：
在字符串当中用一些字符替换另一些字符
replace(被替换的字符串， 要替换为的字符串)；
replace被替换的字符串，要替换为的字符传）
6.7 split()方法
split()方法用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组。
例如下面代码：
将字符串切分为数组，返回的时一个新的数组
var str = 'a,b,c,d';
console.log(str.split(',')); // 返回的是一个数组 [a, b, c, d]
str.split(‘,’);
6.8 课下查阅
toUpperCase() //转换大写
toLowerCase() //转换小写
作业
给定一个字符串，如：“abaasdffggghhjjkkgfddsssss3444343”，问题如下：
1、 字符串的长度
2、 取出指定位置的字符，如：0,3,5,9等
3、 查找指定字符是否在以上字符串中存在，如：i，c ，b等
4、 替换指定的字符，如：g替换为22,ss替换为b等操作方法
5、 截取指定开始位置到结束位置的字符串，如：取得1-5的字符串
6、 找出以上字符串中出现次数最多的字符和出现的次数
7、 遍历字符串，并将遍历出的字符两头添加符号“@”