一、字符串方法：所有方法均不改变原字符串
注意，数组也有的方法，如indexOf、slice、concat
1、charAt：通过索引获取字符，不存在时，返回空字符串。也可以用str[0]
2、indexOf：通过字符获取(该字符首次出现时所在位置的)索引，不存在时，返回-1。
3、concat：把多个字符串拼接成一个字符串，相当于加号
4、split：把字符串按照指定的分隔符拆分成数组（与数组里join方法相反）
（1）实例1：console.log("ABCDEFG".split(""));//[ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
（2）实例2：console.log("ABCDEFG".split("D"));//[ 'ABC', 'EFG' ]
5、substr:复制字符串
（1）没有参数时，返回整个字符串
（2）一个参数时，返回返回参数到末尾的字符串
（3）两个参数时（m,n）,返回从索引m开始的n个字符
6、substring:复制字符串
（1）没有参数时，返回整个字符串
（2）一个参数时，返回返回参数到末尾的字符串
（3）两个参数时（m,n）,返回索引m到索引n,不包括n
7、slice：复制字符串
（1）没有参数时，返回整个字符串
（2）一个参数时，返回参数到末尾的字符串
（3）两个参数时（m,n）,返回从索引m到索引n,不包括n
8、match：
（1）加g，匹配多次
var reg=/(\d)A(\d)/g;
var before="000002223A45556A7888";
var after=before.match(reg);
console.log('返回数组：',after);
//返回值为数组，每项分别为：大正则第1、2、3...次匹配到的内容;
（2）不加g，匹配一次
var reg=/(\d)A(\d)/;
var before="000002223A45556A7888";
var after=before.match(reg);
console.log('返回数组：',after);
//返回值为数组，每项分别为：大正则第1次匹配到的内容、第1、2、3...个小分组匹配到的内容、索引、整个字符串;
9、replace：原字符串不变，返回值为新字符串
（1）字符串+字符串做参数时，旧字符串(第1个参数)被新字符串(第2个参数)取代
var before='AAACCCAAA';
var after=before.replace("AAA","EEE");
console.log('返回字串：',after);
（2）正则+字符串做参数时，
（2-1）加g，匹配多次
var reg=/(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/g;
var before='AAA_12345678_BBB_87654321_CCC';
var after=before.replace(reg,"0000000");
console.log('返回字串：',after);
（2-2）不加g，匹配一次
var reg=/(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/;
var before='AAA_12345678_BBB_87654321_CCC';
var after=before.replace(reg,"0000000");
console.log('返回字串：',after);
（3）正则+回调函数作参数时，
（3-1）加g，匹配多次
var reg=/(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/g;
var before='AAA_12345678_BBB_87654321_CCC';
var i=0;
var after=before.replace(reg,function(totalRegexp,A1,A2,A3,A4,A5,A6,A7,A8,firstIndex,totalString){
i=i+1;
console.log('"'+totalRegexp+'"是被大正则第'+i+'次匹配到的内容');
console.log('"'+A1+'"是被第1个小正则匹配上的内容');
console.log('"'+A2+'"是被第2个小正则匹配上的内容');
console.log('"'+A3+'"是被第3个小正则匹配上的内容');
console.log('"'+A4+'"是被第4个小正则匹配上的内容');
console.log('"'+A5+'"是被第5个小正则匹配上的内容');
console.log('"'+A6+'"是被第6个小正则匹配上的内容');
console.log('"'+A7+'"是被第7个小正则匹配上的内容');
console.log('"'+A8+'"是被第8个小正则匹配上的内容，以此类推');
console.log('"'+firstIndex+'"是被大正则匹配到的内容的第1个字符在整个字符串中的索引');
console.log('"'+totalString+'"是整个字符串，本轮匹配结束');
console.log("==========");
return '（我将取代第'+i+'次被大正则匹配到的内容）'
});
console.log('返回字串：',after);
//返回值为基于原字符串的新字符串，用函数第1、2、3...次返回的内容-代替-原字符串第1、2、3...次被大正则匹配到的内容;
（3-2）不加g，匹配一次
var reg=/(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/;
var before='AAA_12345678_BBB_87654321_CCC';
var i=0;
var after=before.replace(reg,function(totalRegexp,A1,A2,A3,A4,A5,A6,A7,A8,firstIndex,totalString){
i=i+1;
console.log('"'+totalRegexp+'"是被大正则第1次匹配到的内容');
console.log('"'+A1+'"是被第1个小正则匹配上的内容');
console.log('"'+A2+'"是被第2个小正则匹配上的内容');
console.log('"'+A3+'"是被第3个小正则匹配上的内容');
console.log('"'+A4+'"是被第4个小正则匹配上的内容');
console.log('"'+A5+'"是被第5个小正则匹配上的内容');
console.log('"'+A6+'"是被第6个小正则匹配上的内容');
console.log('"'+A7+'"是被第7个小正则匹配上的内容');
console.log('"'+A8+'"是被第8个小正则匹配上的内容，以此类推');
console.log('"'+firstIndex+'"是被大正则匹配到的内容的第1个字符在整个字符串中的索引');
console.log('"'+totalString+'"是整个字符串，本轮匹配结束');
console.log("==========");
return '（我将取代被大正则第1次匹配到的内容）'
});
console.log('返回字串：',after);
//返回值为基于原字符串的新字符串，用函数第1次返回的内容-代替-原字符串第1次被大正则匹配到的内容;
（3-3）罕见用法
var reg=/(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/;
var before='AAA_12345678_BBB_87654321_CCC';
var after=before.replace(reg,'$1');
//返回值为基于原字符串的新字符串，用第1个小分组的内容-代替-原字符串第1次被大正则匹配到的内容;
console.log('返回字串：',after);
二、正则：
1、test
var before='程序员：123';
var reg=/\d/;
var after=reg.test(before);
console.log('返回布尔值：',after);
2、exec：
（1）加g，匹配多次
var reg=/(\d)A(\d)/g;
var before="000002223A45556A7888";
var after=reg.exec(before);
console.log('返回数组：',after);
//返回值为数组，每项分别为：大正则第1、2、3...次匹配到的内容
（2）不加g，匹配一次
var reg=/(\d)A(\d)/;
var before="000002223A45556A7888";
var after=reg.exec(before);
console.log('返回数组：',after);
//返回值为数组，每项分别为：大正则第1次匹配到的内容、小分组第1、2、3...次匹配到的内容、索引、整个字符串;
3、正则元字符
（1）\w：匹配数字、字母、下划线
（2）\W：匹配非数字、字母、下划线
（3）\n：匹配换行符
（4）.：匹配非换行符
（5）\s：匹配空格
（6）\S：匹配非空格
（7）^：匹配输入字符串的开始位置；在方括号中使用时，表示排除方括号中的所有字符
（8）$：匹配输入字符串的结尾位置
（9）*：匹配前面的子表达式0-n次
(10)+：匹配前面的子表达式1-n次
(11)?：匹配前面的子表达式0或1次
(12)\r：匹配回车
(13)正则元字符的使用：MAC
var MACMatch=/^[A-Fa-f0-9]{2}(:[A-Fa-f0-9]{2}){5}$|^[A-Fa-f0-9]{2}(-[A-Fa-f0-9]{2}){5}$/,
4、用正则封装解析方法（解析URL中的问号参数值以及HASH值）
function queryURLParameter(url) {
var obj = {};
var reg = /([^?=&#]+)=([^?=&#]+)/g;
url.replace(reg, function () {
obj[arguments[1]] = arguments[2];
});
reg = /#([^?=&#]+)/;
if (reg.test(url)) {
obj['HASH'] = reg.exec(url)[1];
}
return obj;
}
var str1="https://www.baidu.com/newspage/data/landingsuper?AAA=1111&BBB=222&CCC=333#1234";
var abc1=queryURLParameter(str1);
console.log("第1次输出:",abc1);
5、用正则封装解析方法（HASH值）
function hashA(url){
var reg=/#([^#&=?]+)/;
if(reg.test(url)){
return reg.exec(url)[1];
}
}
var str2="https://www.baidu.com/newspage/data/landingsuper?AAA=1111&BBB=222&CCC=333#1234"
var abc2=hashA(str2);
console.log("第2次输出:"+abc2);
6、用正则封装解析方法
var ary=["零","一","二","三","四","五","六","七","八","九"];
var str3="今年是2017年";
var abc3=str3.replace(/\d/g,function () {
return ary[arguments[0]]
});
var abc4=str3.replace(/\d/g,function (first) {
return ary[first]
});
7、用正则择出汉字
var str5 = '<img src="haha.png" alt="你的朋友"/>';
var reg5=/alt="(.+)"/;
var last=reg5.exec(str5);
console.log("alt内部内容输出:",last[1]);
8、someNumber为数字，当它的小数位数少于number时，则保留原数字，否则四舍五入保留至小数number位
function formatTime(someNumber, number) {
var lastNum = null;
if (typeof someNumber == "number") {
var strNum = someNumber.toString().match(/\.\d*/);
if (strNum == null || strNum[0].length <= number + 1) {
lastNum = someNumber;
} else {
lastNum = someNumber.toFixed(number);
}
}
return lastNum;
}
console.log(formatTime(3.1283456, 2));
console.log(formatTime(3.55, 3));
console.log(formatTime(3, 3));
三、数组的方法：
注意，字符串也有的方法，如indexOf、slice、concat
1、push
（1）作用：向数组末尾追加一项
（2）参数：要添加的数组项（多项用逗号隔开）
（3）返回值：新数组的长度
（4）是否改变原数组：改变
2、pop
（1）作用：删除项数组末尾项
（2）参数：没有参数
（3）返回值：被删除的项
（4）是否改变原数组：改变
3、unshift
（1）作用：向数组开头添加一项
（2）参数：要添加的数组项（多项用逗号隔开）
（3）返回值：新数组的长度
（4）是否改变原数组：改变
4、shift
（1）作用：删除数组开头项
（2）参数：没有参数
（3）返回值：被删除的项
（4）是否改变原数组：改变
5、reverse
（1）作用：倒序数组
（2）参数：不需要参数
（3）返回值：倒序后的数组
（4）是否改变原数组：改变
6、sort
（1）作用：按照指定规则排序
（2）参数：A、无参数，为升序；B、回调函数为参数，如ary.sort(function(a,b){return a-b})，为升序
（3）返回值：排好序的数组
（4）是否改变原数组：改变
7、splice
（1）作用：参数不同，作用不同，主要用来删除数组项
（2）没有参数：原数组不变，返回空数组
（3）一个参数：从索引位置删除到末尾，返回被删除项构成的数组
（4）两个参数（n,m）：从索引n删除m个，返回被删除项构成的数组
（5）三个参数（n,m,X）: 从索引n删除m个，被删除项用X填补，返回被删除项构成的数组
（6）是否改变原数组：改变
/* ===以上原数组改变；以下原数组不变=== */
8、indexOf
（1）作用：获取数组项第一次在数组中出现的位置索引
（2）参数：要判断的数组项
（3）返回值：数组项的索引，没有该项返回-1
（4）是否改变原数组：不变
9、slice
（1）作用：复制数组项
（2）没有参数：原数组不变，返回整个数组
（3）一个参数：返回从索引位置到末尾
（4）两个参数（n,m）：返回索引n到m，不包含m
（5）是否改变原数组：不变
10、concat
（1）作用：把多个数组拼接在一起
（2）参数：要拼接的数组或字符串。如果是数组，就把数组里的每一项放到原数组的后面；如果是字符串，把字符串作为一项，放在原数组后面；克隆数组：ary.concat();ary.concat([])；
（3）返回值：拼接好的数组
（4）是否改变原数组：不变
11、forEach
（1）作用：循环遍历每一项，循环次数为数组项数
（2）参数：匿名函数，匿名函数可以有三个参数
（3）返回值：undefined
（4）是否改变原数组：不变
12、map
（1）作用：循环遍历每一项，循环次数为数组项数
（2）参数：匿名函数，匿名函数可以有三个参数
（3）返回值：返回一个新数组，新数组的每一项是匿名函数每次执行后的返回值
（4）是否改变原数组：不变
13、find
（1）作用：找出最先满足条件的那一项
（2）参数：匿名函数，匿名函数可以有三个参数
（3）返回值：最先满足条件的那一项
（4）是否改变原数组：不变
14、filter
（1）作用：找出所有满足条件的项
（2）参数：匿名函数，匿名函数可以有三个参数
（3）返回值：所有满足条件的项组成的数组
（4）是否改变原数组：不变
15、join（与字符串里split方法相反）
（1）作用：把数组的每一项按照指定的分隔符拼接成字符串
（2）参数：指定的分隔符，项与项之间用分隔符连接
（3）返回值：拼接好的字符串
（4）是否改变原数组：不变
（5）实例1：console.log(["ABC", "EFG"].join(""));//ABCEFG
（6）实例2：console.log(["ABC", "EFG"].join("D"));//ABCDEFG
16、every：方法用于检测数组的所有元素是否都满足指定条件，返回值为boolean。
17、some：方法用于检测数组中是否有元素满足指定条件,返回值为boolean。
18、reduce：累加，将最后一次计算结果暴露出去；可以作为高阶函数，用于函数的compose。接受四个参数：初始值（或回调函数上1次的返回值），当前元素值，当前索引，调用 reduce 的数组
（1）示例一
var ary=[1,3,2,4,3,2];
var aryTotal=ary.reduce(function (total,num) {
return total+num;
});
console.log(aryTotal);
（2）示例二
var todos = [{
score: 12,
completed: true
}, {
score: 21,
completed: false
}, {
score: 35,
completed: true
}, {
score: 47,
completed: true
}, {
score: 95,
completed: false
}];
const totalScore = todos.reduce(function(total, item){
return item.completed ? total + item.score : total
},10000);
console.log(totalScore);
19、filter：过滤
（1）示例一
var aryOld = [1, 2, 3, 4, 5];
var aryNew=aryOld.filter(function(item){
return item > 3;
});
console.log(aryNew);
（2）示例二
var todos = [{
score: 10,
completed: true
}, {
score: 2,
completed: false
}, {
score: 30,
completed: true
}, {
score: 40,
completed: true
}, {
score: 5,
compelted: false
}];
var trueScore = todos.filter(function(item){
return item.completed;
});
console.log(trueScore);
20、find：查找
（1）示例一
var ary=[1, 5, 10, 15]
ary.find(function(value) {
return value > 9;
}) // 10
（2）示例二
var studentAll = [
{
name: '张三',
gender: '男',
age: 20
},
{
name: '王小毛',
gender: '男',
age: 20
},
{
name: '李四',
gender: '男',
age: 20
}
];
var studentOne=studentAll.find(function (ele) {
return ele.age == 20
});
console.log(studentOne);
21、ES6数组实例方法（在百度上搜"Array find"，菜鸟教程的相关页面有该方法属于ES的第几个版本）
（1）copyWithin()
（2）find()
（3）findIndex()
（4）fill()
（5）entries()
（6）keys()
（7）values()
（8）includes()
（9）flat()
（10）flatMap()
四、字符串里字符重复次数
1、对象法：把一个字母作为对象的属性名，字母出现的次数作为属性值；进而比较属性值的大小。
var str = 'SSSadsdccCCCAdkdkkkkDccdddaaaccCCsSSSSSs';
function maxstr(str) {
var obj = {};
var maxNum = 0;
var maxVal = "";
for (var i = 0; i < str.length; i++) {
var strNum = str.charAt(i).toLowerCase();
if (obj[strNum]) {
obj[strNum]++;
} else {
obj[strNum] = 1;
}
}
for (var attr in obj) {
if (obj[attr] > maxNum) {
maxNum = obj[attr];
maxVal = attr;
} else if (obj[attr] == maxNum) {
maxVal += attr
}
}
return "出现次数最多的字母是：" + maxVal + "；次数是：" + maxNum
}
var valNum = maxstr(str);
console.log(valNum);
2、排序法：先对它们进行排序，再取出小分组和小分组被匹配的次数。
var str = 'SSSadsdccCCCAdkdkkkkDccdddaaaccCCsSSSSSs';
function maxstr(str) {
var maxNum = 0;
var maxVal = "";
str = str.split('').sort(function (one, two) {
return one.localeCompare(two)
}).join('');
//下面正则的意思是："(\w)"字符、"\1"第1个括号、"+"1次到多次、"g全局"、"i"不区分大小写
str.replace(/(\w)\1+/gi, function (bigReg,item) {
if (bigReg.length > maxNum) {
maxNum = bigReg.length;
maxVal = item;
} else if (bigReg.length == maxNum) {
maxVal += item;
}
});
return "出现次数最多的字母是：" + maxVal + "，次数" + maxNum;
}
var valNum = maxstr(str);
console.log(valNum);
五、数组4种去重方法
1、新数组法：重新构建一个新数组，遍历原数组的每一项，如果该项在新数组的索引为-1，则把该项添加到新数组中。
var ary = [21, 32, 32, 4, 5, 61, 61, 21, 4, 5, 61];
function removeMany(ary){
var newAry=[];
for(var i=0; i<ary.length; i++){
if(newAry.indexOf(ary[i])===-1){
newAry[newAry.length]=ary[i];
}
}
return newAry
}
console.log(removeMany(ary))
2、新对象法：如果对象中没有这一项，给对象添加属性名和属性值，如果对象中已经有了，说明是重复的，直接在数组中删除这一项；
var ary = [21, 32, 32, 4, 5, 61, 61, 21, 4, 5, 61];
function removeMany(ary){
var obj={};
for(var i=0; i<ary.length; i++){
var cur=ary[i];
if(obj[cur]===cur){//说明重复了
ary.splice(i,1);
i--;
}else{
obj[cur]=cur;
}
}
return ary
}
console.log(removeMany(ary))
3、sort排序法：先用sort方法对数组进行排序，然后拿前一项与后一项进行比较，如果相等，则删除前一项，同时为了防止数组塌陷，下一次仍从该项开始比较。
var ary = [21, 32, 32, 4, 5, 61, 61, 21, 4, 5, 61];
function removeMany(ary){
ary.sort(function (a, b) {
return a - b;//从小到大
});
for (var i = 0; i < ary.length; i++) {
if (ary[i] === ary[i + 1]) {
ary.splice(i, 1);
i--;
}
}
return ary
}
console.log(removeMany(ary))
4、双循环法：第一个循环，依次取出数组的每一项A；第二个循环，从数组的A项开始，依次与A项进行比较，如果相等则删除，同时为了防止数组塌陷，下一次仍从该项开始比较。
var ary = [21, 32, 32, 4, 5, 61, 61, 21, 4, 5, 61];
function removeMany(ary){
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];
for (var j = i + 1; j < ary.length; j++) {
if (cur === ary[j]) {
ary.splice(j, 1);
j--;
}
}
}
return ary
}
console.log(removeMany(ary))
六、数组3种排序方法
1、冒泡排序（目标：实现升序排列）
var ary = [5, 4, 3, 2, 1];
function bubbleSort(ary) {
for (var i = 0; i < ary.length - 1; i++) {
//正在进行第几次循环
for (var j = 0; j < ary.length - i - 1; j++) {
//本次循环需要执行几次
if (ary[j] > ary[j + 1]) {
var tmp = ary[j];
ary[j] = ary[j + 1];
ary[j + 1] = tmp;
}
}
console.log(ary);
}
return ary;
}
console.log(bubbleSort(ary))
2、插入排序（目标：实现升序排列）
var ary = [50, 40, 30, 20, 10];
function insertSort(ary) {
var left = ary.splice(0, 1);
for (var i = 0; i < ary.length; i++) {
//正在进行第几次循环
var aryAry = ary[i];
for (var j = left.length - 1; j >= 0; ) {
//本次循环需要执行几次
var leftAry = left[j];
if (aryAry < leftAry) {
j--;
if (j === -1) {
left.unshift(aryAry);
}
} else {
left.splice(j + 1, 0, aryAry);
break;
}
}
}
return left;
}
console.log(insertSort(ary));
3、快速排序（目标：实现升序排列）
var ary = [500, 400, 300, 200, 100];
function quickSort(ary) {
if (ary.length <= 1) {
return ary;
}
var num = Math.floor(ary.length / 2);
var numValue = ary.splice(num, 1)[0];
var left = [];
var right = [];
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];
if (cur < numValue) {
left.push(cur);
} else {
right.push(cur);
}
}
return quickSort(left).concat([numValue], quickSort(right));
}
console.log(quickSort(ary));
七、递归
注意，递归前从外向里执行。递归后从里向外执行。
1、虚拟DOM中的递归
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>创建一个虚拟DOM实例</title>
<style>
.list {
color: green;
font-size: 30px;
}
</style>
</head>
<body>
<div>
<div>创建一个虚拟DOM实例</div>
</div>
<script>
function Element(obj) {
this.tagName = obj.tagName;
this.props = obj.props || {};
this.children = obj.children || [];
}
Element.prototype.render = function () {
var el = document.createElement(this.tagName);
var props = this.props;
for (propName in props) {
propValue = props[propName];
el.setAttribute(propName, propValue);
}
this.children.forEach(function (child) {
var elemChild = null;
if (child instanceof Element) {
elemChild = child.render();//从外向里逐个折回。看最后一次递归执行时，发生了什么。
} else {
elemChild = document.createTextNode(child);//最后一次递归执行时，要经过这里。
}
el.appendChild(elemChild);//从里向外逐个添加。
});
return el;
};
var elem = new Element({
tagName: 'ul',
props: { 'class': 'list' },
children: [
new Element({
tagName: 'li',
children: [
new Element({ tagName: 'span', children: ['我是span1','我是span1','我是span1--'] }),
new Element({ tagName: 'span', children: ['我是span2','我是span2','我是span2'] })
]
}),
new Element({ tagName: 'li', children: ['我是span3','我是span3','我是span3',] })
]
});
var elemSelf = elem.render();
document.querySelector('body').appendChild(elemSelf);
</script>
</body>
</html>
2、深克隆中的递归
//{ }.toString.call也可以用Object.prototype.toString.call代替
function isArray(value) { return {}.toString.call(value) === "[object Array]"; }
function isObject(value) { return {}.toString.call(value) === "[object Object]"; }
function deepClone(arrayOrObject) {
var target = null;
if (isArray(arrayOrObject)) target = [];
if (isObject(arrayOrObject)) target = {};
for (var key in arrayOrObject) {
var value = arrayOrObject[key];
if (isArray(value) || isObject(value)) {
target[key] = deepClone(value);
} else {
target[key] = value;
}
}
return target;
}
var clonebefore = { a: 1, b: { c: 3 }, d: { e: [1, 2] } };
var cloneafter = deepClone(clonebefore);
console.log(cloneafter);
3、快速排序中的递归
var ary = [500, 400, 300, 200, 100];
function quickSort(ary) {
if (ary.length <= 1) {
return ary;
}
var num = Math.floor(ary.length / 2);
var numValue = ary.splice(num, 1)[0];
var left = [];
var right = [];
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];
if (cur < numValue) {
left.push(cur);
} else {
right.push(cur);
}
}
return quickSort(left).concat([numValue], quickSort(right));
}
console.log(quickSort(ary));
4、react框架中的递归
var define, module, exports;
return (function outerFn(first, second, third) {
function recursion(number) {
if (!second[number]) {
if (!first[number]) {
var error = new Error("Cannot find module '" + number + "'");
throw error.code = "MODULE_NOT_FOUND", error
}
var module = second[number] = {
exports: {}
};
first[number][0].call(module.exports, function (key) {
var value = first[number][1][key];
return recursion(value ? value : key)
}, module, module.exports, outerFn, first, second, third)
}
return second[number].exports
}
for (var number = 0; number < third.length; number++) recursion(third[number]);
return recursion
//以上两行可以合并为下面一行
//return recursion(third[0]);
//同时下面的"(48)" 应当删掉
})({ 2: [function (_dereq_, module, exports) { console.log(_dereq_) }, { "25": 25, "30": 30 }], }, {}, [16])(16)
八、字符串之为空|含某项|遍历|项位置|位置项
1、空字符串的判断方法
（1）if(/^\s*$/.test(str))//字符串里只含0到多个空格时，为true
注意，if(str&&!str.length)不可以，因为排除了“字符串里只有多个空格”的情况
2、字符串里有item项的判断方法
（1）if(str.indexOf(item)!=-1)
3、遍历字符串
（1）for循环
4、获取item项的位置
（1）str.indexOf(item)
5、获取index位置的项
（1）str.charAt(index)
（2）str[index]
九、数组之为空|含某项|遍历|项位置|位置项
1、空数组的判断方法
（1）if(JSON.stringify(ary)=="[]")//空数组里有空格，字符串里没有空格，结果也是true
（2）if(!ary.length)
2、数组里有item项的判断方法
（1）if(ary.indexOf(item)!=-1)
（2）if(item in ary)
3、遍历数组
（1）for循环
（2）for…in 是ES5标准，循环出来的是key
（3）for…of 是ES6标准，循环出来的是value
4、获取item项的位置
（1）ary.indexOf(item)
5、获取index位置的项
（1）ary[index]
十、对象之为空|含某项|遍历|项位置|位置项
1、空对象的判断方法
（1）if(JSON.stringify(obj)=="{}")//空对象里有空格，字符串里没有空格，结果也是true
（2）if(!Object.keys(obj).length)
（3）if(!Object.getOwnPropertyNames(obj).length)
2、对象里有key属性的判断方法
（1）if(key in obj)
注意，if(obj.key)不可以，因为排除了obj={key:0},obj={key:false},obj={key:null},obj={key:undefined}
3、对象遍历
（1）for…in
4、获取key属性项的位置
（1）对象里面的项是无序的，如果有位置要求，则应该写成数组形式
5、获取index位置的项
（1）对象里面的项是无序的，如果有位置要求，则应该写成数组形式