javascript面向对象技术基础.docx

上传人:b****4 文档编号:5613095 上传时间:2023-05-08 格式:DOCX 页数:32 大小:308.48KB
下载 相关 举报
javascript面向对象技术基础.docx_第1页
第1页 / 共32页
javascript面向对象技术基础.docx_第2页
第2页 / 共32页
javascript面向对象技术基础.docx_第3页
第3页 / 共32页
javascript面向对象技术基础.docx_第4页
第4页 / 共32页
javascript面向对象技术基础.docx_第5页
第5页 / 共32页
javascript面向对象技术基础.docx_第6页
第6页 / 共32页
javascript面向对象技术基础.docx_第7页
第7页 / 共32页
javascript面向对象技术基础.docx_第8页
第8页 / 共32页
javascript面向对象技术基础.docx_第9页
第9页 / 共32页
javascript面向对象技术基础.docx_第10页
第10页 / 共32页
javascript面向对象技术基础.docx_第11页
第11页 / 共32页
javascript面向对象技术基础.docx_第12页
第12页 / 共32页
javascript面向对象技术基础.docx_第13页
第13页 / 共32页
javascript面向对象技术基础.docx_第14页
第14页 / 共32页
javascript面向对象技术基础.docx_第15页
第15页 / 共32页
javascript面向对象技术基础.docx_第16页
第16页 / 共32页
javascript面向对象技术基础.docx_第17页
第17页 / 共32页
javascript面向对象技术基础.docx_第18页
第18页 / 共32页
javascript面向对象技术基础.docx_第19页
第19页 / 共32页
javascript面向对象技术基础.docx_第20页
第20页 / 共32页
亲,该文档总共32页,到这儿已超出免费预览范围,如果喜欢就下载吧!
下载资源
资源描述

javascript面向对象技术基础.docx

《javascript面向对象技术基础.docx》由会员分享,可在线阅读,更多相关《javascript面向对象技术基础.docx(32页珍藏版)》请在冰点文库上搜索。

javascript面向对象技术基础.docx

javascript面向对象技术基础

目录

javascript面向对象技术基础

(一)3

javascript面向对象技术基础

(二)5

javascript面向对象技术基础(三)6

javascript面向对象技术基础(四)9

javascript面向对象技术基础(五)12

javascript面向对象技术基础(六)15

javascript面向对象技术基础

(一) 

看了很多介绍javascript面向对象技术的文章,很晕.为什么?

不是因为写得不好,而是因为太深奥.

javascript中的对象还没解释清楚怎么回事,一上来就直奔主题,类/继承/原型/私有变量....

结果呢,看了大半天,有了一个大概的了解,细细一回味,好像什么都没懂...

这篇文章是参考<>第7,8,9章而写成的,我也会尽量按照原书的结构来说明javascript的面向对象技术(对象/数组->函数-->类/构造函数/原型).对一些我自己也拿捏不准的地方,我会附上原文的英文语句,供大家参考.如果不做说明,则文中出现的所有英文语句(程序体除外)都是引自<>.

-------------------------------------------------

对象和数组(ObjectsandArrays)

什么是对象?

把一些"名字-属性"的组合放在一个单元里面,就组成了一个对象.我们可以理解为javascript中

的对象就是一些"键-值"对的集合(Anobjectisacollectionofnamedvalues.Thesenamedvaluesareusuallyreferred toaspropertiesoftheobject.--Section3.5)."名字"只能是string类型,不能是其他类型,而属性的类型则是任意的(数字/字符串/其他对象..).可以用newObject()来创建一个空对象,也可以简单的用"{}"来创建一个空对象,这两者的作用是等同的.

Js代码  

1.var emptyObject1 = {};           //创建空对象  

2.var emptyObject2 = new Object(); //创建空对象  

3.var person = { //创建一个包含初始值的对象person 

4."name":

"sdcyst",  

5.          "age":

18,  

6.          "sex":

"male"

7.};  

8.alert(person.name);              //sdcyst  

9.alert(person["age"]);            //18  

 从上面的例子我们也可以看到,访问一个对象的属性,可以简单的用对象名加"."后加属性的名字,也可以用"[]"操作符来获取,此时在[]里面的属性名字要加引号,这是因为对象中的索引都是字符串类型的.javasript对象中属性的个数是可变的,在创建了一个对象之后可以随时对它赋予任何的属性.

Js代码  

1.var person = {};  

2.person.name = "sdcyst";  

3.person["age"] = 18;  

4.alert(person.name + "__" + person.age); //sdcyst__18  

5.  

6.var _person = {name:

"balala","age":

23}; //在构建一个对象时,属性的名字可以不用引号来标注(name),  

7.//但是仍旧是一个字符串类型.在访问的时候[]内仍旧需要引号  

8.alert(_person["name"] + "__" + person.age); //balala__23  

9.alert(_person[name]);                   //undefinied  

 通过"."操作符获取对象的属性,必须得知道属性的名字.一般来说"[]"操作符获取对象属性的功能更强大一些,可以在[]中放入一些表达式来取属性的值,比如可以用在循环控制语句中,而"."操作符则没有这种灵活性。

 

Js代码  

1.var name = {"name1":

"NAME1","name2":

"NAME2","name3":

"NAME3","name4":

"NAME4"};  

2.var namestring = "";  

3.for(var props in name) {  //循环name对象中的属性名字  

4.    namestring += name[props];  

5.}  

6.alert(namestring);  //NAME1NAME2NAME3NAME4  

7.  

8.namestring = "";  

9.for(var i=0; i<4; i++) {  

10.    namestring += name["name"+(i+1)];  

11.}  

12.alert(namestring);  //NAME1NAME2NAME3NAME4  

 delete操作符可以删除对象中的某个属性,判断某个属性是否存在可以使用"in"操作符.

Js代码  

1.var name = {"name1":

"NAME1","name2":

"NAME2","name3":

"NAME3","name4":

"NAME4"};  

2.var namestring = "";  

3.for(var props in name) {  //循环name对象中的属性名字  

4.    namestring += name[props];  

5.}  

6.alert(namestring);  //NAME1NAME2NAME3NAME4  

7.  

8.delete name.name1;  //删除name1属性  

9.delete name["name3"];  //删除name3属性  

10.namestring = "";  

11.for(var props in name) {  //循环name对象中的属性名字  

12.    namestring += name[props];  

13.}  

14.alert(namestring);  //NAME2NAME4  

15.  

16.alert("name1" in name); //false  

17.alert("name4" in name); //true  

 需要注意,对象中的属性是没有顺序的.

对象的constructor属性

每一个javascript对象都有一个constructor属性.这个属性对应了对象初始化时的构造函数(函数也是对象).

Js代码  

1.var date = new Date();  

2.alert(date.constructor);  //Date  

3.alert(date.constructor == "Date");  //false  

4.alert(date.constructor == Date);  //true  

 

javascript面向对象技术基础

(二)

数组

我们已经提到过,对象是无序数据的集合,而数组则是有序数据的集合,数组中的数据(元素)通过索引(从0开始)来访问,数组中的数据可以是任何的数据类型.数组本身仍旧是对象,但是由于数组的很多特性,通常情况下把数组和对象区别开来分别对待(Throughoutthisbook,objectsandarraysareoftentreatedasdistinctdatatypes.

Thisisausefulandreasonablesimplification;youcantreatobjectsandarraysasseparatetypes 

formostofyourJavaScriptprogramming.Tofullyunderstandthebehaviorofobjectsandarrays, 

however,youhavetoknowthetruth:

anarrayisnothingmorethananobjectwithathinlayerofextra 

functionality.Youcanseethiswiththetypeofoperator:

appliedtoanarrayvalue,itreturns 

thestring"object". --section7.5).

创建数组可以用"[]"操作符,或者是用Array()构造函数来new一个.

Js代码  

1.var array1 = [];  //创建空数组  

2.var array2 = new Array();  //创建空数组  

3.array1 = [1,"s",[3,4],{"name1":

"NAME1"}]; //  

4.alert(array1[2][1]);  //4   访问数组中的数组元素  

5.alert(array1[3].name1); //NAME1 访问数组中的对象  

6.alert(array1[8]);   //undefined  

7.array2 = [,,];  //没有数值填入只有逗号,则对应索引处的元素为undefined  

8.alert(array2.length); //3  

9.alert(array2[1]);     //undefined  

 用newArray()来创建数组时,可以指定一个默认的大小,其中的值此时为undefined,以后可以再给他们赋值.但是由于javascript中的数组的长度是可以任意改变的,同时数组中的内容也是可以任意改变的,因此这个初始化的长度实际上对数组没有任何的约束力.对于一个数组,如果对超过它最大长度的索引赋值,则会改变数组的长度,同时会对没有赋值的索引处赋值undefined,看下面的例子.

Js代码  

1.var array = new Array(10);  

2.alert(array.length);   //10  

3.alert(array[4]);       //undefined  

4.array[100] = "100th";  //这个操作会改变数组的长度,同时将10-99索引对应的值设为undefined  

5.alert(array.length);   //101  

6.alert(array[87]);      //undefined  

 可以用delete操作符删除数组的元素,注意这个删除仅仅是将数组在该位置的元素设为undefined,数组的长度并没有改变.我们已经使用过了数组的length属性,length属性是一个可以读/写的属性,也就是说我们可以通过改变数组的length属性来任意的改变数组的长度.如果将length设为小于数组长度的值,则原数组中索引大于length-1的值都会被删除.如果length的值大于原始数组的长度,则在它们之间的值设为undefined.

Js代码  

1.var array = new Array("n1","n2","n3","n4","n5");  //五个元素的数组  

2.var astring = "";  

3.for(var i=0; i

4.    astring += array[i];  

5.}  

6.alert(astring);       //n1n2n3n4n5  

7.delete array[3];                   //删除数组元素的值  

8.alert(array.length + "_" + array[3])  //5_undefined  

9.  

10.array.length = 3;    //缩减数组的长度  

11.alert(array[3]);     //undefined  

12.array.length = 8;    //扩充数组的长度  

13.alert(array[4]);     //undefined  

 对于数组的其他方法诸如join/reverse等等,在这就不再一一举例.

通过上面的解释,我们已经知道,对象的属性值是通过属性的名字(字符串类型)来获取,而数组的元素是通过索

引(整数型0~~2**32-1)来得到值.数组本身也是一个对象,所以对象属性的操作也完全适合于数组.

 

Js代码  

1.var array = new Array("no1","no2");  

2.array["po"] = "props1";  

3.alert(array.length);   //2  

4.//对于数组来说,array[0]同array["0"]效果是一样的(?

不确定,测试时如此)  

5.alert(array[0] + "_" + array["1"] + "_" + array.po);//no1_no2_props1  

 

javascript面向对象技术基础(三)

函数

javascript函数相信大家都写过不少了,所以我们这里只是简单介绍一下.

创建函数:

functionf(x){........}

varf=function(x){......}

上面这两种形式都可以创建名为f()的函数,不过后一种形式可以创建匿名函数

函数定义时可以设置参数,如果传给函数的参数个数不够,则从最左边起依次对应,其余的用undefined赋值,如果传给函数的参数多于函数定义参数的个数,则多出的参数被忽略.

 

Js代码  

1.function myprint(s1,s2,s3) {  

2.    alert(s1+"_"+s2+"_"+s3);  

3.}  

4.myprint();      //undefined_undefined_undefined  

5.myprint("string1","string2"); //string1_string2_undefined  

6.myprint("string1","string2","string3","string4"); //string1_string2_string3  

 

因此,对于定义好的函数,我们不能指望调用者将所有的参数全部传进来.对于那些必须用到的参数应该在函数体中

加以检测(用!

操作符),或者设置默认值然后同参数进行或(||)操作来取得参数.

 

Js代码  

1.function myprint(s1,person) {  

2.    var defaultperson = {   //默认person对象  

3.        "name":

"name1",  

4.    "age":

18,  

5.    "sex":

"female"  

6.    };  

7.    if(!

s1) {    //s1不允许为空  

8.        alert("s1 must be input!

");  

9.    return false;  

10.    }  

11.    person = person || defaultperson;  //接受person对象参数  

12.    alert(s1+"_"+person.name+":

"+person.age+":

"+person.sex);  

13.};  

14.  

15.myprint(); //s1 must be input!

  

16.myprint("s1"); //s1_name1:

18:

female  

17.myprint("s1",{"name":

"sdcyst","age":

23,"sex":

"male"});  //s1_sdcyst:

23:

male  

 

函数的arguments属性

在每一个函数体的内部,都有一个arguments标识符,这个标识符代表了一个Arguments对象.Arguments对象非常类似于Array(数组)对象,比如都有length属性,访问它的值用"[]"操作符利用索引来访问参数值,但是,二者是完全不同的东西,仅仅是表面上有共同点而已(比如说修改Arguments对象的length属性并不会改变它的长度).

 

Js代码  

1.function myargs() {  

2.    alert(arguments.length);  

3.    alert(arguments[0]);  

4.}  

5.myargs();   //0  ---  undefined  

6.myargs("1",[1,2]);  //2 --- 1  

 Arguments对象有一个callee属性,标示了当前Arguments对象所在的方法.可以使用它来实现匿名函数的内部递归调用.

Js代码  

1.function(x) {  

2.    if (x <= 1) return 1;  

3.    return x * arguments.callee(x-1);  

4.}  (section8.2)  

 ------------------------------------------------------------------

Method--方法

方法就是函数.我们知道,每一个对象都包含0个或多个属性,属性可以是任意类型,当然也包括对象.函数本身就是一种对象,因此我们完全可以把一个函数放到一个对象里面,此时,这个函数就成了对象的一个方法.此后如果要使用该方法,则可以通过对象名利用"."操作符来实现.

Js代码  

1.var obj = {f0:

function(){alert("f0");}}; //对象包含一个方法  

2.function f1() {alert("f1");}  

3.obj.f1 = f1;    //为对象添加方法  

4.  

5.obj.f0(); //f0  f0是obj的方法  

6.obj.f1(); //f1  f1是obj的方法  

7.f1();     //f1  f1同时又是一个函数,可以直接调用  

8.f0();     //f0仅仅是obj的方法,只能通过对象来调用  

 

方法的调用需要对象的支持,那么在方法中如何获取对象的属性呢?

this!

this关键字我们已经很熟悉了,在javascript的方法中,我们可以用this来取得对方法调用者(对象)的引用,从而获取方法调用者的各种属性.

 

Js代码  

1.var obj = {"name":

"NAME","sex":

"female"};  

2.obj.print = function() {  //为对象添加方法  

3.    alert(this.name + "_" + this["sex"]);  

4.};  

5.obj.print();  //NAME_female  

6.obj.sex = "male";  

7.obj.print();  //NAME_male  

 

下面我们来一个更加面向对象的例子.

Js代码  

1.var person = {name:

"defaultname",  

2.              setName:

function(s){  

3.              this.name = s;  

4.          },  

5.          "printName":

function(){  

6.              alert(this.name);  

7.          }}  

8.person.printName();       //defaultname  

9.person.setName("newName");  

10.person.printName();       //newName  

 

在上面的例子中,完全可以用person.name=..来直接改变person的name属性,在此我们只是为了展示一下刚才提到的内容.另一种改变person属性的方法就是:

定义一个function,接收两个参数,一个是person,一个是name的值,看起来像是这样:

changeName(person,"newName").哪种方法好呢?

很明显,例子中的方法更形象,更直观一些,而且好像有了那么一点面向对象的影子.

再次强调一下,方法(Method)本身就是是函数(function),只不过方法的使用更受限制.在后面的篇幅中,如果提到函数,那么提到的内容同样适用于方法,反之则不尽然.

函数的prototype属性

每一个函数都包含了一个prototype(原型)属性,这个属性构成了javascript面向对象的核心基础.在后面我们会详细讨论.

javascript面向对象技术基础(四)

类、构造函数、原型

先来说明一点:

在上面的内容中提到,每一个函数都包含了一个prototype属性,这个属性指向了一个prototype对象(Every functionhasaprototypepropertythatreferstoapredefinedprototypeobject --section8.6.2).注意不要搞混了.

构造函数:

new操作符用来生成一个新的对象.new后面必须要跟上一个函数,也就是我们常说的构造函数.构造函数的工作原理又是怎样的呢?

先看一个例子:

Js代码  

1.function Person(name,sex) {  

2.    this.name = name;  

3.    this.sex = sex;  

4.}  

5.var per = new Person("sdcyst","male");  

6

展开阅读全文
相关资源
猜你喜欢
相关搜索
资源标签

当前位置:首页 > 农林牧渔 > 林学

copyright@ 2008-2023 冰点文库 网站版权所有

经营许可证编号:鄂ICP备19020893号-2