面向对象的 JavaScript

面向对象的 JavaScript

对象（Object）是组成 JavaScript 的基本单元，事实上，JavaScript 中一切都是对象

JavaScript 语言中最重要的几个部分：引用（reference），作用域（scope），闭包（closure）以及上下文（context）

引用（reference）

引用（reference）的概念是 JavaScript 的基础之一，"引用"是一个指向对象实际位置的指针，但是有一个前提：实际的对象肯定不会是引用（字符串永远是字符串，数组永远是数组），不过多个变量却能够指向同一对象

此外，对象可以包含一系列属性（property），这些属性也都不过是到其他对象（比如字符串，数字，数组等等）的引用，如果多个变量指向的是同一个对象，那该对象的类型一改变，所有这些变量也会跟着相应改变

多个变量引用同一个对象

var obj = new Object();

// objRef 现在是另外一个对象的引用
var objRef = obj;

// 修改原对象的一个属性
obj.oneProperty = true;

// 这个改变在两个变量中都反映了出来（因为它们引用的是同一个对象）
console.log( obj.oneProperty === objRef.oneProperty )  // true

自修改对象的例子

var items = ["one", "two", "three"];

// 数组的一个引用
var itemsRef = items;

items.push("four");

// 这两个数组指向同一个数组对象，所以，它们的长度是一致的
console.log( items.length == itemsRef.length );  // true

需要记住的是，引用指向的只能是具体的对象，而不是另一个引用（JavaScript里的结果是沿着引用链一直上溯到原来那个对象）

修改对象的引用，同时保持完整性

var items = ["one", "two", "three"];

var itemsRef = items;

items = ["four"];

// items 和 itemsRef 现在指向不同的对象
// items 指向的是 ["four"] 这个数组
// itemsRef 指向的是 ["one", "two", "three"] 这个数组
console.log( items != itemsRef )  // true

从上面这个例子可以看出，实际对象已经改变了，但是原来指向它的引用仍然保持指向旧的对象

我们再来看下面这个特殊的例子，看上去像是自修改对象，但是其结果却产生了一个新的非引用对象

在执行字符串连接操作的时候，结果总是会一个新的字符串对象，而非原字符串的修改版本

var item = "test";

var itemRef = item;

// 这会创建一个新的对象，而非修改原对象
item += "ing";

// 不相等，因为新的字符串对象已经被创建
console.log( item != itemRef )  // true

函数重载和类型检查

函数重载（function overloading）

函数重载（function overloading）必须依赖两件事情：判断传入参数的数量的能力和判断传入参数类型的能力

JavaScript 的每个函数都带有一个仅在这个函数范围内作用的变量（contextual variable）称为参数（argument），它是一个包含所有传给函数的参数的伪数组（pseudo-array）

函数重载的两个例子

// 实例一
function sendMsg(msg, obj) {
    if (arguments.length == 2) {
        obj.handleMsg(msg);
    } else {
        console.log(msg);
    }
}

// 仅提供一个参数
sendMsg("hello world!");

// 两个参数
sendMsg("hello", {
    handleMsg: function (msg) {
        console.log(msg)
    }
})




// 实例二
function makeArray() {

    var arr = [];

    // 遍历传入的每个参数
    for (var i = 0; i < arguments.length; i++) {
        arr.push(arguments[i]);
    }

    return arr;
}

类型检查

这里只讨论两种比较有用的方法

第一种方法是使用显而易见的 typeof 操作符。

这个工具提供了一个字符串名称（string name），用于表达内容的类型，当变量不是 object 或者 array 类型的时候，这应该算是最完美的解决方法了，但是对于自定义的对象，比如 obj 就不能用这个方法了，因为它只会返回 object

使用 typeof 来判断对象类型

// 检查 num 是否实际上是字符串
if (typeof num == "string") {
    // 如果是，则转为整数
    num = parseInt(num)
}

// 检查 arr 是否实际上是字符串
if (typeof arr == "string") {
    // 如果是，则根据 "," 切分为数组
    arr = arr.split(",")
}

第二种检查对象类型的方法，需要引用所有 JavaScript 对象都带有的一个的属性，称为构造函数（constructor），这一属性引用的是原本用来构造该对象的那个函数

使用构造函数属性来判断对象的类型

// 检查 num 是否实际上是字符串
if (num.constructor == String) {
    // 如果是，则转为整数
    num = parseInt(num)
}

// 检查 arr 是否实际上是字符串
if (arr.constructor == Array) {
    // 如果是，则根据 "," 切分为数组
    arr = arr.split(",")
}

作用域

待续...