JavaScript中的面向对象编程原则

需积分: 9 19 浏览量更新于2024-07-22 收藏 1.7MB PDF 举报

"本书《Object-Oriented Programming in Javascript》由雅虎知名前端工程师Nicholas C. Zakas撰写，旨在教授读者如何在JavaScript环境中正确应用面向对象编程（OOP）原则。" 在JavaScript中实现面向对象编程是软件开发中的一个核心概念，这本书深入探讨了这一主题。 Nicholas C. Zakas在书中首先介绍了面向对象编程的基本原理，帮助读者建立对这一编程范式的理解。 1. 面向对象编程（OOP）基础 OOP是一种编程范式，它基于“对象”的概念，这些对象包含了数据（属性）和操作数据的方法（函数）。在JavaScript中，OOP可以帮助创建可重用、模块化的代码，提高代码的可维护性和可扩展性。 2. 类型系统 - **类型**：在JavaScript中，所有值都有其特定的类型，这决定了值的行为和操作方式。 - **原始类型（Primitive Types）**：包括字符串（String）、数字（Number）、布尔值（Boolean）、空值（null）、未定义（undefined）、符号（Symbol）和大的整数（BigInt）。这些类型的值是不可变的，即一旦创建，其值就不能改变。 - **引用类型（Reference Types）**：主要指的是对象（Object），包括数组（Array）、函数（Function）、日期（Date）等。与原始类型不同，引用类型存储的是对象的引用，而不是实际的值。这意味着，当多个变量引用同一个对象时，修改其中一个变量会影响到其他所有引用该对象的变量。 3. JavaScript的特殊之处 - 动态类型：JavaScript是动态类型的，意味着变量的类型可以在运行时改变。 - 函数作为一等公民：函数在JavaScript中可以赋值给变量，可以作为参数传递，也可以作为返回值。 - 构造函数和原型链：JavaScript没有类，而是通过构造函数来创建对象，并使用原型链来实现继承。 4. 基于原型的继承 JavaScript使用原型（Prototype）机制来实现继承，每个对象都有一个内置的`__proto__`属性，指向它的构造函数的原型对象。原型链使得子对象能够访问父对象的属性和方法。 5. 封装与模块化通过闭包和立即执行函数表达式（IIFE）可以实现JavaScript中的封装，保护内部变量和函数不被外部访问，实现模块化设计。 6. 多态与接口虽然JavaScript没有接口这一概念，但可以通过约定和函数签名实现多态，确保不同对象对同一消息作出一致的响应。 7. 设计模式书中可能会讨论一些常见的JavaScript设计模式，如工厂模式、单例模式、观察者模式等，这些都是在实际开发中提高代码质量的重要工具。通过阅读这本书，开发者不仅可以掌握JavaScript中的OOP实践，还能学习到如何在实际项目中应用这些概念，从而编写出更高效、更易于维护的代码。此外，作者还可能分享了一些最佳实践和避免常见错误的建议，这对于提升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页未读，继续阅读

xsong1985

粉丝: 0
资源: 3

JavaScript中的面向对象编程原则

Packt.Object-Oriented.JavaScript.3rd.Edition

Learning Object-Oriented Programming(PACKT,2015)

Mastering JavaScript Object-Oriented Programming

Mastering JavaScript Object-Oriented Programming 无水印pdf

Object-oriented-programming-for-JavaScript-developers:适用于JavaScript开发人员的面向对象编程的代码存储库

10-Object-Oriented-Programming-Team-Profile-Generator

.Principles.of.Object-Oriented.Programming.in.JavaScript

Mastering-JavaScript-Object-Oriented-Programming:Packt出版的《精通JavaScript面向对象编程的代码库》

10Object-Oriented-Programming-Team-Profile-Generator

object-oriented-programming_in_[removed]了解有关OOP的所有知识，了解JavaScript中最令人困惑的部分，并准备进行技术面试

最新资源