当前位置:17727 > www.17727.com > 更新中_javascript技巧_脚本之家,Javascript高级程序

更新中_javascript技巧_脚本之家,Javascript高级程序

文章作者:www.17727.com 上传时间:2019-12-26

一.prototype原型对象,需要注意的原则是: . 使用原型可以大量减少每个对象对内存的需求量,因为对象可以继承许多属性。 . 即使属性在对象被创建之后才被添加至原型中,对象也能够继承这些属性。 示例代码: 复制代码 代码如下:

主要结论:

三、对象基础

运行结果为: prototype属性: 1. 使用原型可以大量减少每个对象对内存的需求量,因为对象可以继承许多属性。

只有函数对象有prototype原型属性,而且函数对象的原型(prototype)指向该函数对象的实例对象

1、 ECMAScript的对象(object)像一个集合,可以随时添加新的属性或方法。

  1. 即使属性在对象被创建之后才被添加至原型中,对象也能够继承这些属性。 二.setTimeout和setInterval 两个函数都定义在window对象中。setTimeout(fun_name,time_minisec)作用是在time时间后运行fun_name函数一次;setInterval(fun_name,time_minisec)作用是每隔time_sec时间都去运行fun_name函数。 示例代码如下: 复制代码 代码如下:

任何对象都有__proto__属性,也可称为隐式原型,而且一个对象的隐式原型指向构建该对象的构造函数的原型prototype

2、 对象由特性(attribute)构成,特性可以是原始值,也可以是引用值,如果特性存放的是函数,它将被看作对象的方法(method),否则该特性被看作属性(property)。

三.本地对象,内置对象和宿主对象 1.本地对象包含的内容有 Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、URIError 都是一些 ECMA-262 定义的引用类型。 2.内置对象:由 ECMAScript 实现提供的、独立于宿主环境的所有对象,在 ECMAScript 程序开始执行时出现, 内置对象只有两个Global 和 Math ,它们都是本地对象。内置对象就是一种特殊的本地对象。 3.宿主对象:所有非本地对象都是宿主对象,即由 ECMAScript 实现的宿主环境提供的对象。 总之,本地对象,就是那些官方定义好了的对象。内置对象是本地对象的一种,其只包含Global对象和Math对象。而宿主对象则是那些官方未定义,你自己构建的对象加上DOM和BOM对象组成的。 四.Array.prototype.slice.call 的使用相当于_array.slice,不过Array.prototype.slice.call的效率要远远高过第二种用法。 示例: function p { document.write; } p(Array.prototype.slice.call; p; 运行结果: 3,4 3,4 (注:记录一下这些内容只是以后查阅起来方便,作为自己知识积累的记录。其中有很多是参考网络上的资源,不再一一写出出处,还请原作者见谅。)

任何对象都有constructor属性,而且一个对象的constructor属性指向创建该对象的构造函数。

3、 ECMAScript有无用存储单元收集程序,意味着不必专门销毁对象来释放内存。把对象的所有引用都设置为null,可以强制性地废除对象。如果一个对象有两个或更多引用,则要正确废除该对象必须将其所有引用都 设置为null。

  1. 除了JSON和Math, js中所有的内置对象(如Number, String, Array, Error, RegExp, Object, Boolean, Date, Event)typeof都是function, json和math是object.

4、 “独立于宿主环境的ECMAScript实现提供的对象”称为本地对象(native object)。ECMA-262定义的类包括:

2.__proto__是隐藏属性,不管是普通对象还是函数对象都有该属性. 所有的对象的obj都具有proto属性(null和undefined除外),可称为隐式原型。一个对象的隐式原型指向构造该对象的构造函数的原型,即为函数对象的prototype属性。如下图

Object               Function           Array                 String

www.17727.com 1

Boolean             Number            Date                  RegExp

www.17727.com 2

Error                 EvalError          RangeError         ReferenceError

Object.__proto__ ===> function (){}

SyntaxError       TypeError         URIError

Date.__proto__ ===> function (){}

5、 Array类:

Error.__proto__ ===> function (){}

l 创建Array类对象:

RegExp.__proto__===> function (){}

var aValues = new Array();

Number.__proto__ ===> function (){}

l 创建指定大小的Array对象:

String.__proto__ ===> function (){}
Boolean.__proto__ ===> function (){}

var aValues = new Array(20);

Array.__proto__ ===> function (){}

l 创建不指定大小的Array对象:

然而这些内置对象的实现则指向相应的内置对象,如:

var aColors = new Array();

str1.__proto__ ====> String

aColors[0] = “red”;

arr1__proto__ ====> []

aColors[1] = “green”;

n1__proto__ ====> Number

aColors[2] = “blue”;

bl1__proto__ ====> Boolean

l 创建并初始化Array对象

但是Error,Date 和 Object的实现指向Object

var aClors = new Array(“red”, “green”, “blue”);

============================================

l 数组可以根据需要增大或减小。数组增大时没有赋值的位置都会填上null,如:

Object.prototype ===> Object{ }

var aColors = new Array(“red”, “green”, “blue”);

Date.prototype ===> Object{ }

Alert(aColors.length);           // ouputs “3”

Error.prototype ===> Object{ }

aColors[25] = “purple”;

RegExp.prototype===> Object{}

alert(aColors.length);           // outputs “26”

Event.prototype===> Object{}

l 可以用字面量表示定义Array对象,即使用方括号“[”和“]”,用逗号分隔值。

Number.prototype===> Number{ }

var aColors = [“red”, “green”, “blue”];

String.prototype ===> String{ }

l Array类的toString()方法和valueOf方法,返回特殊的字符串。该字符串是通过对每项调用toString()方法转为字符串后,用逗号“,”把它们连接在一起构成的。

Boolean.prototype ===>Boolean{ }

l join()方法也是用来把Arrray各项连接成字符串的。它只有一个参数,可以指定分隔符。如:

Array.prototype ===> [ ]

alert(aColors.join(“][“));          // outputs   “red][green][blue][“

Function.prototype ===> function(){}

l 字符串通过split()方法能转换为数组。当split()的参数为空字符串时,返回的数组中的每个项是字符串的字符。如:

然而这些内置对象的实现则指向相应的内置对象,如:

var sColors = “green”;

str1.__proto__ ====> String

var aColors = sColors.split(“”);

arr1__proto__ ====> []

alert(aColors.toString());                   // ouputs “g,r,e,e,n”

n1__proto__ ====> Number

l Array常用方法:

bl1__proto__ ====> Boolean

Ø concat():将参数中的项附加到数组末尾。如:
var aColors2 = aColors.concat(“yellow”, “purple”);

也就是说,每个内置对象的__protot

Ø slice():返回指定位置的数组项。如:
var aColors = [“red”, “green”, “blue”, “yellow”, “purple”];
var aColros2 = arr.slice(1);
var aColors3 = arr.slice(1, 4);
alert(aColors2.toString());                      // outputs “green,blue,yellow,purple”
alert(aColors3.toString());                     // outputs “green,blue,yellow”

3.prototype是显式原型,只有函数对象才有,即以function创建的

Ø Array对象提供了两个方法push()和pop()。push()方法用于在Array结尾添加一个或多个项,pop()方法用于删除最后一个数组项(length-1),并把该项作为函数的返回值。利用push()和pop()方法可把Array对象模拟为一个栈(stack)。

function a () {};

Ø shift():删除数组中的第一个项,并返回该项作为函数返回值。利用shift()和push()方法可把Array对象模拟为一个队列(queue)。

var obj = new a();

Ø unshift():把一个项放在数组的第一个位置,然后把余下的项向下移动一个位置。

a.prototype = new Object();

Ø reverse():颠倒数组。

a.prototype = obj; 因此一个函数对象a的prototype 属性指向的是该函数对象a的实例对象obj。

Ø sort():按升序排序数组项。根据字符代码(ASCII)大小排序。

4.所有对象的实例是没有prototype属性的(不管是new方式创建的还是对象字面量的方式创建的)

Ø splice():最复杂的方法,功能是把数据项插入数组的中部。该方法用于插入这些项的方式的变体大有用途:
删除——当只声明两个参数时,就可以删除数组的任意多个项。如arr.splice(0, 2)将删除数组arr中的前两项。
替换——声明三个参数时,可以把指定的数据项替换掉。这三个参数的意义是起始位置,删除的数组项的个数,要插入的项。如arr.splice(2, 2, “red”, “green”)将把位置2处的两项删除,并把”red”和”green”插入到该位置,达到替换的目的。

5.一个对象的constructor指向创建它的对象,如下图

6.         内置对象是指独立于宿主环境,由ECMAScript在程序开始时就实例化的对象。ECMA-262只定义了两个内置对象,即Global和Math。

www.17727.com 3

7.         Global对象是ECMAScript最特别的对象,因为根本看不到它的存在。之前章节介绍的函数isNaN()、isFinite()等都是Global对象的方法。而且Grobal对象的方法不止这些。

说到prototype,就不得不先说下new的过程。

l encodeURI()和encodeURIComponent()——encodeURI用于对完整的URL进行编码,而encodeURIComponent用于处理URI的一个片断。这两个方法可代替BOM的escape()方法。

我们先看看这样一段代码:

l decodeURI()和decodeURIComponent()——用于对编码的URI进行解码。这两个方法可代替BOM的unescape()方法。

www.17727.com,var Person =function() { };

l eval()——该方法就像整个ECMAScript的解释程序,接受一个参数,参数是即要执行的ECMAScript字符串。例如:
eval(“alert(‘hi’)”);
这行代码的功能行等价于下面的代码:
alert(“hi”);
当解释程序发现eval()调用时,它将把参数解释为真正的ECMAScript语句,然后把它插入该函数所在的位置。这意味着eval()调用内部引用的变量可在参数以外定义:
var msg = “hello world”;
eval(“alert(msg)”);          // outputs “hello world”

var p =new Person();

8.         Math对象包括许多专门用于执行简单的及复杂的数学计算的方法。

很简单的一段代码,我们来看看这个new究竟做了什么?我们可以把new的过程拆分成以下三步:

l ceil()——向上舍入函数

<1> var p={}; 也就是说,初始化一个对象p。

l floor()——向下舍入函数

Person.prototype = new Object();

l round()——标准的舍入函数,即四舍五入

Person.prototype = p;

l random()——返回一个0到1之间的随机数,不包括0和1。可用下面的形式调用random()方法,在某个范围内选择随机数:
number = Math.floor(Math.random() * total_number_of_choices + first_possible_value)

<2> p.__proto__=Person.prototype;

9.         所有非本地对象都是宿主对象**(host object)**,即由ECMAScript实现的宿主环境提供的对象。所有BOM和DOM对象都是宿主对象。

<3> Person.call(p);也就是说构造p,也可以称之为初始化p。

10.     关键字this总是指向调用该方法的对象,例如:
var oCar = new Object();
oCar.color = “red”;
oCar.showColor = function(){
        alert(this.color);              // outputs “red”
};
使用this,可在任意多个地方重用同一个函数。例如:
function showColor(){
        alert(this.color);
}

关键在于第二步,我们来证明一下:

var oCar1 = new Object;
oCar1.color = “red”;
oCar1.showColor = showColor;

var Person =function() { };

var oCar2 = new Object;
oCar2.color = “blue”;
oCar2.showColor = showColor;

var p =new Person();

oCar1.showColor();                   // outputs “red”
oCar2.showColor();                  // outputs “blue”

alert(p.__proto__ === Person.prototype);

 

这段代码会返回true。说明我们步骤2的正确。

11.     定义类或对象。

那么__proto__是什么?我们在这里简单地说下。每个对象都会在其内部初始化一个属性,就是__proto__,当我们访问一个对象的属性

l 工厂方式

时,如果这个对象内部不存在这个属性,那么他就会去__proto__里找这个属性,这个__proto__又会有自己的__proto__,于是就这样

l 构造函数方式,像工厂方式一样,构造函数方式也会重复生成函数,为每个对象都创建独立的函数版本。不过,与工厂方式相似,也可以用外部函数重写构造函数。

一直找下去,也就是我们平时所说的原型链的概念。

l 原型方式,利用对象的prototype属性,能使多个对象共享相同的函数,不好的是构造函数不能有参数,当属性指向的是一个对象时,多个实例也会共享该对象

在 ECMAScript 中,所有对象并非同等创建的。

l 混合的构造函数/原型方式,结合了两种方式的优点,这是目前使用最广泛的类定义方式。例如:

一般来说,可以创建并使用的对象有三种:本地对象、内置对象和宿主对象。

  function Car(sColor, iDoors, iMpg){           // 构造函数方式定义属性
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.drivers = new Array(“Mike”, “Sue”);
}

本地对象

Car.prototype.showColor = function(){               // 原型方式定义函数,使多个实例能共享相同的函数
    alert(this.color);
};

ECMA-262 把本地对象(native object)定义为“独立于宿主环境的 ECMAScript 实现提供的对象”。简单来说,本地对象就是 ECMA-262 定义的类(引用类型)。它们包括:

var oCar1 = new Car(“red”, 4, 23);
var oCar2 = new Car(“blue”, 3, 25);

Object

oCar1.drivers.push(“Matt”);

Function

alert(oCar1.drivers);                   // outputs “Mike,Sue,Matt”
alert(oCar2.drivers);                 // outputs “Mike, Sue”

Array

l 动态原型方法,动态原型方法的优点是可以把属性定义和函数定义把封装在一起,不用分开定义。

String

l 混合工厂方式,与经典的工厂方式不同,这种方式可以使用new运算符,使它更像真正的构造函数。不过同经典的工厂方式存在相同的问题,不建议使用。

Boolean

Number

Date

RegExp

Error

EvalError

RangeError

ReferenceError

SyntaxError

TypeError

URIError

相关页面

JavaScript 高级教程:ECMAScript 引用类型

JavaScript 高级教程:ECMAScript Function 类

JavaScript 参考手册:Array 对象

JavaScript 参考手册:Boolean 对象

JavaScript 参考手册:Date 对象

JavaScript 参考手册:Number 对象

JavaScript 参考手册:String 对象

JavaScript 参考手册:RegExp 对象

内置对象

ECMA-262 把内置对象(built-in object)定义为“由 ECMAScript 实现提供的、独立于宿主环境的所有对象,在

ECMAScript 程序开始执行时出现”。这意味着开发者不必明确实例化内置对象,它已被实例化了。ECMA-262 只定义了两个内置对象,即

Global 和 Math (它们也是本地对象,根据定义,每个内置对象都是本地对象)。

相关页面

JavaScript 参考手册:Global 对象

JavaScript 参考手册:Math 对象

宿主对象

所有非本地对象都是宿主对象(host object),即由 ECMAScript 实现的宿主环境提供的对象。

所有 BOM 和 DOM 对象都是宿主对象。

相关页面

JavaScript 高级教程:JavaScript 实现

W3School 参考手册:JavaScript 参考手册

W3School 教程:HTML DOM 教程

本文由17727发布于www.17727.com,转载请注明出处:更新中_javascript技巧_脚本之家,Javascript高级程序

关键词: