javascript06--数组方法用法以及严格模式

 严格模式 'use strict';

            //var date=new Date();//获取当前的日期

 //alert(date.toLocaleString());//本地字符串的格式

 //alert(date.toLocaleDateString());//本地字符串的格式

 //alert(date.toLocaleTimeString());//本地字符串的格式

 所谓严格模式，从字面上就很好理解，即更严格的模式，在这种模式下执行，浏览器会对JS的要求更苛刻。

 设立"严格模式"的目的，主要有以下几个：

消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;

消除代码运行的一些不安全之处，保证代码运行的安全；

提高编译器效率，增加运行速度；

为未来新版本的Javascript做好铺垫

 "严格模式"有两种调用方法，适用于不同的场合。

针对整个脚本文件  针对单个函数

 语法和行为改变

全局变量显式声明：严格模式下，变量都必须先用var命令声明，然后再使用。

禁止使用with语句：因为该语句无法在编译时就确定，属性到底归属哪个对象。

禁止this关键字指向全局对象

函数不能有重名的参数

禁止八进制表示法

禁止使用arguments.callee

 ES5新增数组操作方法（ECMAscript3 ECMAscript5 ECMAscript6）

n 位置方法----indexOf()  lastIndexOf()返回要查找的项在数组中的索引位置，没找到的情况下返回-1。（两个参数：要查找的项和（可选的）表示查找起点位置的索引）

indexOf() 方法从数组的开头开始向后查找。

lastIndexOf() 方法则从数组的末尾开始向前查找。

n 迭代方法（不会改变原数组）

两个参数：

第一个参数：要在每一项上运行的函数

此函数会接收三个参数：数组项的值、该项在数组中的位置、数组对象本身。

第二个参数：（可选的）运行该函数的作用域对象（影响 this 的值）。

 

every()方法：类似与逻辑与符号的特点。

对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true 。

arr.every(function(){

alert(this)//hello

},'hello');*/

//第一个参数：要在每一项上运行的函数

//第二个参数：（可选的）运行该函数的作用域对象,函数对象的this指向谁。

 

//every()方法：类似与逻辑与符号的特点。

//对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true 。

//some()方法：类似与逻辑或符号的特点。

//对数组中的每一项运行给定函数，如果该函数对任意一项返回 true ，则返回 true 。

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

/*var arr=[1,2,3,4,5,6,7,8,9];

var b=arr.every(function(value,index,arr){//数组项的值、该项在数组中的位置、数组对象本身

return value>0;

});

alert(b);//true*/

some()方法：类似与逻辑或符号的特点。

/*var arr=[1,2,3,4,5,6,7,8,9];

var b=arr.some(function(value,index,arr){//数组项的值、该项在数组中的位置、数组对象本身

return value>8;

});

alert(b);//true*/

对数组中的每一项运行给定函数，如果该函数对任意一项返回 true ，则返回 true 。

 

filter() 方法：

对数组中的每一项运行给定函数，返回该函数结果为 true 的项组成的数组。

/*var arr=[9,8,5,7,8,9,6,5,4,7];

var b=arr.filter(function(value){//整个返回结果是一个数组(true)

return value>5

});

alert(b);//9,8,7,8,9,6,7*/

 

 

var arr=[9,8,5,7,8,9,6,5,4,7];

var b=arr.filter(function(value,index){//整个返回结果是一个数组(true)

return arr.indexOf(value)==index

});

alert(b);//985764

map() 方法：

对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

返回就是数组，不考虑true或者false；

/*var arr=[9,8,5,7,8,9,6,5,4,7];

var arrnew=[];

var b=arr.map(function(value,index){

if(arr.indexOf(value)==index){

return value;

}

});

//console.log(b);//[9, 8, 5, 7, undefined, undefined, 6, undefined, 4, undefined]

for(var i=0;i<b.length;i++){

if(b[i]){

arrnew.push(b[i]);

}

}

 

var arr=[9,8,5,7,8,9,6,5,4,7];

var arrnew=[];

arr.map(function(value,index){

if(arr.indexOf(value)==index){

arrnew.push(value);

}

});

alert(arrnew);

 

/*var arr=[1,2,3,4,5,6,7,8,9];

var c=arr.map(function(value){

return value*100;

})

alert(c);*/

 

/*var arr=[1,2,3,4,5,6,7,8,9];

var arrnew=[];

var c=arr.filter(function(value){

if(value>0){

arrnew.push(value*100)

}

});

alert(arrnew);*/

 

//var arr=['a','b','c','d','e','f'];

/*var arr=[1,2,3,4,5,6,7,8,9];

arr.forEach(function(value,index,array){//类似与for循环

console.log(value*100+'--'+index+'--'+(array==arr));

})*/

forEach() 方法：

对数组中的每一项运行给定函数。这个方法没有返回值。

 

n 归并方法---- reduce()  reduceRight()

n *var arr=[1,2,3,4,5,6,7,8,9,10];

n var sum=arr.reduce(function(prev,next){

n console.log(prev+'------'+next);

n return prev+next;

n });

n 

n alert(sum);*/

n 

n /*var arr=[1,2,3,4,5,6,7,8,9,10];

n var sum=arr.reduce(function(prev,next){

n console.log(prev+'------'+next);

n return prev<next;//prev的结果

n });

n 

n alert(sum)

这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。

reduce() 方法从数组的第一项开始，逐个遍历到最后。

reduceRight() 方法从数组的最后一项开始，向前遍历到第一项。

两个参数：每一项上调用的函数和（可选的）作为归并的初始值。

调用的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。

 包装对象

思考：JavaScript是面向对象的语言，使用”.”操作符可以访问对象的属性和方法，而对于基 本类型（null, undefined, bool, number, string）应该是值类型，没有属性和方法。

n 概念：使用字符串、数字或布尔值的属性和方法时，创建的临时对象称做包装对象，它只是偶尔用来区分字符串值和字符串对象、数字和数值对象以及布尔值和布尔对象。

n 过程：只要是引用了字符串的属性和方法，JavaScript就会将字符串值通过new String(s)的方式转为内置对象String，一旦引用结束，这个对象就会销毁。数字和布尔值的处理也类似。null和undefined没有对应对象，所以不是包装对象。

 字符串的定义

n 也可使用 var str = new String("abc");  注意此刻str为object类型

n var str=“abc”;

 字符串的属性length---字符串的长度

 字符串的方法

n charAt(num):返回对应字符串索引的内容。

n var str='我很帅爱丑';

n alert(str.charCodeAt(4));//19985n返回对应的字符串索引的内容的unicode编码*/

n 

n //String.fromCharCode(unicode编码);将参数中的unicode编码返回成对应的字符串的内容，多个编码用逗号分隔。

n 

n 

n //alert(String.fromCharCode(19985));

n /*var str='';

n for(var i=0;i<50000;i++){

n str+=String.fromCharCode(i);

n }

n document.write(str);*

n charCodeAt(num):返回对应的字符串索引的内容的unicode编码

n String.fromCharCode(unicode编码);将参数中的unicode编码返回成对应的字符串的内容，多个编码用逗号分隔。

n indexOf(‘查找字符’, ’开始位置’):从指定的位置从左往右查找对应的字符，并返回对应字符的位置。如果第二个参数为负数，默认当做0来处理。 没有找到就返回-1。

n //indexOf()

n 

n  //alert(arr.indexOf('c'));//2 返回下标

n //alert(arr.indexOf('h'));//如果没有找到返回-1

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

n //alert(arr.indexOf('c'));//2

n //alert(arr.indexOf('c',3));//5

 //indexOf:第一个参数：查找的数组项，第二个参数：查找的起始位置。

 //alert(arr.lastIndexOf('c'));//5

 //alert(arr.lastIndexOf('c',3));//2

 //lastIndexOf:从数组的末尾开始向前查找。下标还是一样的。

 lastIndexOf(‘查找字符’,’开始位置’):类似于indexOf方法，但查找顺序是相反，为从后往前找。

 replace替换字符串  string.replace("tmd", "*");

 /*var str='tmdtmdtmdtmdtmdtmd';

 alert(str.replace('tmd','*'));*/

 

/*var str='tmdtmdtmdtmdtmdtmd';

 alert(str.replace(/tmd/g,'*'));//正则*/

   //替换字符串,第一个参数：被替换字符串，第二个参数：替换字符串

 split——根据分隔符、拆分成数组

 /*var str='abcdefghijk';

 alert(str.split(''))//根据分隔符、拆分成数组  类型：object

 */

 

 /*var str='cbacdddeafgdahidjdk';

 //alert(str.split('d'))//根据分隔符、拆分成数组  类型：object

 //alert(str.split('a').length-1);//3

 alert(str.split('a',2));//第二个参数用来限制数组的长度，多余的切掉。*/

把一个字符串分割成一个数组。通过传递一个参数来分割。参数就是分割字符串的 符号。如果参数为空，也是数组，只有一个数据。第二个参数用来限制数组的长 度，多余的切掉。

*var str='abcdefg';

//alert(typeof str.split());//object

str.split();

alert(str[3]);

n substring()：用来截取字符串的内容

没有参数全部截取。相当于从第0位开始截取。

一个参数代表截取从参数的位置往后的字符串。

两个参数代表截取两个参数之间的字符串，包括第一个参数的位置。

两个参数的时候，当第二个参数小于第一个参数，自动交换位置。

如果是负数，当做0来处理。

n substr(start, length); 用来截取字符串的内容

start：开始的索引，如果为负数，从后往前进行截取，包括开始的索引。

length：截取的长度。

var str='abcdefg';

//alert(str.substring());//没有参数全部截取。相当于从第0位开始截取。

//alert(str.substring(1));//一个参数代表截取从参数的位置往后的所有字符串

//alert(str.substring(2,4));//cd 两个参数代表截取两个参数之间的字符串，包括第一个参数的位置。

//alert(str.substring(4,2));//两个参数的时候，当第二个参数小于第一个参数，自动交换位置。

//alert(str.substring(-4,2));//ab  如果是负数，当做0来处理

//alert(str);//abcdefg 对原字符串没有影响

//var str='abcdefg';

 

//alert(str.substr(2,3));//cde   substr(开始位置, 截取长度); 用来截取字符串的内容

//alert(str.substr(-4,3));//def //如果为负数，从后往前进行截取，包括开始的索引。

 

//toUpperCase()转换成大写

//toLowerCase()转换成小写

/*var str='abcdefg';

alert(str.toUpperCase());

*/

/*var str='ABCDEFG';

alert(str.toLowerCase());*/

 

//alert(Math.PI);

//数字(0-9) 48--57  

//大写字母(A-Z)：65--90

//小写字符(a-z)：97--122

//var str='9';

//alert(str.charCodeAt(0));

/*var str='ab23A#VBFEab@#%';

var numcount=0;

var uppercount=0;

var lowercount=0;

var tscount=0;

 

for(var i=0;i<str.length;i++){

if(str.charAt(i)>='a' && str.charAt(i)<='z'){

lowercount++;

}

}

 

alert(lowercount);*/

/*var strcount={

a:1,

b:1,

c:1,

d:1

}

//strcount.a;

//strcount[a]

var str='aabccdfffgjjjjjjjjj';

var arr=str.split('');//将字符串转换成数组//['a',abccdfffgjjjjjjjjj]

var newArr=[];//定义接收去重后的数组

var strcount={};//定义一个对象，接收每个字符和字符的个数

for(var i=0;i<arr.length;i++){

var bstop=true;//没有重复

for(var j=0;j<newArr.length;j++){

if(arr[i]==newArr[j]){

var count=strcount[arr[i]];//属性（字符）的值赋给count

count++;//满足if条件count累加

strcount[arr[i]]=count;//将属性值赋给对象

bstop=false;

break;

}

}

if(bstop){//没有重复

strcount[arr[i]]=1;//没有重复，值为1

newArr.push(arr[i]);

}

}

/*console.log(strcount);*/

/*for(var x in strcount){

console.log(x+':'+strcount[x]);

}*/

//console.log('去重后的字符串：'+newArr.join(''));*/

n toLowerCase、toUpperCase

toUpperCase()转换成大写

toLowerCase()转换成小写