javascript变量声明，hoisting机制，面向对象

以下不遵守可能引起未知错误

1.  表示区块起首的花括号，不要另起一行。

2.  不要省略句末的分号

3.  不要使用with语句，可以减少代码的书写，但是会造成混淆。

4.  不要使用"相等"（==）运算符，只使用"严格相等"（===）运算符。

== 两边值类型不同的时候，要先进行类型转换，再比较，造成很多意想不到的情况。

=== 不做类型转换，类型不同的一定不等。

0 == ‘‘// true
1 == true // true
2 == true // false
0 == ‘0‘ // true
false == ‘false‘ // false
false == ‘0‘ // true
" \t\r\n " == 0 // true

5.  所有变量申明都要写在函数的头部。所有函数都要在使用之前定义

因为javascript的函数声明和变量声明有一个hoisting机制，声明永远都会被提升至作用域的最顶端。

var a = 10;
(function () {
    alert(a);//undefined
    var a = 20;
})()

//相当于：
var a = 10;
var f = function () {
    alert(a);//undefined
    var a = 20;
}
f()
//相当于：
var a = 10;
function xx() {
    alert(a);//undefined
    var a = 20;
}
xx()
//相当于：
(function () {
    var a;//在这里对变量hoisting，先声明
    alert(a);
    a = 20;//再赋值
})()

注：两种函数声明的var f = function () {}和function f() {} 不一样

f();//有错
var f = function () {
    alert("Hello");
}
//语句相当于：
var f;
f();
f = function () {
    alert("Hello");
}

var b = (function () {
    return 20;
}())

与
(function () {
    var a;//在这里对变量hoisting，先声明
    alert(a);
    a = 20;//再赋值
})()

安全沙箱模式

var f = function foo(){
    return typeof foo;
};typeof foo;// "undefined"
f();// "function"

　函数名 foo 只在该函数的作用域内有用

JavaScript本身中没有提供命名空间机制，为了避免不同函数、对象以及变量名对全局空间的污染，通常的做法是为你的应用程序或者库创建一个唯一的全局对象，然后将所有方法与属性添加到这个对象

function Person(name, age) {

    this.name = name;

    this.age = age;

    this.sayName = function () {

        alert(this.name);

    }

}
Person(1, 2)
alert(name)

//我们在函数的内部，可以使用this.XXX以及var来声明变量。
//区别是使用this.XXX声明的变量在外部是可以访问的。
//使用var声明的变量，由于受到函数作用域的保护，在函数的外部是无法直接访问的。

在JavaScript中，并没有显示的声明私有成员的关键字等。所以要想实现封装/信息隐藏就需要从另外的思路出发。我们可以使用闭包的概念来创建只允许从对象内部访问的方法和属性，来达到封装的要求。

基本方式
一般来说，我们学用的有三种方法来达到封装的目的。

使用this.XXX来声明一个变量，然后再声明getXXX、setXXX等取值、赋值的方法。
使用this._XXX来声明一个变量，然后再声明getXXX、setXXX等取值、赋值的方法。
利用“函数作用域”这一个概念来做。

var Book = function(isbn,title,author){
  this.setIsbn(isbn);
  this.setTitle(title);
  this.setAuthor(author);
};

Book.prototype = {
  setIsbn: function(isbn){
    this.isbn = isbn;
  },
  getIsbn: function(){
    return this.isbn;
  },
  setTitle: function(title){
    this.title = title;
  },
  getTitle: function(){
    return this.title;
  },
  setAuthor: function(author){
    this.author = author;
  },
  getAuthor: function(){
    return this.author;
  }
};
//使用这种方法实现的封装，虽然实现了取值器与赋值器以保护私有属性。但是在实际使用中，私有属性依然可以从外部访问，所以从根本上讲，没有实现封装。

var Book = function(isbn,title,author){
  this.setIsbn(isbn);
  this.setTitle(title);
  this.setAuthor(author);
};

Book.prototype = {
  setIsbn: function(isbn){
    this._isbn = isbn;
  },
  getIsbn: function(){
    return this._isbn;
  },
  setTitle: function(title){
    this._title = title;
  },
  getTitle: function(){
    return this._title;
  },
  setAuthor: function(author){
    this._author = author;
  },
  getAuthor: function(){
    return this._author;
  }
};
//使用这种方法与第一种类似，区别在于使用不同的命名来保护私有属性的使用。但是，从实际应用来说其仍然没有实现封装。

var Book = function(newIsbn,newTitle,newAuthor){
  var isbn,title,author;

  this.setIsbn=function(newIsbn){
    isbn = newIsbn;
  };
  this.getIsbn=function(){
    return isbn;
  };
  this.setTitle=function(newTitle){
    title = newTitle;
  };
  this.getTitle=function(){
    return title;
  };
  this.setIsbn=function(newAuthor){
    author = newAuthor;
  };
  this.getIsbn=function(){
    return author;
  };
}
//由于在JavaScript的函数中声明的变量是有作用域的，所以使用这种方法可以避免在外部直接访问私有属性。基本达到封装所要求的内容。

无论什么时候，只要创建一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。

申明函数Book，
Book的属性prototype的指向
和Book内this指向一样吗

http://www.cnblogs.com/sitemanager/p/3535904.html

必须与new共同使用的构造函数名应以大写字母开头。当new被省略时JavaScript不会有任何编译错误或运行错误抛出。忘记加new时会让不好的事情发生(比如被当成一般的函数),所以大写构造函数名是我们来尽量避免这种情况发生的唯一办法。