标签：
/**
* Created by Administrator on 2015/7/11 0011.
*/
//引用类型:它的值是引用类型的一个实例（数据结构）：用于将数据和功能组织起来，也称为类，
//创建新对象
var person=new Object();
//这样创建了Object()一个实例，然后将这个实例赋值给person变量《它可以用于存储和传输数据》
//创建object()方式，如下
var person=new Object();
//第2种通过键值对方式，如下
var person={name:‘Nicholas‘,age:29,5:true};
//这里的29是数字它会自动转换字符串
//还可以创建为空的{}功能与new Object()相同,如下
var person={};
person.name=‘Nicholas‘;
person.age=29;
//官方推荐使用键值对方式来创建对象，如下
function dictdisplay(args){
var out=‘‘;
if(typeof args.name==‘string‘){
out+=‘Name:‘+args.name+‘\n‘;
}
if(typeof args.age==‘number‘){
out+=‘Age‘+args.age+‘\n‘;
}
alert(out)
//if(args.name instanceof ‘string‘){
// out+=‘Name:‘+args.name+‘\n‘;
//}
//if(args.name instanceof ‘number‘){
// out+=‘Age‘+args.age+‘\n‘;
//}
//alert(out)
}
dictdisplay({
name:‘Nicholas‘,age:29
});
dictdisplay({
name:‘Nicholas1‘
});
/*在dictdisplay(args)带了args参数，这个参数中带有name和age(也可以不存在这2个属性),在函数内
部
* 通过typeof操作符来检测这些属性是否存在，然后基于这些情况打印一条显示消息，然后调用这个函
数，上面2个都可以正常打印，一般来说，（所有的语言《我学过的》）
* 都是通过.方式来访问这个属性，语法如下
* obj[‘str‘]或者obj.str方式，
* 这2种方式没有什么变化，obj[‘str‘]的优点是：通过变量来访问属性，如果属性名中包含会语法错
误的字符，或者属性名使用的关键字或者保留字，也可以使用[]来表示，如下
* obj[‘str1 str2‘]=obj,注意除非是使用变量来访问这个属性，一般情况下通过.号来访问即可
*
* */
//Array数组，特点是可以保存你需要的任何类型数据,语法如下
var colors=new Array();
//比如创建一个名为数组20，如下创建
var colors=new Array(20);
//也可以通过[]这样的方式创建，如下
var colors=new Array(‘red‘,‘blue‘,[‘a‘,‘b‘,(1),2]);
//创建数组第2种方式，如下
var colors=[‘red‘,‘blue‘];
var name=[];//创建空列表(我还是喜欢称列表)
var dog=[1,2,]//打印1,2,undefined列表，在其他浏览器只显示1,2数组，在IE8胶之前版本中，js实
现数组存在bug,官方不推荐这样使用
//通过索引方式（以0开始,-1最后一个）
var colors=[‘red‘,‘blue‘];
alert(colors[0]);
//修改元素
colors[1]=‘dogs‘;
// 增加元素(这样就会自动增加长度为1)
colors[2]=‘dogs1‘;
//判断列表的长度:lenght:(特点它不是只读的，通过这个属性，可以从数组的末尾移除或者增加)
alert(‘长度是:‘+colors.length);
colors.length=2;//通过设置为2将移除最后一项（就是位置为2的那一项），增加与移除原理相同
alert(colors[3]);//undefined;
//新增元素在末尾如下
colors[colors.length]=‘blues‘;
alert(colors);
//数组最后的索引项需要lenght-1项，如下
colors[99]=‘123‘;
alert(colors.length);//100
//数组它最多可以包含4294967295个项，如果超出这个上限，就异常
//检测数组
if(colors instanceof Array){
//语句体
}
//js5中新增一个列表方法，如下:Array.isArray():确定是否是数组
if(Array.isArray(colors)){
//语句体
}
//转换方法(toLocaleString(),toString()拼接,valueOf()它是返回数组)
var colors=[‘red‘,‘blue‘,‘green‘];
//返回结果都是一样，但实际是不同的，更多可以谷歌或者文档
alert(colors.toString());
alert(colors.valueOf());
alert(colors);
//toLocaleString():如果是数组使用这个方法时，它会创建一个数组值的以逗号分隔的字符串，与
valueOf(),toString()方法的唯一不同的地方在于，为了取得每一项的值，每次都会调用
toLocaleString()方法
var person1={toLocaleString:function(){
return ‘Python‘
},
toString:function(){
return ‘C++‘
}};
var person2={toLocaleString:function(){
return‘Java‘
},toString:function(){
return ‘c#‘
}};
var person=[person1,person2];
alert(person);//首先会调用.toString()方法
alert(person.toString());//同上面结果
alert(person.toLocaleString());
//join()方法可以使用不同的分隔符来构建字符串，如下
var colors=[‘red‘,‘blue‘,‘green‘];
alert(colors.join(‘,‘));
alert(colors.join(‘|‘));
//堆和队列方法(所有语言)
//堆(lifo)，特点:后进先出,push
//push()方法可以接受任意数据参数，把它们逐个添加到数组末尾，并返回修改后数组的长度,pop()方
法则从数组末尾移除最后一项，从而减少数组lenght值，然后返回移除的项，如下
var colors=new Array();
var count=colors.push(‘red‘,‘green‘);//插入2项
alert(count);
count=colors.push(‘dog‘);//插入一项
alert(count);
var item=colors.pop();//取得最后一项
alert(item);
alert(colors.length);
//使用[]这个方式与Array()一样，所以不在说明
//队列(fifo)先进先出，在列表末端添加项，从列表前端移项,shift()它能够移除数组中第一个项并返
回该项，同时将数组减少1，如下
var colors=new Array();
var count=colors.push(‘red‘,‘green‘);//插入2项
alert(count);
count=colors.push(‘dog‘);//插入一项
alert(count);
var item=colors.shift();//取得最后一项
alert(item);
alert(colors.length);
//unshift()它能够在数组前端添加任意项并返回新数组长度，如果与pop()一起使用，可以制作反向模拟队列，即在数组前端添加项，在末尾移除项，如下
var colors=new Array();
var count=colors.push(‘red‘,‘green‘);//插入2项
alert(count);
count=colors.unshift(‘dog‘,‘cat‘);//插入一项
alert(count);
var item=colors.pop();//取得最后一项
alert(item);
alert(colors.length);
//重排序方法:reverse()与sort()
var values=[1,2,3,4,5,6]
values.reverse()//反转
alert(values)
//sort()方法也会根据测试字符串的结果改变原来的顺序
//例子
function countsort(v1,v2){
if(v1<v2){
return -1
}else if(v1>v2){
return 1
}else{
return 0
}
}
var s=[0,1,5,10,15];
s.sort(countsort);
alert(s);//0,1,5,10,15
//对上面的函数再一步修改，如下
function countsort(v1,v2){
if(v1<v2){
return 1
}else if(v1>v2){
return -1
}else{
return 0
}
}
var s=[0,1,5,10,15];
s.sort(countsort);
alert(s);//15,10,5,1,0
//对于数据类型或者其他valueOf()方法会返回的数值类型对象，可以使用如下方法
function countd(s1,s2){
return s2-s1
}
//操作方法
//concat()方法可以基于当前数组中所有项创建一个新数组，具体来说，这个方法会先创建当前一个副
本，然后将接受到的参数添加个副本末尾，然后构建新数组，在没有给concat()方法传递参数情况下，
它只复制当前数组并返回副本，如果传递参数给concat()方法一个或者多个数组时，则该方法将会在这
些数组中每一项添加到结果数组中，如果传递的值非数组，那么这些值就会被简单地添加到结果数组末
尾
var counts=[‘red‘,‘geeen‘,‘blue‘];
var counts1=counts.concat(‘yellow‘,[‘black‘,‘brown‘]);
alert(counts);
alert(counts1);
//slice()它能够基于当前数组中一个或者多个项创建新数组，它可以接受1个或者2个参数：开始和结束
位置，在只有一个参数情况下，它会从该指定位置到当前数组末尾所有项，如果指定了2个参数，该方法
返回指定开始和指定结束的位置，但不包括结束位置的项，如下
var counts=[‘red‘,‘geeen‘,‘blue‘,‘yellow‘,‘purple‘];
var counts1=counts.slice(1);
var counts2=counts.slice(1,4);
alert(counts1);
alert(counts2);
//slice()它可以接受负数，与python类似
//splice():向数组中部插入项
//splice()删除，它可以删除任意数量项，只需要指定2个参数：要删除第一项位置和要删除项数,如
slice(0,2)
//splice()插入，可以插入到指定的位置的任意数量项，需要提供3个参数：start,0(要删除项数)和要
插入的项，如果要插入多个项，可以再传入第4，第5，以至任意多个项，如splice(2,0,‘red‘,‘green‘)
//splice()替换,可以向指定位置插入任意数量项，且同时删除任意项，需要3个参数:start,要删除项数
和要插入任意数量项，插入项与删除项可以不相等
//splice()如果没有删除任何则，返回一个空数组，如下代码
var colors=[‘red‘,‘geeen‘,‘blue‘];
var removed=colors.splice(0,1);//删除第一项
alert(‘打印是:‘+colors);
alert(‘替换:‘+removed);
removed=colors.splice(1,0,‘yellow‘,‘orange‘);
alert(‘打印是:‘+colors);
alert(‘空:‘+removed);//打印为空
removed=colors.splice(1,1,‘yellow‘,‘purple‘);
alert(‘打印是:‘+colors);
alert(‘替换:‘+removed);
//位置方法
//indexOf()与lastIndexOf()这2个方法都接受2个参数:要查找项和（可选的）查找起点位置索引
//indexOf()方法从数组开始（位置0开始）查找，lastIndexOf()从数组末尾开始向前查找
//这2个方法，如果未在数组中找到均返回-1结果，在比较第一个参数与数组中每一项时，会使用全等于
操作，如下
var num=[1,2,3,4,5,4,3,2,1];
alert(‘查找到:‘+num.indexOf(4));//注意是从0开始，所以是3
alert(‘查找到:‘+num.lastIndexOf(4));//所以是5
//迭代方法（5个方法）：这5个都接受2个参数：要在每一项上运行函数和（可选的）运行该函数作用域
对象--影响this的值，传入这些方法中的函数会接受三个参数(数组项值，该基岩 数组中位置和数组本
身)，如下
/*
* every()对数组中每一项运行给定函数，如果该函数对每一项都返回true,则返回true
* filter()对数组中每一项运行给定函数，返回该函数会返回true的项组成的数组
* forEach()对数组中每一项运行给定函数，这个方法没有返回值
* map()对数组中每一项运行给定函数，返回每次函数调用结果组成数组
* some()对数组中每一项运行给定函数，如果该函数对任一项返回true，则返回true
* 以上方法都不会修改数组中包含的项
* some与every:它们都用于查询数组中的项是否满足某个条件，对every来说，传入函数必须对每一项都
是true
* 这个方法才返回true，否则只返回false,some方法传入函数对数组中某一英返回true就会返回true，
如下代码*/
var num=[1,2,3,4,5,4,3,2,1];
var everyResult=num.every(function(item,index,array){
return item>2
});
alert(everyResult);//false,它只符合部分
var everyResult=num.some(function(item,index,array){
return item>2
});
alert(everyResult);//true
//filter()利用指定的函数克理否在返回数组中包含某一项，如下
var everyResult=num.filter(function(item,index,array){
return item>2
});
alert(everyResult);//34543
//map()对数组中每一项在原始数组中对应 项运行传入函数结果，如下
var everyResult=num.map(function(item,index,array){
return item*2
});
alert(everyResult);//2,4,6,8,10,...
//forEach()对数组中每一项运行传入的函数，它是没有返回值的，如下
num.forEach(function(item,index,array){
//语句体
})//
//归并方法
//reduce()与reduceRight()这2个方法都会迭代数组所有项，然后构建最终返回值
//reduce()方法从数组第一项开始，逐个遍历到最后，而reduceRight()从最后一个开始，向前遍历到第
一项
//接受2个参数：一个是在每一项上调用函数和（可选的）作为归并基础的初始值，传给reduce()与
reduceRight()
//的函数接收4个参数：前一值，当前值，项索引和数组对象，这个函数返回的任何项都会作为每个参数
自动传给下一项，第一次迭代发生在数组的第二项上，因此第一个参数是数组第一项，第二个参数就是
数组的第二项，
values=[1,2,3,4,5];
sum=values.reduce(function(prev,cur,index,array){
return prev+cur
});;
alert(sum);
//Date(utc国际协调时间)从1970年1月1日0点开始
//创建日期
var now=new Date();
//Date.parse():接收一个表示日期字符串，然后尝试根据这个字符串返回相应日期毫秒秒
//ECMA-262没有定义Date.parse()支持那些格式，以美国浏览器通常接收以下几种日期格式:
/*月/日/年，如6/1/2015;
* 英文月，日，年,如January,12,2014;
* 英文星期几，月，日，年，如Tue May 25 2004:00:10:20 Gmt-0700;
* iso 8601扩展格式 YYYY-MM-DDTHH:mm:ss:sssZ如2014-05-25T00:00:00*/
//创建日期
var date=new Date(Date.parse(‘May,25,2005,10:20:30‘));
//Date.parse()如果不能为日期，就返回Nan,也可以直接写如下
var date=new Date(‘May,25,2005,10:20:30‘);//这样会在后台调用Date.parse()方法
//alert(date);
//Date.UTC():日期毫秒，分别表示：年月（1月是0，二月是1，以此类推）日(1-31)，小时（0-23），
分，秒，毫秒，在这几个参数中，前2个是必需的，其他几个可选，如果不写入，默认以0 表示
//例子
var utc=Date(Date.UTC(2000,7))//表示2000年6月1号午夜0点
//alert(utc)
//gmt创建的
var utc=new Date(Date.UTC(2000,4,5,17,55,55))//表示2000年5月5号下午5:55:55
//alert(utc)
//本地创建的
//var locast=new Date(2000,4,5,17,55,55)
//alet(‘本地:‘+locast)
//时间戳计算
//var start=new Date().now();//开始时间
//调用函数:doSomething()
//停止时间
//var end=Date().now();
//result=end-start;//进行计算
//继承方法:date()重写了:tolocalestring():会与浏览器设置的地区相适应格式返回日期和时间，包
括pm,am,tostring():返回带有时区信息的日期和时间，一般以军用时间（0到23小时）,
//在不同浏览器下面,上面这2个方法都会输出pst()太平洋标准时间
// valueof()：不返回字符串，返回的是日期的毫秒，然后可以进行比较，如下
//var d1=new Date(2006,1,2)
//var d2=new Date(2004,1,2)
//alert(d1>d2)
//日期格式化方法如下
/*
* toDateString()星期几，月，日，年
* toTimeString()时分秒时区
* toLocaleDateString()星期几，月，日，年
* toLocaleTimeString()时分秒
* toUTCString()实现格式完整的utc日期*/
//日期/时间组件方法（请访问文档或者w3cshool文档）
//常用的几个
date=new Date();
alert(‘年份:‘+date.getFullYear())
alert(‘月份:‘+parseInt(date.getMonth()+1))
alert(‘天数:‘+parseInt(date.getDate()))
alert(‘小时:‘+parseInt(date.getHours()))
alert(‘分:‘+parseInt(date.getMinutes()))
alert(‘秒:‘+parseInt(date.getSeconds()))
alert(‘星期:‘+parseInt(date.getDay()))
//RegExg（正则表达式）
//语法:var regExg=/pattern/flags
//patten:可以是任何简单或者复杂的正则表达式，可以是字符串，分组，向前或者身后查找，限定符
等，每个正则表达式都可以副一个或者多个标志(flags)用以标明正则表达式行为，3个标志
/*g:全局模式:应用于所有字符串，而非在发生第一个匹配项时立即停止
* i:不区分大小写,也就是忽略字符串大小写
* m:多行，即在到达一行文本末尾时还会继续查找下一行中是否存在与模式匹配的项*/
//例子
var p1=/at/g;//匹配字符串所有at的实例
var p2=/[bc]at/i;//匹配第一个字符串bat或cat，不区分大小写
var p3=/.at/gi;//匹配所有以at结尾的3个字符组合，不区分大小写
var p4=/\.at/gi;//匹配所有.at不区分大小写
//rexexp创建，如下
var regexg=new RegExp(‘[bc]at‘,‘i‘);
//例子
var re=null,i;
for(i=0;i<10;i++){
re=/cat/g;
re.test(‘catastrophe‘)
}
for(i=0;i<10;i++){
re=new RegExp(‘cat‘,‘g‘);
re.test(‘catastrophe‘)
}
//regexp实例属性
/*global：布尔，表示是否设置了g标志
* ignoreCase:布尔,表示是否设置了i标志
* lastIndex:整数,表示开始搜索下一个匹配项字符位置，从0算起
* multiline:布尔，表示是否设置m标志
* source:正则表达式字符串表示，按照字符量形式而非传入构建中的字符串模式返回*/
//例子
//var p1=/\[bc]at/i;
//alert(p1.global);//false
//alert(p1.ignoreCase);//ture
//alert(p1.multiline);//false
//alert(p1.lastIndex);//0
//alert(p1.source);//\[bc]at
//Regexp实例方法
//正则表达式主要方法:exec()：主要是专门为捕获而设计的,接受一个参数，即要应用模式的字符串，
然后返回包含第一个匹配项信息的数组或者在没有匹配项情况下返回null,返回数组虽然是Array实例，
饮食个额外属性:index和input
//index匹配项在字符串位置,input表示应用正则表达式的字符串，在数组中第一项与整个模式匹配的
字符串，其他项是与模式中捕获的字符串（如果没有被捕获，则该数组中只包含一项）
//例子
var text=‘mon and dad and bady‘;
var p1=/mon(and ada( and bady)?)?/gi;
var m1=p1.exec(text);
//alert(m1.index);//0
//alert(m1.input);//mon and dad and bady
//alert(m1[0]);//mon
//alert(m1[1]);//undefined
//alert(m1[2]);//undefined
//alert(m1);//mon,,
//对exec()方法而言，在模式中g标志，每次也只会返回一个匹配项，在不设置g标志时，在同一个字符
串上多次调用exec()将始终返回第一个匹配项的信息，在设置g标志情况下，每次调用exec()则会在字
符串中继续查找新匹配项，如下
var text=‘cat,bat,sat,fat‘;
var p1=/.at/;//这个不是全局模式，每次调用exec()返回都是第一个匹配项(cat)
var m1=p1.exec(text);
//alert(m1.index);//0
//alert(m1[0]);//cat
//alert(m1.lastIndex);//undefined
//
//var m1=p1.exec(text);
//alert(m1.index);//0
//alert(m1[0]);//cat
//alert(m1.lastIndex);//undefined
//var p2=/.at/g;//全局模块，每次调用exec()都会返回字符串下一个匹配项，直到搜索到字符串为止
,lastIndex的值每次在调用exec()会增加，在非全局模式下lastIndex的值不会改变
//var m2=p2.exec(text);
//alert(m2.index);//0
//alert(m2.lastIndex);//undefined
//alert(m2[0]);//cat
//alert(m2.index);//0
//alert(m2.lastIndex);//undefined
//alert(m2[0]);//cat
//正则表达式第2个方法:test():接受一个字符串参数，在模式与该参数参数的情况下返回true，否则
为false，在只知道字符串现某个模式是否匹配，但不需要其文本内容时，这个test()很方便
//注意test()经常与if语句合用,如下
var text1=‘000-00-00‘;
var text2=/\d{3}-\d{2}-\d{4}/
if(text2.test(text1)){
alert(‘匹配成功‘);
}
//regexp实例继承了tolocalestring()与tostring()方法都返回正则表达式字面量，如下
var p3=new RegExp(‘\\[bc\\]at‘,‘gi‘);
//alert(p3.toString());
//alert(p3.toLocaleString())
////valueOf()方法返回正则表达式表示
//alert(p3.valueOf());
//RegExp构造函数属性
//注意:opera浏览器对短属性名不支持
/* 长属性名 短属性名 说明
input $_ 最近一次要匹配的字符串 ,opera未实现
lastMatch $& 最近一次匹配的项 ,opera未实现
lastParen $+ 最近一次匹配捕获级,opera未实现
leftContext $‘ input字符串的lastMatch之前的文本
multiline $* 布尔值，表示是否所有表达式都使用多行模式,IE与opera
未实现
rightContext $‘ input字符串的lastMatch之后的文本
使用这上面的属性可以从exec()或者test()执行的操作中提取更具体的信息，如下
* */
//长属性名
var text=‘this has been a short summer‘;
var p2=/(.)hort/g;
//if(p2.test(text)){
// alert(RegExp.input);//this has been a short summer
// alert(RegExp.leftContext);//this has been a
// alert(RegExp.rightContext);//summer
// alert(RegExp.lastMatch);//short
// alert(RegExp.lastParen);//s
// alert(RegExp.multiline);//false
//}
//在谷歌浏览器中测试的
//短属性名，我以一个为主，短属性名以[]方式显示，如下
//if(p2.test(text)){
// alert(RegExp.$_);//this has been a short summer
// alert(RegExp["$*"]);
//}
//正则表达式还有9个用于存储捕获组的构造函数，语法如下RegExp.$1
var text=‘this has been a short summer‘;
var p2=/(..)or(.)/g;
if(p2.test(text)){alert(RegExp.$1)}//sh
//模式的局限性
//js不支持一些特性(url:http://www.regular-expressions.info/)需要FQ
/*开始和结束\A,\Z
* 向后查询lookbehind
* 并集和交集
* 原子组atomic grouping
* unicode支持（单字符除外，如\uFFFF）
* 命名捕获组
* s(单行)和x(无间隔)匹配模式
* 条件匹配
* 正则表达式注释
* ^$开始和结束；支持向前查询lookahead,支持编号捕获组*/
//Function
//语法如下
alert(1)
function funcname(num1,num2){
return num1+num2
}
//也可以使用如下方式
var sum=function(num1,num2){
return num1+num2;
}
//接受任意数量参数，如下（不推荐）
//var sum=function(‘n1‘,‘n2‘,‘return n1+n2‘)
//alert(sum(1,2));
sum1=sum;
//alert(sum1(1,2));
//没有重载
function AddNum(num){
return num+10
}
//alert(AddNum(90));
var AddNum=function(num){
return num+20
}
//alert(AddNum(10))
//函数声明与函数表达式
alert(sumcount(10,10));
function sumcount(a,b){
return a+b
}
//下面这样的情况会出现错误，如下
//alert(sumcount(10,10));
//sumcount=function (a,b){
// return a+b
//};
/*
* 在实际情况下，解析器在向执行环境中加载数据时，对函数声明和函数表达式并非一视同仁，解析器
会率先读取函数声明，并使基在执行任何代码之前可用，至于函数表达式，则必须等到解析器执行到它
所有的代码执行，才会被解释
* 在代码开始执行之前，解析器已经通过名为函数声明提升过程，js引擎在第一遍声明函数将它们放到
源代码树顶部*/
//作为值的函数
function call(func1,func2){
return func1(func2)
}
//func1表示函数,func2表示值
function add1(s){
return s+10
}
var result=call(add1,40);
//alert(result);
function getstring(s){
return s+‘你好‘
}
var string=call(getstring,‘python‘);
//alert(string);
//在函数中嵌套函数，如下
function create1(name){
return create2(o1,o2){
var v1=o1[name];
var v2=o2[name];
if(v1<v2){
return -1
}else{
return 1
}
}
}
//更简单的方式，使用键值对方式
//var data=[{name:‘python‘,age:28},{name:‘c++‘,age:10}];
//alert(data);
//
//data.sort(create1(‘name‘));
//alert(data[0].name);
//函数内部属性
//arguments主要用于保存函数参数，它有一个callee属性，该属性是一个指针，例子
function factorial(s){
if(s<=1){
return 1
}else{
return s*factorial(s-1)
}
}
//通过arguments下面的callee属性来实际阶乘
function factorial(s){
if(s<=1){
return 1
}else{
return arguments.callee(s-1)
}
}
//this特殊对象：它是引用函数以执行环境对象，也就是说this在当前页面的全局作用域中调用函数时
，this对象引用就是window,如下
window.color=‘red‘;
var o={color:‘blue‘};
function sayColor(){
alert(this.color)
//this.color求值会转换成window.color求值
}
sayColor()//red
o.sayColor=sayColor//会指向同一个指针变量
o.sayColor()//blue
//caller()保存调用当前函数引用，如果在全局作用域中调用函数，它的值是null
function outer(){
inner()
}
//function inner(){
// alert(inner.caller())
//}
//outer()
//上面的代码会警告框显示，outer()函数的源代码，因为outer()调用了inner(),所以innercaller()
就指向outer()
function inner(){
alert(arguments.callee.caller())
}
outer()
//function属性和方法:lenght和prototype
//lenght表示函数希望接收命名参数个数，如下
function sayName(name1,name2){
//sayName()长度需要lenght:2个:name1,name2
}
alert(sayName.length);
//prototype:保存它们所有实例方法，比如valueOf()等，在创建自定义类型以及实现继承时，使用
prototype属性很重要
//函数非继承方法apply()和call()用于在特定作用域中调用函数，实际上等于设置函数体内this对象
值
//apply()接收2个参数:一是在运行函数的作用域，另一个是参数数组（可以是Array实例，也可以是
arguments对象），如下
function sum1(a,b){
return a+b
}
function sum2(a,b){
sum1.apply(this,arguments)
}
function sum3(a,b){
sum1.apply(this,[a,b])
}
//这边的this它是全局变量，也就是window对象
//call()方法与apply()作用相同，第一参数this值没有变化，变化是其余参数直接传递给函数,如下
function sum(a,b){
return a+b
}
function callsum(a,b){
return sum.call(this,a,b)
}
//如果使用的是arguments或者是一个数组，那么apply()方便，否则使用call()
//apply()和call()可以对函数进行扩展
window.color=‘red‘;
var o={color:‘blue‘};
function sayName(){
alert(this.color)
}
sayName();//red
sayName.call(this);//red
sayName.call(window);//red
sayName.call(o);//blue
//bind()创建一个函数实例
window.color=‘red‘;
var o={color:‘blue‘};
function sayName(){
alert(this.color)
}
var objects=sayName.bind(o);
objects();//blue
基本包装类型
//s1=new String(‘some text‘)//创建
//s2=s1.substring(2);//调用指定的方法
//s1=null//销毁
////引用类型和基本包装类型主要区别就是对象生存器，使用new操作符创建引用类型的实例，在执行
流离开当前作用域之前一直保存在内存中，而自动创建基本包装类型对象，只存在代码执行瞬间，然后
立即被销毁，这样就不能在运行时为基本类型添加属性和方法，如下
//var s1=‘some text‘;
//s1.color=‘red‘;
//alert(s1.color);//undefined
//
////创建对象
//var obj=new Object(‘some text‘);
//alert(obj instanceof String);//trye
//
var num=10;
alert(num.toFixed(2));//10.00:按照指定小数位返回数值字符串表示
alert(num.toExponential(2));//科学计数法1.00e+1
//toPrecision()返回固定大小格式，也可以返回指数格式，接收一个参数，即表示数值所有数字位（
不包括指数部分），如下
alert(num.toPrecision(1));//1e+1
//string字符串
//length长度
s=new String(‘hello python‘)
//alert(s.length)
//查找特定字符串:charAt()与charCodeat()都接收一个参数，即基于0位置
//charCodeat()以单字字符串形式返回给定位置的那个字符，如下
//alert(s.charAt(1));
//通过下标方式，如下
//alert(s[1])
//拼接一个或者多个字符串;concat(),它可以接收任意多个参数
//s+=s.concat(‘ and c++‘);
//alert(s);
//s+=s.concat(‘ and c++‘,‘!‘);
//alert(s);
//slice(),substr(),substring()都返回字符串一个子字符串，都接收1个或2个参数
//slice()和substring()第二个参数指定的是子字符串最后一个字符后面的位置
//substr()第二个参数是指返回字符个数，如果没有给定这些方法传递第二参数，么字符串长度作为结
束位置，与concat()一样，这3低点不会修改字符串本身，只返回一个基本类型字符串，对原始没有什
么影响
//alert(s.slice(3))
//alert(s.slice(3,7))
//alert(s.substr(3))
//alert(s.substring(3))
//alert(s.substr(3,7))
//alert(s.substring(3,7))
////传递负数也是可以的
//alert(s.slice(-7,-3))
//indexOf():从字符串开头向后搜索和lastIndexOf():从字符串末尾向前搜索;
// 搜索给定的子字符串，然后返回子字符串位置（未找到，返回-1）
//从0开始搜索
//alert(s.indexOf(‘py‘));//6
//alert(s.indexOf(‘py‘,7));//-1
//trim()创建字符串副本，删除前置及后缀所有空格，然后返回结果，如下
//s1=‘ python hello world! ‘;
//alert(s1);
//alert(s1.trim());
//大小写
//var s2=‘python PycharM‘;
//alert(s2.toLocaleLowerCase());//小写
//alert(s2.toLocaleUpperCase());//大写
////toLocaleLowerCase()和toLocaleUpperCase()针对特定地区实现的
//alert(s2.toUpperCase());//大写
//alert(s2.toLowerCase());//小写
//匹配模式方法
//match()接受一个参数，要么是正则表达式，要么是regexp对象，如下
var text=‘cat,bat,sat,fat‘;
var p1=/.at/;
var m1=text.match(p1);
//alert(m1.index);//0
//alert(m1[0]);//cat
//alert(p1.lastIndex)//0
//search()唯一参数与match()相同的：由字符串或者regexp对象指定一个正则表达式，返回字符串第
一个匹配项的索引，如果未找到，返回-1，search()始终从字符串开关向后查找
var pos=text.search(/at/)
//alert(pos)//1
////replace()接受2个参数，第一个参数可以是一个regexp对象或者由一个字符串（这个字符串不会被
转换成正则表达式），第二个参数是可以是一个字符串或者一个函数，如果第一个参数是字符吕， 那
么只会替换第一个子字符串，要么替换所有子字符串，唯一办法就是提供一个正则表达式，而且要指定
g标志，如下
//var replkace=text.replace(‘at‘,‘one‘)
//alert(replkace)
//var replkace=text.replace(/at/g,‘one‘)
//alert(replkace)
//特殊的字符序列，如下
result=text.replace(/(.at)/g,‘word($1)‘)
//alert(result)
//split()分割:字符串或者正则表达式对象，第二个参数是数组的大小
//alert(text.split(‘,‘))
//alert(text.split(‘,‘,2))
//alert(text.split(/[^\,]+/))
//localeCompare()比较2个字符串，规则
/* 如果字符串在字符表中应该排在字符串之前，则返回一个负数（大多数情况下是-1，具体看情况）
如果字符串等于字符串参数，则返回0；
如果字符串在字符表中应该排在字符串之后，则返回一个正数（大多数情况下是1，具体看情况）
* */
//alert(text.localeCompare(‘bat‘));//1
//alert(text.localeCompare(‘xyz‘));//-1
//fromCharCode()静态方法， 接受一个或者多个字符编码，转换成一个字符串，它与charCodeAt()执
行相反，如下
alert(String.fromCharCode(104,101,108,108,111))//hello
//所有在全局作用域中定义的属性和函数，都是Global 对象的属性
//url编码方法:encodeURL()和encodeURIComponent()通用资源标识符进行编码
//encodeURL()用于整个url地址(本身不会对url特殊字符进行编码,如冒号等),encodeURIComponent()
主要对url某一段进行编码(对它发生任何非标准字符进行编码)，如下
url=‘http://baidu.com‘;
//alert(encodeURI(url))//除了空格之外的其他字符都原封不动，只有空格被替换成%20
//alert(encodeURIComponent(url));//使用对应的编码替换所有非字符数字字符，使用的多
//eval()接受一个参数，如下
eval(alert(1));//等于alert(1)
//还可以使用函数
eval(‘function say(){alert( "hello") }‘)
say();
//math对象,其他请文档
alert(Math.sqrt(4));
标签：
原文地址：http://www.cnblogs.com/mhxy13867806343/p/4641725.html
