关于JavaScript的书籍集合

《JavaScript 高级程序设计》

第 20 章 JSON

JSON 是 JavaScript 的一个严格的子集，利用了 JavaScript 中的一些模式来表示结构化数据。
JSON 是一种数据格式，JSON 并不从属于 JavaScript。而且，并不是只有 JavaScript 才使用 JSON，毕竟 JSON 只是一种数据格式。很多编程语言都有针对 JSON 的解析器和序列化器。

语法

JSON 的语法可以表示以下三种类型的值。

• 简单值：使用与 JavaScript 相同的语法，可以在 JSON 中表示字符串、数值、布尔值和 null。但JSON 不支持 JavaScript 中的特殊值 undefined。
• 对象：对象作为一种复杂数据类型，表示的是一组无序的键值对儿。而每个键值对儿中的值可以是简单值，也可以是复杂数据类型的值。
• 数组：数组也是一种复杂数据类型，表示的是一组有序的值的列表，可以通过数值索引来访问其中的值。数组的值也可以是任意类型 ———— 简单值、对象或数组。

JSON 不支持变量、函数或对象实例，它就是一种表示结构化数据的格式，虽然与 JavaScript 中表示数据的某些语法相同，但它并不局限于 JavaScript 的范畴。

简单值

最简单的 JSON 数据形式就是简单值。例如，下面这个值是有效的 JSON 数据：

5;
"Hello world!";

JavaScript 字符串与 JSON 字符串的最大区别在于，JSON 字符串必须使用双引号（单引号会导致语法）

对象

var person = {
    name : "Nicholas",
    age : 29
}

// JSON 中的对象要求给属性加引号，实际上，在 JavaScript 中，前面的对象字面量完全可以写成下面这样：
var person = {
    "name" : "Nicholas",
    "age" : 29
};

// JSON 表示上述对象的方式如下：
{
    "name" : "Nicholas",
    "age" : 29
}

与 JavaScript 的对象字面量相比，JSON 对象有两个地方不一样。

• 没有声明变量（JSON 中没有变量的概念）。
• 没有末尾的分号（因为这不是 JavaScript 语句，所以不需要分号）。对象的属性必须加双引号，这在 JSON 中是必须的。

对象中嵌套对象：

{
    "name" : "Nicholas",
    "age" : 29,
    "school" : {
        "name" : "Merrimack College",
        "location" : "North Andover, MA"
    }
}

---

《JavaScript语言精粹》

页码3有资源误删

精华

分析 JavaScript

好的想法：函数、弱类型、动态对象和对象字面量表示法。
坏的想法：全局变量。

JSlint、ESLint

语法

注释

书中建议避免使用 /* */ 注释，而用 // 注释代替。
例如：

/*
var rm_a = /a*/.match(s);
*/

对象

语句

JavaScript 可以通过条件语句（if 和 switch），循环语句（while、for 和 do）、强制跳转语句（break、return 和 throw）和函数调用来改变这个执行序列。

函数

继承

数组

正则表达式

方法

代码风格

优美的特性

附录

糟粕

鸡肋

JSLint

语法图

JSON

// 页码 26

---

《学习JavaScript数据结构与算法》(第3版)

---

《JavaScript 设计模式》

第一篇 面向对象编程

面向对象编程（Object-oriented programming,oop）是一种程序设计范型。它将对象作为程序的基本单元，将程序和数据封装其中，以提高程序的重用性、灵活性和扩展性。

function checkName(){
  //  验证姓名
}

function checkEmail(){
  //  验证邮箱  
}

function checkPassword(){
  //  验证密码  
}

/*
 *  函数的另一种形式
 *  声明了3个全局变量
 *  互相覆盖不易察觉
 */
var checkName = function (){
  //  验证姓名
}

var checkEmail = function (){
  //  验证邮箱  
}

var checkPassword = function (){
  //  验证密码  
}

/*
 *  存放在一个变量里，减少覆盖风险。
 */
var checkobject = {
  checkName: function(){
    //  验证姓名    
  },
  checkEmail: function(){
    //  验证邮箱  
  },
  checkPassword: function(){
    //  验证密码    
  }
}

/*
 *  JavaScript 中函数也是对象。
 *  无法继承
 */
var checkobject = function(){};
checkobject.checkName = function(){
  //  验证姓名    
}
checkobject.checkEmail = function(){
  //  验证邮箱  
},
checkobject.checkPassword = function(){
  //  验证密码    
}

/*
 *  返回新的对象 使用互不影响
 */
var checkobject = function (){
    return {
      checkName: function(){
        //  验证姓名    
      },
      checkEmail: function(){
        //  验证邮箱  
      },
      checkPassword: function(){
        //  验证密码    
      }
    }
}
var a = checkobject();
a.checkEmail()

/*
 *  这样做造成的消耗是奢侈的  
 */
var ckeckobject = function (){
   this.checkName: function(){
     //  验证姓名    
   },
   this.checkEmail: function(){
     //  验证邮箱  
   },
   this.checkPassword: function(){
     //  验证密码    
   }
}
var a = new ckeckobject();
a.checkEmail();

/*
 *  这样创建对象实例的时候，创建出来的对象所拥有的方法就都是一个了。因为它们都要依赖 prototype 原型依次寻找，而
 *  找到的方法都是同一个，它们都绑定在 checkObject 对象类的原型上。
 *  这种方式要将 prototype 写很多遍。
 */
var checkobject = function (){}
checkobject.prototype.checkName: function(){
  //  验证姓名    
}
ckeckobject.prototype.checkEmail: function(){
  //  验证邮箱  
}
ckeckobject.prototype.checkPassword: function(){
  //  验证密码    
}


/*
 *  这两种方式不能混着用，如在后面为对象的原型赋值新对象时，那么它将会覆盖掉之前 prototype 对象赋值的方法  
 */
var checkobject = function (){}
checkobject.prototype={
  checkName: function(){
    //  验证姓名    
  },
  checkEmail: function(){
    //  验证邮箱  
  }, 
  checkPassword: function(){
    //  验证密码    
  }
}
var a = new checkobject();
a.checkName();
a.checkEmail();
a.checkPassword();

/*
 *  避免 a 书写 3遍
 *  那么就要在声明的每个方法末尾处将当前对象返回，在 JavaScript 中 this 指向的就是当前对象，所以你可以将它返回。
 */
var checkobject = {
  checkName: function(){
    //  验证姓名
    return this;
  }
  checkEmail: function(){
    //  验证邮箱
    return this;
  }
  checkPassword: function(){
    //  验证密码
    return this;
  }
}
checkobject.checkName().checkEmail().checkPassword();

var checkobject = function (){}
checkobject.prototype = {
  checkName: function(){
    //  验证姓名
    return this;
  },
  checkEmail: function(){
    //  验证邮箱  
    return this;  
  }, 
  checkPassword: function(){
    //  验证密码
    return this;  
  }
}
var a = new checkobject()
a.checkName.checkEmail().checkPassword();

prototype.js：最大的特点是对原生对象的扩展。

// 抽象出一个统一添加方法的功能方法
Function.prototype.addMethod = function (name,fn) {
    this[name] = fn;
    return this;
}

var methods = new Function(); // 或者 var methods = function(){}
methods.addMethod('checkName', function(){ // this 指向 methods 为自身添加方法
// 验证姓名
})；
methods.addMethod('checkEmail', function(){
// 验证邮箱
})；

methods.checkName();
methods.checkEmail();

// 链式写法
methods.addMethod('checkName', function(){
  // 验证姓名
  return this；
}).addMethod('checkEmail', function(){
 // 验证邮箱
　 return this;
})；

// 调用方式
methods.checkName().checkEmail()；

// 类的写法
Function.prototype.addMethod = function(name, fn){
　 this.prototype[name] = fn；
}
var Methods = function(){}
Methods.addMethod('checkName',function(){ // this 指向实例对象 为原型添加方法
  // 验证姓名
}).addMethod('checkEmail',function(){
  // 验证邮箱
})

// 调用方式
var m = new Methods();
m.checkEmail()

面向对象编程就是将你的需求抽象成一个对象，然后针对这对象分析其特性（属性）与动作（方法）。这个对象我们称之为类。面向对象编程思想其中有一个特点就是封装。

var Book = function(id,bookname,price) {
  this.id = id
  this.bookname = bookname
  this.price = price
}
Book.prototype.display = function(){
  // 展示这本书
}
/*
 * 或者


  Book.prototype = {
    display: function(){
        
    }
  }
*/
// 使用方式
var book = new Book(10,'javascript设计模式',50);
console.log(book.bookname) // javascript设计模式

---

相关资料

红宝书第四版精读训练营

红宝书第四版精读训练营代码库

学习JavaScript数据结构与算法（第3版）源码