ES5新增数组方法及字符串相关操作

严格模式和普通模式

严格模式：规避了代码的不规范 不严谨的地方 提高了代码的安全性。
“use strict” 可将该作用域变为严格模式
严格模式有以下特点：
1、变量声明：定义变量时，必须加var声明
2、禁止使用with：

var obj = {
	age:20
}
with(obj){
	console.log(age);
}
// Strict mode code may not include a with statement

3、设立eval作用域

eval("var a = 100;console.log(a)");//设立独立的作用域
console.log(a);  //a is not defined

4、函数中的this指向问题

// 谁调用函数或方法,这个函数或方法里的this就指向谁
function foo(){
	console.log(this);
}
foo();  //打印undefined，不可省略window
window.foo();  //可正常打印window对象

5、删除变量，变量无法删除，会报错

var a;
delete a;
//Delete of an unqualified identifier in strict mode.

6、函数参数不能重名

function foo(a,a){
	console.log(a);
}
foo(10,20);
//Uncaught SyntaxError: Duplicate parameter name not allowed in this context

7、八进制字面量表示法

var num = 0o13;  //表示八进制
console.log(num);  //11

8、arguments不追踪参数变化

function foo(x){
	console.log(arguments[0]);  //1
	x = 2;
	console.log(arguments[0]);  //1
}
foo(1);

ES5新增数组操作方法

var arr = [1,2,3,4];    //创建一个arr数组，供以下方法使用

1、indexOf arr.indexOf(item) 返回item在数组arr中的索引值,无就返回-1

console.log(arr.indexOf(3),arr.indexOf(22));
// 2 -1
// indexOf(n) 返回n在数组中的索引值,无就返回-1

2、forEach 遍历数组中的每个元素，可得到每一项的值和索引值

arr.forEach(function(item,index){
	console.log(item,index);
})
// 1 0
// 2 1
// 3 2
// 4 3

3、map map和forEach类似，可有运算之后的返回数组

var a = arr.map(function(item,index){
	return item*1.3;
})
console.log(a);
//[1.3, 2.6, 3.9000000000000004, 5.2]

4、filter 过滤出满足条件的数组元素，返回数组

var a = arr.filter(function(item){
	return item>1;
})
console.log(a);
//[2, 3, 4]

5、some 返回布尔值，只要有一个满足，就返回true

var a = arr.some(function(item){
	return item>1;
})
console.log(a);
// true 存在item>1，故结果为true

6、every 返回布尔值，所有的都满足，才返回true

var a = arr.every(function(item){
	return item>1;
})
console.log(a);
// false 存在1不大于1，故结果为false

7、reduce(对数组中的所有元素调用指定的回调函数。
该回调函数的返回值为累积结果，
并且此返回值在下一次调用该回调函数时作为参数提供。)

// 初始时，a为第一个元素，b为第二个元素
// 计算a+b的值，结果赋给a，b向后移一位
var sum = arr.reduce(function(a,b){
	return a+b;
})
console.log(sum);
// 10 返回值为各项的和


var arr1 = [[1,2],[3,4],[5,6]];
var sum1 = arr1.reduce(function(a,b){
	return a.concat(b);
})
console.log(sum1);
//[1, 2, 3, 4, 5, 6]

字符串相关操作

var str = "abc123";

1、charAt() str.charAt(index) 取到对应索引位上的字符，不传参数时，返回第一个字符

console.log(str.charAt(),str.charAt(4));
// a 2

2、indexOf() str.indexOf(“b”)返回字符b在字符串str中的索引值，无就返回-1

console.log(str.indexOf("b"));
// 1

3、slice str.slice(1,3)返回开始索引值到结束索引值的字符串（不包含结束字符）

console.log(str.slice(1),str.slice(1,3),str.slice(3,1));
// bc123 bc
// slice 如果前面的索引值大于后面的索引值，则无效

4、substring 与slice类似，如果索引值颠倒位置，也能正常输出

//substring 如果第二个参数小于第一个参数,则交换位置
console.log(str.substring(1),str.substring(1,3),str.substring(3,1));
// bc123 bc bc

5、substr 也是截取，第二个参数表示截取的长度，最多两个参数

// 第二个参数表示截取的长度
console.log(str.substr(1),str.substr(1,3),str.substr(1,3,"af"));
// bc123 bc1 bc1

6、split 分割,从参数进行分割,返回值为数组

console.log(str.split(),str.split(""),str.split(1));
// ["abc123"]   ["a","b","c","1","2","3"]  ["abc","23"]

7、replace 替换，第二个参数替换掉第一个参数

console.log(str.replace("ab","*"));
// *c123

8、concat 字符串拼接

console.log(str.concat("123"));
// abc123123

9、trim 去掉首尾的空格

// 去掉首尾的空格，不能去掉中间的空格
var str1 = "   1 2 3  s ";
console.log(str1.trim());
console.log(str1);
// 1 2 3  s
//    1 2 3  s

ASCII字符集相关操作

1、charCodeAt(index)，输出该字符串对应索引值的字符在ASCII字符集中的编码

var str = "0123ABCabc";
console.log(str.charCodeAt(0));    //48
console.log(str.charCodeAt(4));    //65
console.log(str.charCodeAt(7));    //97

2、fromCharCode(num)，给一个数字，返回该编码所对应的字符

console.log(String.fromCharCode(48));    //0
console.log(String.fromCharCode(65));    //A
console.log(String.fromCharCode(97));    //a

案例

已知字符串“a,a,b,c,c,d”，统计每个字符出现的次数
结果显示 a 2、b 1、c 2、d1，去掉重复的字符，使结果显示 abcd

var str = "a,a,b,c,c,d";
var arr = str.split(",");
// 将字符串按逗号分隔,分隔为数组
			
var obj = {};
for(var i=0 ; i<arr.length ; i++){
	if(obj[arr[i]] === undefined){
		obj[arr[i]] = 1;
	}else{
		obj[arr[i]]++;
	}
}
			
var result = "";
var zimu = ""; 
for(var i in obj){
	result += i+" "+obj[i]+"、";
	zimu += i+" ";
}
// 去掉字符串的最后一个元素
result = result.substr(0,result.length-1);
document.write(result+"<br>");
document.write(zimu);