Js-w3school（2024(2)

call() 和 apply() 功能一样，只是传入的参数列表形式不同：如 func.call(func1,var1,var2,var3)

对应的apply写法为：func.apply(func1,[var1,var2,var3])

call的对比解释

var value = 1;

var foo = {

value: 1

};

function bar() {

console.log(this.value);

}

bar.call(foo); // 1

通过上面的介绍我们知道，call()主要有以下两点

·call()改变了this的指向

·函数 bar 执行了

如果在调用call()的时候把函数 bar()添加到foo()对象中，即如下

var foo = {

value: 1,

bar: function() {

console.log(this.value);

}

};

foo.bar(); // 1

这个改动就可以实现：改变了this的指向并且执行了函数bar

4. 访问对象属性

您能够以两种方式访问属性：

objectName.propertyName

objectName[“propertyName”]

5.访问对象方法

您能够通过如下语法访问对象方法：

objectName.methodName()

比如

name = person.fullName();

如果不用括号

name = person.fullName；将返回

function() { return this.firstName + " " + this.lastName; }

6. 请避免字符串、数值或逻辑对象。他们会增加代码的复杂性并降低执行速度。

var x = new String(); // 把 x 声明为 String 对象

var y = new Number(); // 把 y 声明为 Number 对象

var z = new Boolean(); // 把 z 声明为 Boolean 对象

7 一种面向对象语言需要向开发者提供四种基本能力：

 封装 - 把相关的信息（无论数据或方法）存储在对象中的能力

 聚集 - 把一个对象存储在另一个对象内的能力

 继承 - 由另一个类（或多个类）得来类的属性和方法的能力

 多态 - 编写能以多种方法运行的函数或方法的能力

8.对象废除

把对象的所有引用都设置为 null，可以强制性地废除对象。例如：

var oObject = new Object;

// do something with the object here

oObject = null;

9.早绑定和晚绑定

早绑定（early binding）是指在实例化对象之前定义它的属性和方法，这样编译器或解释程序就能够提前转换机器代码。ECMAScript 不是强类型语言，所以不支持早绑定。

晚绑定（late binding）指的是编译器或解释程序在运行前，不知道对象的类型。使用晚绑定，无需检查对象的类型，只需检查对象是否支持属性和方法即可。ECMAScript 中的所有变量都采用晚绑定方法。

10. 在 ECMAScript 中，所有对象并非同等创建的。一般来说，可以创建并使用的对象有三种：本地对象、内置对象和宿主对象。

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

• Object

• Function

• Array

• String

• Boolean

• Number

• Date

• RegExp

• Error

• EvalError

• RangeError

• ReferenceError

• SyntaxError

• TypeError

• URIError

内置对象：ECMA-262 把内置对象（built-in object）定义为“由 ECMAScript 实现提供的、独立于宿主环境的所有对象，在 ECMAScript 程序开始执行时出现”。这意味着开发者不必明确实例化内置对象，它已被实例化了。ECMA-262 只定义了两个内置对象，即 Global 和 Math （它们也是本地对象，根据定义，每个内置对象都是本地对象）。

宿主对象：所有非本地对象都是宿主对象（host object），即由 ECMAScript 实现的宿主环境提供的对象。所有 BOM 和 DOM 对象都是宿主对象。

10.对象作用域

公用作用域中的对象属性可以从对象外部访问，即开发者创建对象的实例后，就可使用它的公用属性。而私有作用域中的属性只能在对象内部访问，即对于外部世界来说，这些属性并不存在。这意味着如果类定义了私有属性和方法，则它的子类也不能访问这些属性和方法。受保护作用域也是用于定义私有的属性和方法，只是这些属性和方法还能被其子类访问。

• ECMAScript 只有公用作用域

由于缺少私有作用域，开发者确定了一个规约，说明哪些属性和方法应该被看做私有的。这种规约规定在属性前后加下划线：

obj.color = “blue”;

这段代码中，属性 color 是私有的。注意，下划线并不改变属性是公用属性的事实，它只是告诉其他开发者，应该把该属性看作私有的。

有些开发者还喜欢用单下划线说明私有成员，例如：obj._color。

• ECMAScript 没有静态作用域

严格来说，ECMAScript 并没有静态作用域。不过，它可以给构造函数提供属性和方法。还记得吗，构造函数只是函数。函数是对象，对象可以有属性和方法。例如：

function sayHello() {

alert(“hello”);

}

sayHello.alternate = function() {

alert(“hi”);

}

sayHello(); //输出 “hello”

sayHello.alternate(); //输出 “hi”

11.定义类或对象

（1）原始的方式

因为对象的属性可以在对象创建后动态定义，所有许多开发者都在 JavaScript 最初引入时编写类似下面的代码：

var oCar = new Object;

oCar.color = “blue”;

oCar.doors = 4;

oCar.mpg = 25;

oCar.showColor = function() {

alert(this.color);

};

（2）工厂方式

要解决该问题，开发者创造了能创建并返回特定类型的对象的工厂函数（factory function）。

例如，函数 createCar() 可用于封装前面列出的创建 car 对象的操作：

function showColor() {

alert(this.color);

}

function createCar(sColor,iDoors,iMpg) {

var oTempCar = new Object;

oTempCar.color = sColor;

oTempCar.doors = iDoors;

oTempCar.mpg = iMpg;

oTempCar.showColor = showColor;

return oTempCar;

}

var oCar1 = createCar(“red”,4,23);

var oCar2 = createCar(“blue”,3,25);

oCar1.showColor(); //输出 “red”

oCar2.showColor(); //输出 “blue”

（3）构造函数方式

创建构造函数就像创建工厂函数一样容易。第一步选择类名，即构造函数的名字。根据惯例，这个名字的首字母大写，以使它与首字母通常是小写的变量名分开。除了这点不同，构造函数看起来很像工厂函数。请考虑下面的例子：

function Car(sColor,iDoors,iMpg) {

this.color = sColor;

this.doors = iDoors;

this.mpg = iMpg;

this.showColor = function() {

alert(this.color);

};

}

var oCar1 = new Car(“red”,4,23);

var oCar2 = new Car(“blue”,3,25);

（4）原型方式

该方式利用了对象的 prototype 属性，可以把它看成创建新对象所依赖的原型。

这里，首先用空构造函数来设置类名。然后所有的属性和方法都被直接赋予 prototype 属性。我们重写了前面的例子，代码如下：

function Car() {

}

Car.prototype.color = “blue”;

Car.prototype.doors = 4;

Car.prototype.mpg = 25;

Car.prototype.showColor = function() {

alert(this.color);

};

var oCar1 = new Car();

var oCar2 = new Car();

（5）混合的构造函数/原型方式

这种概念非常简单，即用构造函数定义对象的所有非函数属性，用原型方式定义对象的函数属性（方法）。结果是，所有函数都只创建一次，而每个对象都具有自己的对象属性实例。

function Car(sColor,iDoors,iMpg) {

this.color = sColor;

this.doors = iDoors;

this.mpg = iMpg;

this.drivers = new Array(“Mike”,“John”);

}

Car.prototype.showColor = function() {

alert(this.color);

};

var oCar1 = new Car(“red”,4,23);

var oCar2 = new Car(“blue”,3,25);

oCar1.drivers.push(“Bill”);

alert(oCar1.drivers); //输出 “Mike,John,Bill”

alert(oCar2.drivers); //输出 “Mike,John”

（6）动态原型方法

function Car(sColor,iDoors,iMpg) {

this.color = sColor;

this.doors = iDoors;

this.mpg = iMpg;

this.drivers = new Array(“Mike”,“John”);

if (typeof Car._initialized == “undefined”) {

Car.prototype.showColor = function() {

alert(this.color);

};

Car._initialized = true;

}

}

（7）混合工厂方式

function Car() {

var oTempCar = new Object;

oTempCar.color = “blue”;

oTempCar.doors = 4;

oTempCar.mpg = 25;

oTempCar.showColor = function() {

alert(this.color);

};

return oTempCar;

}

这种方式使用 new 运算符，使它看起来像真正的构造函数：

var car = new Car();

12.修改对象

（1）创建新方法

可以用 prototype 属性为任何已有的类定义新方法，就像处理自己的类一样。例如，还记得 Number 类的 toString() 方法吗？如果给它传递参数 16，它将输出十六进制的字符串。如果这个方法的参数是 2，那么它将输出二进制的字符串。我们可以创建一个方法，可以把数字对象直接转换为十六进制字符串。创建这个方法非常简单：

Number.prototype.toHexString = function() {

结尾

正式学习前端大概 3 年多了，很早就想整理这个书单了，因为常常会有朋友问，前端该如何学习，学习前端该看哪些书，我就讲讲我学习的道路中看的一些书，虽然整理的书不多，但是每一本都是那种看一本就秒不绝口的感觉。

以下大部分是我看过的，或者说身边的人推荐的书籍，每一本我都有些相关的推荐语，如果你有看到更好的书欢迎推荐呀。

() {

alert(this.color);

};

return oTempCar;

}

这种方式使用 new 运算符，使它看起来像真正的构造函数：

var car = new Car();

12.修改对象

（1）创建新方法

可以用 prototype 属性为任何已有的类定义新方法，就像处理自己的类一样。例如，还记得 Number 类的 toString() 方法吗？如果给它传递参数 16，它将输出十六进制的字符串。如果这个方法的参数是 2，那么它将输出二进制的字符串。我们可以创建一个方法，可以把数字对象直接转换为十六进制字符串。创建这个方法非常简单：

Number.prototype.toHexString = function() {

结尾

正式学习前端大概 3 年多了，很早就想整理这个书单了，因为常常会有朋友问，前端该如何学习，学习前端该看哪些书，我就讲讲我学习的道路中看的一些书，虽然整理的书不多，但是每一本都是那种看一本就秒不绝口的感觉。

以下大部分是我看过的，或者说身边的人推荐的书籍，每一本我都有些相关的推荐语，如果你有看到更好的书欢迎推荐呀。