JavaScript面向对象编程原则：从基础到实践

5星 · 超过95%的资源需积分: 50 167 浏览量更新于2024-07-21 收藏 1.7MB PDF 举报

《JavaScript面向对象编程原则》是一本由Nicholas C. Zakas编写的书籍，于2014年6月18日发布。该书是Leanpub平台的作品，采用轻量级工具和迭代方式，旨在通过不断获取读者反馈，持续优化内容，最终形成满足读者需求的高质量图书。这本书的目标是帮助开发者深入理解JavaScript中的面向对象编程（OOP）技术，并掌握这一核心编程思想。书的主体部分涵盖了以下知识点： 1. **介绍**：首先，作者会为读者提供一个简短的介绍，明确本书的目标读者，可能包括初学者和已有一定JavaScript基础但希望提升面向对象编程能力的开发者。 2. **目标读者与概述**：这部分将描述这本书适合哪些人群阅读，例如对JavaScript有一定了解但想深化理解OOP概念的程序员，或者希望在JavaScript项目中运用OOP技术进行设计的开发者。 3. **致谢与支持**：作者通常会在这一章节感谢读者、同行和资助者，同时提供帮助和支持的渠道，鼓励读者在遇到问题时寻求互动。 4. **第一章：基本类型与引用类型**：这是OOP基础中的重要章节。书中会讲解JavaScript中的数据类型，区分**基本类型**（如数字、字符串、布尔值等）和**引用类型**（如对象、数组、函数等）。作者会详细介绍这些类型的特性和区别，以及它们在面向对象编程中的应用。 5. **类型系统**：通过实例和理论相结合的方式，解释JavaScript中如何进行类型检查和处理不同类型的数据，这对于理解和实现封装、继承等OOP特性至关重要。 6. **封装**：介绍如何使用封装来隐藏对象内部细节，保护数据安全，提高代码复用性。 7. **继承**：讲解JavaScript中的继承机制，可能是基于原型链的实现，以及如何设计类和子类的关系。 8. **多态**：探讨如何通过接口或抽象类实现多态，让代码更具灵活性和扩展性。 9. **其他主题**：除了以上核心概念，可能还会涉及设计模式、模块化、构造函数、原型方法等其他OOP相关话题。通过阅读《JavaScript面向对象编程原则》，读者可以全面掌握在JavaScript中实施面向对象编程的最佳实践和策略，从而提升自己的编程技能和项目的可维护性。

Chapter 1: Primitive and Reference Types 10

Figure 1-3: Two variables pointing to one object

Dereferencing Objects

JavaScript is a garbage-collected language, so you don’t really need to worry about memory

allocations when you use reference types. However, it’s best to dereference objects that you no

longer need so that the garbage collector can free up that memory. The best way to do this is to

set the object variable to null.

var object1 = new Object();

// do something

object1 = null; // dereference

Here, object1 is created and used before finally being set to null. When there are no more

references to an object in memory, the garbage collector can use that memory for something

else. (Dereferencing objects is especially important in very large applications that use millions

of objects)

Adding or Removing Properties

Another interesting aspect of objects in JavaScript is that you can add and remove properties at

any time. For example:

var object1 = new Object();

var object2 = object1;

object1.myCustomProperty = "Awesome!";

console.log(object2.myCustomProperty); // "Awesome!"

Chapter 1: Primitive and Reference Types 13

var colors = new Array("red", "blue", "green")

console.log(colors[0]); // "red"

Function Literals

You almost always define functions using their literal form. In fact, using the Function

constructor is typically discouraged given the challenges of maintaining, reading, and debugging

a string of code rather than actual code, so you’ll rarely see it in code.

Creating functions is much easier and less error prone when you use the literal form. For example:

function reflect(value) {

return value;

}

// is the same as

var reflect = new Function("value", "return value;");

This code defines the reflect() function, which returns any value passed to it. Even in the case

of this simple function, the literal form is easier to write and understand than the constructor

form. Further, there is no good way to debug functions that are created in the constructor form:

These functions aren’t recognized by JavaScript debuggers and therefore act as a black box in

your application.

Regular Expression Literals

JavaScript also has regular expression literals that allow you to define regular expressions

without using the RegExp constructor. Regular expression literals look very similar to regular

expressions in Perl: The pattern is contained between two slashes, and any additional options

are single characters following the second slash. For example:

var numbers = /\d+/g;

// is the same as

var numbers = new RegExp("\\d+", "g");

The literal form of regular expressions in JavaScript is a bit easier to deal with than the con-

structor form because you don’t need to worry about escaping characters within strings.When

using the RegExp constructor, you pass the pattern in as a string, so you have to escape any

backslashes. (That’s why \d is used in the literal and \\d is used in the constructor.) Regular

expression literals are preferred over the constructor form in Java Script except when the regular

expression is being constructed dynamically from one or more strings.

That said, with the exception of Function, there really isn’t any right or wrong way to instantiate

built-in types. Many developers prefer literals, while some prefer constructors. Choose whichever

method you find more comfortable to use.

Chapter 1: Primitive and Reference Types 14

Property Access

Properties are name/value pairs that are stored on an object. Dot notation is the most common

way to access properties in JavaScript (as in many object-oriented languages), but you can also

access properties on JavaScript objects by using bracket notation with a string.

For example, you could write this code, which uses dot notation:

var array = [];

array.push(12345);

With bracket notation, the name of the method is now included in a string enclosed by square

brackets, as in this example:

var array = [];

array["push"](12345);

This syntax is very useful when you want to dynamically decide which property to access. For

example, here bracket notation allows you to use a variable instead of the string literal to specify

the property to access.

var array = [];

var method = "push";

array[method](12345);

In this listing, the variable method has a value of "push", so push() is called on the array. This

capability is quite useful, as you’ll see throughout this book. The point to remember is that,

other than syntax, the only difference—performance or otherwise—between dot notation and

bracket notation is that bracket notation allows you to use special characters in property names.

Developers tend to find dot notation easier to read, so you’ll see it used more frequently than

bracket notation.

Identifying Reference Types

A function is the easiest reference type to identify because when you use the typeof operator on

a function, the operator should return "function":

function reflect(value) {

return value;

}

console.log(typeof reflect); // "function"

Other reference types are trickier to identify because, for all reference types other than functions,

typeof returns "object". That’s not very helpful when you’re dealing with a lot of different

types. To identify reference types more easily, you can use JavaScript’s instanceof operator.

The instanceof operator takes an object and a constructor as parameters. When the value is an

instance of the type that the constructor specifies, instanceof returns true; otherwise, it returns

false, as you can see here:

剩余92页未读，继续阅读

伪装狙击手

粉丝: 97

JavaScript面向对象编程原则：从基础到实践

The Principles of Object-Oriented JavaScript 无水印原版pdf

Nicholas_C_Zakas-The_Principles_of_JavaScript-EN.pdf

The Principles of Object Oriented.JavaScript

No.Starch.The.Principles.of.Object-Oriented.JavaScript

Javascript.Object.Oriented.Programming.pdf

Mastering JavaScript Object-Oriented Programming

The.Go.Programming.Language.0134190440.epub

The.Dart.Programming.Language.03219277

Mastering.JavaScript.1785281348

英文原版-Modern Programming Made Easy 1st Edition

最新资源