深入理解JavaScript中的结构器

发布时间：10/01 来源：未知浏览：关键词：

对结构函数有很好的懂得是你把握JavaScript这门说话的重点。我们都知道JavaScript不像其他说话，它没有class关键字，但是它有跟function非常类似的结构函数。这篇文章我们一起来具体地理解JavaScript结构函数怎样结构对象。

结构函数跟一般函数非常类似，但是我们通过new关键字来使用它们。主要有两品种型的结构函数，native结构函数（Array,Object）它们可以在施行环境中主动生成，还有自定义的结构函数，你可以定义本人的办法和属性。

当你想要创立许多类似的对象（具有雷同的属性和办法）的时候，使用结构函数是非常有效的。大部分程序员都遵照公约，使用大写字母开头来将结构函数和一般函数区分开。看看下面的代码。

function Book() { 
    // unfinished code
} 
var myBook = new Book();

最后一行代码创立了一个Book对象，并把它赋值给变量；这样完成之后，即便Book结构器没有做任何操纵，myBook也是Book实例。正如你看到的，除了首字母大写和使用new关键字之外，结构函数和一般函数并没有什么不同。

推断实例的类型

推断某个对象可否为某种实例，我们可以使用instanceof操纵符：

myBook instanceof Book    // => true
myBook instanceof String  // => false

留意：假如右侧不是一个函数的实例，那么将会报错：

myBook instanceof {}; // => TypeError: invalid 'instanceof' operand ({})

另一种办法是使用constructor属性，所有对象实例都有一个constructor属性，这个属性指向创立它的结构函数。

myBook.constructor == Book;   // => true

就像myBook的constructor指向Book一样。所有对象都从它们的原型上继承了constructor这个属性：

var s = new String("text");
s.constructor === String;      // => true
"text".constructor === String; // => true
var o = new Object();
o.constructor === Object;      // => true
var o = {};
o.constructor === Object;      // => true
var a = new Array();
a.constructor === Array;       // => true
[].constructor === Array;      // => true

尽管使用constructor可以用来检测实例类型，但是倡议还是使用instanceof办法。由于constructor属性是可以被重写的..用起来不太靠谱。

自定义结构函数

结构函数就像饼干印模。统一印模制作出来的，都是统一个diao样(男人没一个好东西也是这个事理)。

function Book(name, year) {
    this.name = name;
    this.year = '(' + year + ')';
}

Book结构器需要两个参数，当使用new关键字结构对象时，会把两个形参传给Book对象的name 和 year。

var firstBook = new Book("Pro AngularJS", 2014);
var secondBook = new Book("Secrets Of The JavaScript Ninja", 2013); 
var thirdBook = new Book("JavaScript Patterns", 2010);

console.log(firstBook.name, firstBook.year);           
console.log(secondBook.name, secondBook.year);           
console.log(thirdBook.name, thirdBook.year);

如你所见，我们可以通过传不一样参数，快速创立另一本书。JavaScript的Array(),Date()也是这个事理。

Object.defineProperty 办法

Object.defineProperty 办法可以在结构器中被使用来配置属性。

function Book(name) { 
    Object.defineProperty(this, "name", { 
        get: function() { 
            return "Book: " + name;       
        },        
        set: function(newName) {            
            name = newName;        
        },               
        configurable: false     
    }); 
}
var myBook = new Book("Single Page Web Applications");
console.log(myBook.name);    // => Book: Single Page Web Applications
// we cannot delete the name property because "configurable" is set to false
delete myBook.name;    
console.log(myBook.name);    // => Book: Single Page Web Applications
// but we can change the value of the name property
myBook.name = "Testable JavaScript";
console.log(myBook.name);    // => Book: Testable JavaScript

上面的代码中是调取了祖先的办法。它供给了getter和setter接口。getter办法负责返回封装的值，setter办法接受参数，并把值赋给属性。当我们在某个属性上操纵存取时，调取的就是这两个办法。通过配置configurable，我们可以设定该值能否被删除。

对象字面量表示法是首选的结构函数

JavaScript说话九种内建的结构器：Object(), Array(), String(), Number(), Boolean(), Date(), Function(), Error() 乃至 RegExp()。当我们需要创立这些值的时候，我们可以自在选中使用字面量或者结构器。但是雷同状况下，字面量对象不仅易读，并且运转速度更快，由于他们可以在解析的时候被优化。所以当你需要使用简便对象的时候就使用字面量吧。

// a number object
// numbers have a toFixed() method
var obj = new Object(5);
obj.toFixed(2);     // => 5.00
// we can achieve the same result using literals
var num = 5;
num.toFixed(2);     // => 5.00
// a string object
// strings have a slice() method 
var obj = new String("text");
obj.slice(0,2);     // => "te"
// same as above
var string = "text";
string.slice(0,2);  // => "te"

使用new关键字是必不成少的

记得使用结构器的时候要用new关键字，假如你不当心健忘了，那么结构器中的this指向的是global对象(阅读器中默许为window)。

function Book(name, year) {
    console.log(this);
    this.name = name;
    this.year = year;
}
var myBook = Book("js book", 2014);  
console.log(myBook instanceof Book);  
console.log(window.name, window.year);
var myBook = new Book("js book", 2014);  
console.log(myBook instanceof Book);  
console.log(myBook.name, myBook.year);

上面的代码运转结果如下所示：

假如是在严厉模式下，上面的代码将会抛出错误，由于严厉模式不同意我们不使用new关键字调取结构器。

适用范畴更高的结构器

为理解决大概会健忘使用new关键字的风险，我们可以通过推断this的值创立适用范畴更高的结构器。

function Book(name) { 
    if (!(this instanceof Book)) { 
        // the constructor was called without "new".
        return new Book(name);
    } 
}

加上这段代码之后，我们就可以‘胡作非为’地使用结构器了。

function Book(name, year) { 
    if (!(this instanceof Book)) { 
        return new Book(name, year);
    }
    this.name = name;
    this.year = year;
}
var person1 = new Book("js book", 2014);
var person2 = Book("js book", 2014);
console.log(person1 instanceof Book);    // => true
console.log(person2 instanceof Book);    // => true

许多内建的结构器都是这么做的。通过推断this可否为当前类型。假如程序员健忘加new关键字，那么我们就返回一个通过new出来的对象。