2.window文档l构?br />3.延迟加蝲和间歇加?br /> setTimeout(function,time) clearTimeout(obj);
setInterval(function,time) clearInterval(obj);
]]>
a. 工厂模式
function Person(name,age){
var person = new Object();
person.name = name;
person.age=age;
person.say=function(){
alert(person.name+" "+person.age);
}
return person;
}
var person1 = Person("xcp",23);
var person2 = Person("lxm",24);
person1.say();
person2.say();
//没有解决对象识别的问题（x么知道对象的类型）
var person = new Object();
person.name = name;
person.age=age;
person.say=function(){
alert(person.name+" "+person.age);
}
return person;
}
var person1 = Person("xcp",23);
var person2 = Person("lxm",24);
person1.say();
person2.say();
//没有解决对象识别的问题（x么知道对象的类型）
b. 构造函数模?/p>
function Person(name,age){
this.name = name;
this.age = age;
this.say = function(){
alert(this.name+" "+this.age);
}
}
var person1 = new Person("xcp",23);
var person2 = new Person("lxm",24);
person1.say();
person2.say();
//直接属性附gthisQƈ且没有显C的创徏和返回对象；必须用new来创建对?br />alert(person1 constructor Person);//true
alert(person1 instanceof Person); //true
->创徏对象l历以下步骤Q?br /> >创徏一个新对象this.name = name;
this.age = age;
this.say = function(){
alert(this.name+" "+this.age);
}
}
var person1 = new Person("xcp",23);
var person2 = new Person("lxm",24);
person1.say();
person2.say();
//直接属性附gthisQƈ且没有显C的创徏和返回对象；必须用new来创建对?br />alert(person1 constructor Person);//true
alert(person1 instanceof Person); //true
>构造函数的作用赋予新对?因此this指向了新对?
>执行构造函数里面的代码Q添加属性）
>q回新对?br /> ->构造函数的问题
>使用构造函数的主要问题Q就是每个方法都要在每个实例上重?/strong>创徏一遍。例如我们上面的alert(person1.say==person2.say) //false
创徏两个同样功能的Function()是完全没有必要的Q况且有this对象在，Ҏ不用在执行代码前把函数l定到特定对象上面。因些，大可以像以下面的代码Q通过把函数定义{Ud构造函数外部解册个问题：
function Person(name,age){
this.name = name;
this.age = age;
this.say = sayFunction(this.name,this.age);
}
function sayFunction(name,age){
alert(name+" "+age);
}
//q样sayFunction只会创Zơ了 //卻Ialert(person1.say==person2.say) //true;
但问题也来了Q如果有很多个方法，p创徏很多ҎQ这h论可L，适用性都不是很好
c. 原型模式
>理解Q我们创建的每一个对象，都有一个prototype属性，q个属性是一个对象，那么q个对象的作用是什么呢Q所有prototype属性都会自动获得一个constructor(构造函?Q这个属性民包含一个指向prototype属性在所函数的指针。Person.prototype.constructor指向Person。而通过q个构造函敎ͼ我们q可以承ؓ原型d其他属性和Ҏ。如图：
.Person对象的prototype属性指向Person原理对象
.Person原理对象的构造方法指向Person对象
.Person实例调用属性和Ҏ的顺序：先查找Person对象是否h此属性和ҎQ如果Person对象h则返回，如果没有则先查询Person的原型对像。推出：如果对象本n和原型对象同时具有某个函数和ҎQ以对象本n的属性和Ҏ为准。从q个可以体现出多个对象共享原型所保存?/strong>属性和ҎQ以降低内存开消。但有的时候我们需要用原理对象的属性属性和Ҏ去覆盖原有对象的属性的ҎQ这时我们采?strong>删除原有对象的属性和ҎQdelete Person.name(删除原有对象的name属?.可以使用hasOwnProperty()和isPrototypeof();
>原型与in操作W?br /> .有两U可能用in操作Q单独?"name" in person1)和在for..in里面。单独用in的时候对象能够返回给定属性时q回true(实例和原?
>更加单的原型语法
function Person(){}
Person.prototype={
name:'age',
age:'23',
say:function(){
alert(this.name+" "+this.age);
}
}
//q样写下来就相当?strong>重写了对象的prototype对象Q那原型对象里面的constructor属性就没有?/strong>.但如果我要得到constructor属性怎么办呢Q?br /> Person.prototype={
constructor:Person,//constructor=this,
name:'age',
age:'23',
say:function(){
alert(this.name+" "+this.age);
}
}
>原型中的动态?nbsp;
.׃原型中查找植的过E是一ơ性的Q因此我们对原型对象所做的操作会立d映出来，?br /> function Person(){
}
Person p = new Person();
Person.prototype.say=function(){
alert("hi");
}
p.say(); //hi;q样可以立M现出?br />
//再看看下面的例子
function Person(){}
Person p = new Person();
Person.prototype={
say:function(){
alert("hi");
}
}
p.say(); //error;
//q里Z么就出错了呢Q上一个例子不是好好的?/strong>Q因为第一个例子，只是在prototype原型对象里面d了一个属性，我们在调用say的时候他会查扑֯象本w和原型对象q且是一ơ查询（所以的代码q行完毕Q，所以可以正常的到原型对象里面取出来Q可是后面一个方法呢Q声明对象p他的时候他会找到_proto_指针指向原型对象Q而我用Person.prototype也重构这个原型对象，q当于切断了constructor与是初始原型之间的连接关p，所有p的Q何非本n属性都会出错！
>原生态对象模?/span>
.原型cd不仅体现在自定义对象模型Q包括原生的引用cd都是采用的这U模式，所以我们可以修改引用类型提供的Ҏ和属性?/span>
String.prototype.trim=function(text){...} //我们跟String对象d了一个trim()ҎQ?/span>
>原型对象的问?/span>
.原型对象省略了ؓ构造函C低参数这一l节Q结果所以的实例对象取得的实例值都是一LQ所?/span>原型对象最大问题就是由本n本质导成?/strong>?/span>
function Person(){}
Person p = new Person();
Person.prototype={
say:function(){
alert("hi");
}
}
p.say();
Person p1 = new Person();
Person p2 = new Person();
alert(p1.say==p2.say);//true
//所以接下来我们是?/span> 解决怎么合理׃n,卛_理用prototypeQ?/span>
>l合使用构造函数模式和原型模型(最常见的方?
.构造函数模式用于定义：实例属?可以传递多个参C保必要?
原型模式用于定义Q共享的属性和Ҏ(q样即保证了安全Q也保证了最大的节约内存)
例：function Person(name,age){
this.name=name;
this.age = age;
this.friend=["zhangsan","lisi","wangmazi"];
}
Person.prototype={
constructor:Person,
say:function(){
alert(this.name+" "+this.age);
}
}
Person p1 = new Person("xcp","23");
Person p2 = new Person("lxm","25");
alert(p1.friends==p2.friends);//false;
alert(p1.say==p2.say);//true;
.动态原型模?br /> function Person(name,age){
this.name=name;
this.age = age;
this.friend=["zhangsan","lisi","wangmazi"];
if(typeof this.say !="function"){
Person.prototype.say:function(){
alert(this.name+" "+this.age);
}
//再一ơ强调这不能写成
Person.prototype={...}
}
}
>寄生构造函数模?br /> .在工厂模式上加上参数
function Person(name,age){
var o = new Object();
o.name=name;
o.age = age;
o.say=function(){
alert(this.name+" "+this.age);
}
return o;
}
2.l承
一般所有的OO都支持接口承和实现l承Q而ECMAScript?span style="color: #000000">数没?/span>{明的说话（I函数标志或者说接口的声明方法）Q所以只有实现承，而实现承主要是通过原型对象来实C?nbsp;
>原型?/strong>(重要思想)
. 单回一下构造函敎ͼ原型和实例的关系
构造函数的prototype属?指针) -> 原型地址
原型的construtcotr属?指针) -> 构造函数地址
实例的_proto_属?内部指针) -> 原型对象
.原型铄思想
我们一个原型对象的指针指向另一个构造函数。如此层层递进Q就实现了实例和原型的链?br /> function SuperType(){
this.property = true;
}
SuperType.prototype.getSuperValue=function(){
return this.property;
}
function Subtype(){
this.subproperty = false;
}
SubType.prototype = new SuperType(); //子类的原型对象指向 生成的超cȝ子类Q所以有一个_proto_指针指向类的面型对象）
SubType.prototype.getSubValue=function(){
return this.subproperty;
}
Subtype instance = new Subtype();
instance.getSuperValue();
分析Q?br />
.如果我们调用subType.getSuperValue()l过的步骤有Q?Q搜索实例本w?2Q搜索SubType.prototype 3)搜烦SuperType.prototype 4)所有的c都是实现ObjectQ所以如果前面没有找到的话，p要搜索Object.prototype;所以真正的原型铑ֺ该是Q?br />
//再到q来q来一下，不是原型对象的constructor被重写了Q而且_proto_指针被重写了?br />
. 两种Ҏ来确定实现跟原理之间的关p?br /> //是否是指定类型的实现
alert(instance instanceof Object)//true;
alert(instance instanceof SuperType);//true;
alert(instance instanceof SubType);//true;
alert(instance instanceof Data); //false;
//指定cd的原型对象是否派生了此实?br /> alert(Object.prototype.isPrototype(instance));//true;
alert(SuperType.prototype.isPrototype(instance));//true;
alert(SubType.prototype.isProtoType(instance));//true
.重写类Ҏ
在SubType.prototype = new SuperType(); 后面d如下Q?br /> //重写类Ҏ
SubType.prototype.getSuperValue=function(){
return false;
}
//不能写成q样
SubType.prototype=new Supertype();
SubType.prototype={
getSuperValue=function(){
return false;
}
} //当一使用q一句话Ӟ上一句话qd效了Qؓ什么呢Q前面已l说q一q样切断了SubType与SuperType.prototype的链?br />
.原型铄问题
最主要的问题就是包含引用类型类型的?换一句就?strong style="color: red">讉K安全性问?/strong>Q怎么说来着Q前面介l包含引用类型值的原型属性民会被所有实例共享；而这也正是ؓ什么要在构造函CQ而不是在原型对象中定义属性的原因。但我们通过原型来实现承时Q原型实际上会变成另一个类型的实例Q于是，原先的实例属性和原型对象里面所有的属性和Ҏ利成章地变成了现在的原型属性了Q从而可以将属性工享这q坏了原有的安全性了?br />
>借用构造函?/strong>Q也叫伪造对象和l典l承->常用方式Q?br /> .无参数版
function SuperType(){
colors:["red","blue","green"];
}
function SubType(){
//实现l承SuperType,Z么呢Q因为在子类构造函数调用父cL造函数里面的callҎ
SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push("block");
alert(instance1.colors); //"red","blue","green","block";
var instance2 = new SubType();
alert(instance2.colors); //"red","blue","green"
.有参数版
function SuperType(name){
this.name = name;
}
function SubType(){
//l承了SuperType,同时传递了参数
SuperType.call(this,"xcp");
//实例属?br /> this.age = 23;
}
var instance = new SubType();
alert(instance.name); //xcp
alert(instance.age); //23
.借用构造函数的问题
如果仅仅是借用构造函敎ͼ那么也将无法避免构造函数模式存在的问题Q方法都在构造函C定义Q这样些函数复用无从谈起了?br />
>l合l承(也称伪经典?,指的是将原型铑֒借用构造函数的技术结合在一hQ从而发挥者这宅的一U承模?br /> .实例(_օ实例)
function SuperType(name){
this.name = name;
this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName=function(){
alret(this.name);
}
function SubType(name,age){
//l承属?br /> SuperType.call(this,name);
//d新属?br /> this.age = age;
}
//l承原型里面的属性和Ҏ
SubType.prototype = new SuperType();
//d新方?br /> SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("xcp",23);
instance1.colors.push("black");
alert(instance1.colors); //red,blue,green,black
instance1.sayName();//xcp;
instance1.sayAge();//23;
var instance2 = new SubType("lxm",25);
alert(instance2.colors); //red,blue,green
instance2.sayName();//lxm
instance2.sayAge(); //25
//l合l承避免了前面的原型链Q父cL有的属性和Ҏ均作用子cȝ原型对象的属性和ҎQ所以就存在数据安全问题了）和借用构造函数的~陷Q无׃n属性和Ҏ机制Q；成ؓJavascript中最常用的承模式。而且Qinstanceof和isPrototypeOf()也能够用于识别基于组合承创建的对象?br />
>当然q包括：原型式ѝ寄生式l承{?br />
3.ȝ
>创徏javascript对象的方?br /> .ҎQ?br /> 构造方法式<接收参数传值实例属?gt;+原型?lt;抽取公共׃n的方?gt;
.实例Q?br /> function Person(name,age){
this.name=name;
this.age = age;
this.friend=["zhangsan","lisi","wangmazi"];
}
Person.prototype={ //使用最对象完成
constructor:Person,
say:function(){
alert(this.name+" "+this.age);
}
}
Person p1 = new Person("xcp","23");
Person p2 = new Person("lxm","25");
alert(p1.friends==p2.friends);//false;
alert(p1.say==p2.say);//true;
>l承类的方?br /> .Ҏ
借用构造函数式<复用类的实例变量，表示不同实例得到不变量不?gt;+原型?lt;复用类的原型对象，意思就是子cȝ_proto_指针指同类的原型对?gt;
.实例
function SuperType(name){
this.name = name;
this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName=function(){
alret(this.name);
}
function SubType(name,age){
//l承属?br /> SuperType.call(this,name);
//d新属?br /> this.age = age;
}
//l承原型里面的属性和Ҏ
SubType.prototype = new SuperType();
//d新方?br /> SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("xcp",23);
instance1.colors.push("black");
alert(instance1.colors); //red,blue,green,black
instance1.sayName();//xcp;
instance1.sayAge();//23;
var instance2 = new SubType("lxm",25);
alert(instance2.colors); //red,blue,green
instance2.sayName();//lxm
instance2.sayAge(); //25
]]>
a. 用new操作W后跟Object构造函?br /> var person = new Object();
person.name = "xcp";
person.age = 23;
b. 另一U方式是使用对象字面?/strong>表示?br /> var person = {
name:'xcp';
age:23;
}
或?br /> var person={}
person.namge="xcp";
person.age=23;
3.创徏Array数组有两U方法：
a. 使用Array的构造函?br /> var colors = new Array();
var colors = new Array(20);
var colors = {"red","blue","green"}
//每一个数l元素的初始值都?strong>undefined;
b. 使用数组字面?/strong>Ҏ
var colors = Array(20);
var colors = ["red","blue","green"];
4.使用Array的常用方法：
a. 栈操作方?后进先出)Qpush 推入,pop 弹出
var colors=["red","blue"];
colors.push("green"); //推入一?br /> colors[4]="block";
alert(colors.length); //4
var temp = colors.pop();
alert(temp); //block
alert(colors.length);//3
b. 对列Ҏ(先进先出)Qpush推入Qshift取出, unshift塞入
var colors=["red","blue"];
colors.push("green"); //推入一?br /> colors[4]="block";
alert(colors.length); //4
var temp = colors.shift();
alert(temp); //red
alert(colors.length);//3
unshift和shift的功能刚好相反：他是在第一位添加数据项
var colors = new Array();
var count = colors.unshift("red","green");
alert(count); //2
colors.unshift("block");
var item = colors.pop();
alert(item); //green
alert(colors.length);
c. 重排序方?reverse()和sort()
var values=[1,2,3,4,5,6];
values.reverse();
alert(values); //6,5,4,3,2,1
//注意sortҎ会调?strong>每个数组的toString()转型ҎQ然后得到字W串Q然后再排序Q就会出C下情况：
var values = [0,15,1,10,5];
values.sort();
alert(values); //0,1,10,15,5
//不用说这UsortҎ肯定不是最佳的方式。因此sortҎ可以接收一个比较函C为参敎ͼ和java的Comparable一L作用.
function compare(value1,valu2){
if(value1 < value2){
return -1;
}else if(value > value2){
return 1;
}else{
return 0;
}
}
values.sort(compare);
alert(values); //0,1,5,10,15
d. 常用Ҏ
concat:两个或更多数l组合而成?br /> join:q回字符串|其中包含了连接到一L数组的所有元?nbsp; values.join(",") 0,1,5,10,15
slice:q回一个数l的一D?nbsp; values.slice(0,2);
splice:从一个数l中U除一个或多个元素 values.splice(0,2);
valueOf:q回指定对象的原始?br />
5.使用Datacd
a. 创徏日期对象
var now = new Date();
var someData = new Date(Data.parse("May 25,2005"));
var someData = new Date("May 25,2005");
6.使用RegExp对象
a. 创徏RegExp对象(字面量方式创?/strong>)
var expression = /pattern/flags;
q里面的pattern 是p匚w的正则表辄
q时面的flags包括以下几种Q?strong>g,i,m
gQ表C全局模式(global)Q则模式应用于所有字W串Q而ƈ非发现第一个匹配项qd止?br /> iQ表CZ区分大小写（case-insensitive),
mQ表C多行模?mutiline)Q即辑ֈ一行末时q会l箋查找下一行是否存在匹配项
例：var at = /at/g; 匚wat
var at2 = /[bc]at/gi; 匚wbat,cat。。。。ƈ且不区分大小?br /> var at3 = /.at/gi; 分有以atl尾?个字母的字符?br /> 注：
以下是javascript里面的{义字W：(){}[]\|/^$.?*+ 转义ҎQ加\ 。如\\ \$
var at4 = /\.at/gi; 所?at,不区分大写
b. 使用RegExp构造函数创?br /> 它接受两个参敎ͼ一个是要匹配的字符串模式，可选的标志字符丌Ӏ?br /> var at5 = new RegExp("[bc]at","i");
׃RegExp函数模式的参数是字符Ԍ所以在某些情况下要对字W串q行双重转义Q如Q?br />
c. RegExp的属?br /> >globalQ返回true/false,q回是否讄了g标志
>ignonecaseQ返回true/falseQ返回是否设|了i标志
>mutilineQ返回true/false,q回是否讄了m标志
>lastIndexQ开始搜索下一个匹配的位置Q从0开?br /> >sourceQ返回正则表辄
d. RegExp的方?br /> >execҎ
var text = "mom and dad and bady";
var p = /mon( and dad( and bady)?)?/gi;
var m = p.exec(text); //q回匚w?br /> alert(m.index); //0
alert(m.input);//mom and dad and bady
alert(m[0]);//mom and dad and bady 相当于group(0)
alert(m[1]);// and dad and bady 相当于group(1)
alert(m[2]);// and bady 相当于group(2)
>testҎ
通常用于if语句Q如果匹配返回true,否则q回false
var test="000-00-0000";
var p = /\d{3}-\d{2}-\d{4}/;
if(p.test(test)){alert("dd");}
f. Functioncd
a.函数的声?br /> function test(index){}
var test = function(index){}
var test = new Function(index){} //不推?br /> 注：
>函数没有重蝲功能Q如果两个函CP他会直接前面的Ҏ
b. 函数内部属?strong>this和arguments
c. 每个函数都包?strong>length和prototype属?br /> lengthQ接受参数的个数
prototypeQ原型对象，很重?br /> d. 每个函数都有两个非承的ҎQ?strong>apply()和call()Ҏ
>q两个方法的用途都是在特定的作用域中调用函敎ͼ实际上等于设|函C内this对象的倹{?br /> >首先,applyҎ接受两个参数Q一个是在其中运行函数的作用域，另一个是参数数据Q可以是Array实例Q也可以是arguments对象Q?br /> function sum(num1,num2){
return num1+num2;
}
function callsum1(num1,num2){
return sum.apply(this,arguments); //传入arguments对象
}
function callsum2(num1,num2){
return sum.apply(this,[num1,num2]); //传入数组
}
alert(callSum1(10,10)); //20
alert(callSum2(10,10)); //20
>call()Ҏ与apply()Ҏ的作用相同，它们的区别仅在于接收参数的方式不同。对于call()Ҏ来言Q第一个参数是作用域没有变?Q变化的只是其余参数都是直接 传递跟函数的?br /> function callSum3(num1,num2){
return sum.call(this,num1,num2);
}
alert(callSum3(10,10));//20
//所以apply()和call()使用q怎么使用方便来用了，如我们传入的参数是要传调用的函数的参数Q就可以直接作用apply(this,arguments);
>真正强大的地Ҏ能够扩充函数赖以q行的作用域<是在后面运行的函数的作用域是我传q的作用?gt;
window.color = "red";
var o={color:"blue"}
function getColor(){
alert(this.color);
}
getColor(); //red
getColor.call(this); //red
getColor.call(widow); //red;
getColor.call(0); //blue;
g.Booleancd
a. 声明
var b = true;
var b = new Boolean(true);
alert(b instanceof Boolean); //true
h.Numbercd
a. 声明
var b1 = 2;
var b2 = new Number(2);
var b3 = (Number)"2";
i.Stringcd
a. 声明
var s1 = "dd";
var s2 = new String("dd');
b. 常用Ҏ
charAt,concat, substring,indexOf,toLowerCase,toUpperCase{?br />
j.常用内置对象
a. URI~码ҎQencodeURI()和encodeURIComponent(常用)
比较QencodeURI()用于整个URL;encodeURIComponent用于URL中的某段q行~码
encodeURI不会Ҏw的URLҎ字符q行~码Q例如冒P正斜杠，问号??而encodeURIComponentҎ有非标准字符都要q行~码
b. URL解码ҎQdecodeURI()和decodeURIComponent,基本操作同上
c. isNan(), parseInt(), parseFloat()
d. eval()---功能最强大的一个方?br /> ECMAScript内部解析器一?br /> e. Window对象
f. Mathc?br /> min,max, ceil,floor,round,random
]]>
2.ECMAScrip:Javascript ActionScript ScriptEase
3.defer="defer"延迟加蝲
二、基
(一)、语?br /> 1.区分大小写（变量Q函数名Q操作符都区分大写Q?br /> 2.标识W?br /> 2.1 W一个字母必LQ字母、_?
2.2 其它的允许字母、_?、和数字
3.注释
3.1 单行 //
3.2 多行 /***/
4.关键?br /> this,break,continue,if,else,switch,default,for,do,while,with,new,typeof,instanceof,try,catch,finally,throw,return{等
(?、数据类?br /> 1、基本数据类?可以保用typeof来取得以?
1.1 undefined --- 如果q个值未定义
1.2 boolean --- 如果q个值是布尔?nbsp;
1.3 string --- 如果q个值是字符?br /> 1.4 number --- 如果q个值是数字?br /> 1.5 object --- 如果q个值是对象或null
1.6 function --- 如果q个值是函数
2、基本数据类
Undefined,Boolean,String,Number,Object,Null,Function
3?strong>Null与Undefined的区?br /> Null是指对象定义了，只不q指定他为空或者没有赋|而Undefined是对象肯定没有定?br />(?、操作符
1、一元操作符
1.1 递增Q递减 ++ --
2、位操作W?br /> 2.1 Not,And,Or,左移,有符号右U?无符号右U?br /> 3、关pR?br /> 4?strong>各数据类型之间的操作
(?、语?br /> 1、if...endif...else
2、switch() case... break;default;
3、do...whie()
4、while(); break;continue;
5、for(var i=0;i<*;i++)
6、for(var i in *)
4.内置功能Q系l类Q?br /> 1、Function 可以传递参敎ͼ?strong>arguments得到所以传递参数集?/div>
]]>
]]>