首页 > 编程语言 > 详细

悟透JavaScript

时间:2014-11-28 13:54:27      阅读:160      评论:0      收藏:0      [点我收藏+]
:http://www.daqianduan.com/261.html







似E=MC2







广《JavaScript



解JavaScript。JavaScript

JavaScript undefined, null, boolean, number和string即object

JavaScript是function

和Number, String, Object, Function等JavaScript ,JavaScript!

个JavaScript是unfined, null, bool, number, string, object function就typeof



* undefined



:typeof(undefined) undefined将undefined

* null

西

:typeof(null) object但null非object有null非object

* boolean



* number

线便

:typeof(NaN) typeof(Infinity)回number 。NaN是NaN NaN != NaN 。Infinity / Infinity = NaN

* string



,JavaScript

。JavaScript有object和function



object在JavaScript object

但JavaScript 是JavaScript

段JavaScript

var life = {};

for(life.age = 1; life.age <= 3; life.age++)

{

switch(life.age)

{

case 1: life.body = ;

life.say = function(){alert(this.age+this.body)};

break;

case 2: life.tail = ;

life.gill = ;

life.body = ;

life.say = function(){alert(this.age+this.body+-+this.tail+,+this.gill)};

break;

case 3: delete life.tail;

delete life.gill;

life.legs = ;

life.lung = ;

life.body = ;

life.say = function(){alert(this.age+this.body+-+this.legs+,+this.lung)};

break;

};

life.say();

};

段JavaScript 象life,life 性body个say了tail和gill 的tail和gill了legs和lung







,JavaScript,JavaScript

解JavaScript



下JavaScript

JavaScript有function,function有procedure method在JavaScript有function个function

function myfunc()

{

alert(“hello);

};

alert(typeof(myfunc));

到typeof(myfunc)是function

var myfunc = function ()

{

alert(“hello);

};

alert(typeof(myfunc));

量myfunc个function,typeof(myfunc) function些JavaScript 为function





var myfunc = function ()

{

alert(“hello);

};

myfunc(); //第一次调用myfunc,输出hello

myfunc = function ()

{

alert(“yeah);

};

myfunc(); //第二次调用myfunc,将输出yeah

使



function myfunc ()

{

alert(“hello);

};

myfunc(); //这里调用myfunc,输出yeah而不是hello

function myfunc ()

{

alert(“yeah);

};

myfunc(); //这里调用myfunc,当然输出yeah

在JavaScript

,JavaScript 用myfunc

个JavaScript个html<script/>

<script>

function myfunc ()

{

alert(“hello);

};

myfunc(); //这里调用myfunc,输出hello

</script>

<script>

function myfunc ()

{

alert(“yeah);

};

myfunc(); //这里调用myfunc,输出yeah

</script>

了JavaScript

:JavaScript

:JavaScript

果JavaScript与C++,DELPHI,C#的委托相比,又有啥稀奇嘛!然 而,JavaScript函数的神奇之处还体现在另外两个方面:一是函数function类型本身也具有对象化的能力,二是函数function与对象 object超然的结合能力。





()

function Sing()

{

with(arguments.callee)

alert(author + + poem);

};

Sing.author = ;

Sing.poem = ;

Sing();

Sing.author = ;

Sing.poem = ;

Sing();

,Sing给Sing了author和poem将author和poem 用Sing()了JavaScript JavaScript

了function西和object西西

var anObject = {}; //一个对象

anObject.aProperty = “Property of object; //对象的一个属性

anObject.aMethod = function(){alert(“Method of object)}; //对象的一个方法

//主要看下面:

alert(anObject[“aProperty]); //可以将对象当数组以属性名作为下标来访问属性

anObject[“aMethod](); //可以将对象当数组以方法名作为下标来调用方法

for( var s in anObject) //遍历对象的所有属性和方法进行迭代化处理

alert(s + is a + typeof(anObject[s]));

于function

var aFunction = function() {}; //一个函数

aFunction.aProperty = “Property of function; //函数的一个属性

aFunction.aMethod = function(){alert(“Method of function)}; //函数的一个方法

//主要看下面:

alert(aFunction[“aProperty]); //可以将函数当数组以属性名作为下标来访问属性

aFunction[“aMethod](); //可以将函数当数组以方法名作为下标来调用方法

for( var s in aFunction) //遍历函数的所有属性和方法进行迭代化处理

alert(s + is a + typeof(aFunction[s]));

访

线线西:JavaScript



,JavaScript object和function JavaScript



function与object

访



看C++、C#和Java的this,DELPHI的self,还有VB的me,或许你会恍然大悟!当然,也可能只是说句“不过如此”而已。

使

使

《JavaScript

JavaScript 有this个this与C++、C#或Java等语言的this不同。一般编程语言的this就是对象自己,而 JavaScript 的this却并不一定!this可能是我,也可能是你,可能是他,反正是我中有你,你中有我,这就不能用原来的那个“自我”来理解 JavaScript 这个this的含义了。为此,我们必须首先放下原来对象的那个“自我”。



function WhoAmI() //定义一个函数WhoAmI

{

alert(“I’m + this.name + of + typeof(this));

};

WhoAmI(); //此时是this当前这段代码的全局对象,在浏览器中就是window对象,其name属性为空字符串。输出:I’m of object

var BillGates = {name: “Bill Gates};

BillGates.WhoAmI = WhoAmI; //将函数WhoAmI作为BillGates的方法。

BillGates.WhoAmI(); //此时的this是BillGates。输出:I’m Bill Gates of object

var SteveJobs = {name: “Steve Jobs};

SteveJobs.WhoAmI = WhoAmI; //将函数WhoAmI作为SteveJobs的方法。

SteveJobs.WhoAmI(); //此时的this是SteveJobs。输出:I’m Steve Jobs of object

WhoAmI.call(BillGates); //直接将BillGates作为this,调用WhoAmI。输出:I’m Bill Gates of object

WhoAmI.call(SteveJobs); //直接将SteveJobs作为this,调用WhoAmI。输出:I’m Steve Jobs of object

BillGates.WhoAmI.call(SteveJobs); //将SteveJobs作为this,却调用BillGates的WhoAmI方法。输出:I’m Steve Jobs of object

SteveJobs.WhoAmI.call(BillGates); //将BillGates作为this,却调用SteveJobs的WhoAmI方法。输出:I’m Bill Gates of object

WhoAmI.WhoAmI = WhoAmI; //将WhoAmI函数设置为自身的方法。

WhoAmI.name = “WhoAmI;

WhoAmI.WhoAmI(); //此时的this是WhoAmI函数自己。输出:I’m WhoAmI of function

({name: “nobody, WhoAmI: WhoAmI}).WhoAmI(); //临时创建一个匿名对象并设置属性后调用WhoAmI方法。输出:I’m nobody of object

,this this和function

在JavaScript 把this。this据this访 给this的this JavaScript访,this

JavaScript 递this象BillGates.WhoAmI() SteveJobs.WhoAmI()递this的this 白JavaScript 是JavaScript





使为JavaScript Object Notation(写JSON)“JavaScript

JSON



var o = {};



var person = {name: “Angel, age: 18, married: false};



var speaker = {text: “Hello World, say: function(){alert(this.text)}};



var company =

{

name: “Microsoft,

product: “softwares,

chairman: {name: “Bill Gates, age: 53, Married: true},

employees: [{name: “Angel, age: 26, Married: false}, {name: “Hanson, age: 32, Marred: true}],

readme: function() {document.write(this.name + product + this.product);}

};

JSON{},: JavaScript句JSON

,JSON是JavaScript比XML个JSON 个JSON个JavaScript使用eval JavaScript于JSON使在AJAX

JavaScript西





除JSON在JavaScript使用new

function MyFunc() {}; //定义一个空函数

var anObj = new MyFunc(); //使用new操作符,借助MyFun函数,就创建了一个对象

JavaScript



function MyFunc(){};

var anObj = {}; //创建一个对象

MyFunc.call(anObj); //将anObj对象作为this指针调用MyFunc函数

,JavaScript 用new为this ,JavaScript “anObj = new MyFunc() ,C++和C#不就是这样创建对象的吗?原来,条条大路通灵山,殊途同归啊!

个MyFunc!JavaScript

1 function Person(name) //带参数的构造函数

2 {

3 this.name = name; //将参数值赋给给this对象的属性

4 this.SayHello = function() {alert(“Hello, I’m + this.name);}; //给this对象定义一个SayHello方法。

5 };

6

7 function Employee(name, salary) //子构造函数

8 {

9 Person.call(this, name); //将this传给父构造函数

10 this.salary = salary; //设置一个this的salary属性

11 this.ShowMeTheMoney = function() {alert(this.name + $ + this.salary);}; //添加ShowMeTheMoney方法。

12 };

13

14 var BillGates = new Person(“Bill Gates); //用Person构造函数创建BillGates对象

15 var SteveJobs = new Employee(“Steve Jobs, 1234); //用Empolyee构造函数创建SteveJobs对象

16

17 BillGates.SayHello(); //显示:I’m Bill Gates

18 SteveJobs.SayHello(); //显示:I’m Steve Jobs

19 SteveJobs.ShowMeTheMoney(); //显示:Steve Jobs $1234

20

21 alert(BillGates.constructor == Person); //显示:true

22 alert(SteveJobs.constructor == Employee); //显示:true

23

24 alert(BillGates.SayHello == SteveJobs.SayHello); //显示:false

第9,Employee this用Person第21、22:BillGates由Person 而SteveJobs由Employee的constructor



作this( ) 了JavaScript

象JavaScript使

,JavaScript造this使

function SayHello() //先定义一份SayHello函数代码

{

alert(“Hello, I’m + this.name);

};

function Person(name) //带参数的构造函数

{

this.name = name; //将参数值赋给给this对象的属性

this.SayHello = SayHello; //给this对象SayHello方法赋值为前面那份SayHello代码。

};

var BillGates = new Person(“Bill Gates); //创建BillGates对象

var SteveJobs = new Person(“Steve Jobs); //创建SteveJobs对象

alert(BillGates.SayHello == SteveJobs.SayHello); //显示:true

SayHello与Person

,JavaScript 的prototype



prototype。JavaScript prototype为C++的prototype

JavaScript 有function个prototype个prototype个object 个prototype然prototype 的prototype访 ,prototype



function Person(name)

{

this.name = name; //设置对象属性,每个对象各自一份属性数据

};

Person.prototype.SayHello = function() //给Person函数的prototype添加SayHello方法。

{

alert(“Hello, I’m + this.name);

}

var BillGates = new Person(“Bill Gates); //创建BillGates对象

var SteveJobs = new Person(“Steve Jobs); //创建SteveJobs对象

BillGates.SayHello(); //通过BillGates对象直接调用到SayHello方法

SteveJobs.SayHello(); //通过SteveJobs对象直接调用到SayHello方法

alert(BillGates.SayHello == SteveJobs.SayHello); //因为两个对象是共享prototype的SayHello,所以显示:true

的prototype到prototype





1 function Person(name) //基类构造函数

2 {

3 this.name = name;

4 };

5

6 Person.prototype.SayHello = function() //给基类构造函数的prototype添加方法

7 {

8 alert(“Hello, I’m + this.name);

9 };

10

11 function Employee(name, salary) //子类构造函数

12 {

13 Person.call(this, name); //调用基类构造函数

14 this.salary = salary;

15 };

16

17 Employee.prototype = new Person(); //建一个基类的对象作为子类原型的原型,这里很有意思

18

19 Employee.prototype.ShowMeTheMoney = function() //给子类添构造函数的prototype添加方法

20 {

21 alert(this.name + $ + this.salary);

22 };

23

24 var BillGates = new Person(“Bill Gates); //创建基类Person的BillGates对象

25 var SteveJobs = new Employee(“Steve Jobs, 1234); //创建子类Employee的SteveJobs对象

26

27 BillGates.SayHello(); //通过对象直接调用到prototype的方法

28 SteveJobs.SayHello(); //通过子类对象直接调用基类prototype的方法,关注!

29 SteveJobs.ShowMeTheMoney(); //通过子类对象直接调用子类prototype的方法

30

31 alert(BillGates.SayHello == SteveJobs.SayHello); //显示:true,表明prototype的方法是共享的

第17 prototype第28类prototype

在JavaScript,prototype且prototype使 的prototype prototype去prototype辈prototype

在JavaScript 的prototype用new 的prototype(如Firefox) 访

是Object数prototype 如toString如Function, Boolean, String, Date和RegExp的prototype

是JavaScript

使

function Person(name)

{

this.name = name;

};

Person.prototype.company = “Microsoft; //原型的属性

Person.prototype.SayHello = function() //原型的方法

{

alert(“Hello, I’m + this.name + of + this.company);

};

var BillGates = new Person(“Bill Gates);

BillGates.SayHello(); //由于继承了原型的东西,规规矩矩输出:Hello, I’m Bill Gates

var SteveJobs = new Person(“Steve Jobs);

SteveJobs.company = “Apple; //设置自己的company属性,掩盖了原型的company属性

SteveJobs.SayHello = function() //实现了自己的SayHello方法,掩盖了原型的SayHello方法

{

alert(“Hi, + this.name + like + this.company + , ha ha ha );

};

SteveJobs.SayHello(); //都是自己覆盖的属性和方法,输出:Hi, Steve Jobs like Apple, ha ha ha

BillGates.SayHello(); //SteveJobs的覆盖没有影响原型对象,BillGates还是按老样子输出

。JavaScript (override)



function Person(name)

{

this.name = name;

};

Person.prototype.SayHello = function() //建立对象前定义的方法

{

alert(“Hello, I’m + this.name);

};

var BillGates = new Person(“Bill Gates); //建立对象

BillGates.SayHello();

Person.prototype.Retire = function() //建立对象后再动态扩展原型的方法

{

alert(“Poor + this.name + , bye bye!);

};

BillGates.Retire(); //动态扩展的方法即可被先前建立的对象立即调用





在JavaScript 如Object和Function的prototype展JavaScript



在AJAX的AJAX的JavaScript 的prototype ASP.NET AJAX其prototype了JavaScript

自MicrosoftAjax.debug.js

String.prototype.trim = function String$trim() {

if (arguments.length !== 0) throw Error.parameterCount();

return this.replace(/^\s+|\s+$/g, );

}

置String的prototype个trim的String了trim便

给Object的prototype

计AJAX(closure)

function Person(firstName, lastName, age)

{

//私有变量:

var _firstName = firstName;

var _lastName = lastName;

//公共变量:

this.age = age;

//方法:

this.getName = function()

{

return(firstName + + lastName);

};

this.SayHello = function()

{

alert(“Hello, I’m + firstName + + lastName);

};

};

var BillGates = new Person(“Bill, “Gates, 53);

var SteveJobs = new Person(“Steve, “Jobs, 53);

BillGates.SayHello();

SteveJobs.SayHello();

alert(BillGates.getName() + + BillGates.age);

alert(BillGates.firstName); //这里不能访问到私有变量

象C#语言的描述形式,在一个构造函数里依次定义了私有成员、公共属性和可用的方法,显得非常优雅嘛。特别是“闭包”机制可以模拟对私有成员的保护机制,做得非常漂亮。

使 访使

给JavaSript ,IE在JavaSript



//定义构造函数

function Person(name)

{

this.name = name; //在构造函数中定义成员

};

//方法定义到构造函数的prototype上

Person.prototype.SayHello = function()

{

alert(“Hello, I’m + this.name);

};

//子类构造函数

function Employee(name, salary)

{

Person.call(this, name); //调用上层构造函数

this.salary = salary; //扩展的成员

};

//子类构造函数首先需要用上层构造函数来建立prototype对象,实现继承的概念

Employee.prototype = new Person() //只需要其prototype的方法,此对象的成员没有任何意义!

//子类方法也定义到构造函数之上

Employee.prototype.ShowMeTheMoney = function()

{

alert(this.name + $ + this.salary);

};

var BillGates = new Person(“Bill Gates);

BillGates.SayHello();

var SteveJobs = new Employee(“Steve Jobs, 1234);

SteveJobs.SayHello();

SteveJobs.ShowMeTheMoney();



的prototype 是undefined





让JavaScript

在JavaScript西



下JavaScript

var anObject = new aFunction() 数prototype 为this访



var Person = //定义一个对象来作为原型类

{

Create: function(name, age) //这个当构造函数

{

this.name = name;

this.age = age;

},

SayHello: function() //定义方法

{

alert(“Hello, I’m + this.name);

},

HowOld: function() //定义方法

{

alert(this.name + is + this.age + years old.);

}

};

个JSON个C#的类啊!既有构造函数,又有各种方法。如果可以用某种形式来创建对象,并将对象的内置的原型设置为上面这个“类”对象,不就相当于创建该类的对象了吗?

访访使

的prototype用new



function anyfunc(){}; //定义一个函数躯壳

anyfunc.prototype = Person; //将原型对象放到中转站prototype

var BillGates = new anyfunc(); //新建对象的内置原型将是我们期望的原型对象

个anyfunc使西使

退

function New(aClass, aParams) //通用创建函数

{

function new_() //定义临时的中转函数壳

{

aClass.Create.apply(this, aParams); //调用原型中定义的的构造函数,中转构造逻辑及构造参数

};

new_.prototype = aClass; //准备中转原型对象

return new new_(); //返回建立最终建立的对象

};

var Person = //定义的类

{

Create: function(name, age)

{

this.name = name;

this.age = age;

},

SayHello: function()

{

alert(“Hello, I’m + this.name);

},

HowOld: function()

{

alert(this.name + is + this.age + years old.);

}

};

var BillGates = New(Person, [“Bill Gates, 53]); //调用通用函数创建对象,并以数组形式传递构造参数

BillGates.SayHello();

BillGates.HowOld();

alert(BillGates.constructor == Object); //输出:true

New()

退 New的new_于new_的prototype 和new_ constructor是Object有constructor 即Object

了New像C#那些静态对象语言的形式了,这样的代码显得多么文静而优雅啊!



//语法甘露:

var object = //定义小写的object基本类,用于实现最基础的方法等

{

isA: function(aType) //一个判断类与类之间以及对象与类之间关系的基础方法

{

var self = this;

while(self)

{

if (self == aType)

return true;

self = self.Type;

};

return false;

}

};

function Class(aBaseClass, aClassDefine) //创建类的函数,用于声明类及继承关系

{

function class_() //创建类的临时函数壳

{

this.Type = aBaseClass; //我们给每一个类约定一个Type属性,引用其继承的类

for(var member in aClassDefine)

this[member] = aClassDefine[member]; //复制类的全部定义到当前创建的类

};

class_.prototype = aBaseClass;

return new class_();

};

function New(aClass, aParams) //创建对象的函数,用于任意类的对象创建

{

function new_() //创建对象的临时函数壳

{

this.Type = aClass; //我们也给每一个对象约定一个Type属性,据此可以访问到对象所属的类

if (aClass.Create)

aClass.Create.apply(this, aParams); //我们约定所有类的构造函数都叫Create,这和DELPHI比较相似

};

new_.prototype = aClass;

return new new_();

};

//语法甘露的应用效果:

var Person = Class(object, //派生至object基本类

{

Create: function(name, age)

{

this.name = name;

this.age = age;

},

SayHello: function()

{

alert(“Hello, I’m + this.name + , + this.age + years old.);

}

});

var Employee = Class(Person, //派生至Person类,是不是和一般对象语言很相似?

{

Create: function(name, age, salary)

{

Person.Create.call(this, name, age); //调用基类的构造函数

this.salary = salary;

},

ShowMeTheMoney: function()

{

alert(this.name + $ + this.salary);

}

});

var BillGates = New(Person, [“Bill Gates, 53]);

var SteveJobs = New(Employee, [“Steve Jobs, 53, 1234]);

BillGates.SayHello();

SteveJobs.SayHello();

SteveJobs.ShowMeTheMoney();

var LittleBill = New(BillGates.Type, [“Little Bill, 6]); //根据BillGate的类型创建LittleBill

LittleBill.SayHello();

alert(BillGates.isA(Person)); //true

alert(BillGates.isA(Employee)); //false

alert(SteveJobs.isA(Person)); //true

alert(Person.isA(Employee)); //false

alert(Employee.isA(Person)); //true

,JavaScript

的JavaScript constructor让JavaScript

prototype的JavaScript

计AJAX把AJAX 把Bill Gates的AJAX



,JavaScript的JavaScript 向JavaScript 的C#语言就吸收了JSON那样的简洁表示法,以及一些其他形式的 JavaScript特性。

着RIA(),AJAX,JavaScript





悟透JavaScript

原文:http://www.cnblogs.com/liuyitian/p/4128196.html

(0)
(0)
   
举报
评论 一句话评论(0
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!