let a;
let name = 'Simon';

// myLetVariable is *not* visible out here

for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
   // myLetVariable is only visible in here
}

// myLetVariable is *not* visible out here

const Pi = 3.14;                                // 设置 Pi 的值
Pi = 1;                                         // 将会抛出一个错误因为你改变了一个常量的值。

d:\zhaoyingjun\Web\JavaScript_01\number2.js:81
Pi = 1; // 将会抛出一个错误因为你改变了一个常量的值。
   ^

TypeError: Assignment to constant variable.
    at Object.<anonymous> (d:\zhaoyingjun\Web\JavaScript_01\number2.js:81:4)
    at Module._compile (module.js:653:30)
    at Object.Module._extensions..js (module.js:664:10)
    at Module.load (module.js:566:32)
    at tryModuleLoad (module.js:506:12)
    at Function.Module._load (module.js:498:3)
    at Function.Module.runMain (module.js:694:10)
    at startup (bootstrap_node.js:204:16)
    at bootstrap_node.js:625:3

var a;
var name = "simon";

// myVarVariable *is* visible out here 

for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
  // myVarVariable is visible to the whole function
} 

// myVarVariable *is* visible out here

console.log("3" + 4 + 5);
console.log(3 + "4" + 5);                       // 345，前面两个中只要有一个为字符串，则相加结果都是隐式转换为字符串
console.log(3 + 4 + '5');                       

console.log(123 == '123');                      // true
console.log(1 == true);                         // true

console.log(123 === '123');                     // false
console.log(1 === true);                        // false

var a = ['a', 'b', 'c'];
for (let i = 0; i < a.length; i++) {
    console.log(a[i]);
}var a = ['a', 'b', 'c'];
for (let i = 0; i < a.length; i++) {
    console.log(a[i]);
}

a
b
c

for (let value of array) {
  // do something with value
}

var a = ['a', 'b', 'c'];
for (let value of a) {
    console.log(value);
}

a
b
c

for (let property in object) {
  // do something with object property
}

var a = ['a', 'b', 'c'];
for (let value in a) {
    console.log(value);
}

0
1
2

for (let i in a) {
    console.log(a[i]);
}

a
b
c

// 方式一
var obj = new Object();

// 方式二
var obj = {}；

 // “对象字面量”也可以用来在对象实例中定义一个对象
 var obj = {
     name: "Carrot",
     "_for": "Max",
     details: {
         color: "orange",
         size: 12
     }
 };
 // 对象的属性可以通过链式（chain）表示方法进行访问：
 console.log(obj.details.color);                 // orange
 console.log(obj["details"]["color"]);           // orange

 // 下面的例子创建了一个对象原型，Person，和这个原型的实例，You。
 function Person(name, age) {
     this.name = name;
     this.age = age;
 }

 // 定义一个对象
 var You = new Person("John", 24);

 // 完成对象创建后，对象属性可以通过如下两种方式进行赋值和访问
 // 方式一
 obj.name = "Simon";
 var name_str = obj.name;
 // 方式二
 obj['name'] = "Simon";
 var name_str = obj['name'];

 // can use a variable to define a key
 // 方式一
 var user1 = 'what is your key?';
 obj[user1] = 'what is its value?';
 console.log(obj);
 // 方式二
 obj["user2"] = "user2_value";
 console.log(obj);

orange
orange
{ name: 'Simon',
  _for: 'Max',
  details: { color: 'orange', size: 12 },
  'what is your key?': 'what is its value?' }
{ name: 'Simon',
  _for: 'Max',
  details: { color: 'orange', size: 12 },
  'what is your key?': 'what is its value?',
  user2: 'user2_value' }

 var stooge = {
     "first_name": "Jerome",
     "last_name": "Howard",
      arrival: {
         city: "Los Angeles",
         "time": "2018-09-30 11:13"
     }
 };

 var a = 2 + 3 + "";
 var str = "hello";
 console.log("hello");
 console.log(str);

 var stooge = {
     "first_name": "Jerome",
     "last_name": "Howard",
     arrival: {
         city: "Los Angeles",
         "time": "2018-09-30 11:13"
     }
 };
 console.log(stooge.arrival.time);
 console.log(stooge.arrival.city);
 console.log(stooge["first_name"]);

 var status = stooge.middle || "unknown";
 console.log(status);

 stooge.first_name = "Yichun";
 stooge["last_name"] = "Zhao";
 stooge.middle = "Handsome";
 stooge.test = {
     aa: "Test"
 };
 console.log(stooge.middle);
 console.log(stooge);

 console.log("\n------------反射测试------------");
 var flight = {
     airline: "Oceanic",
     number: 815,
     departure: {
         IATA: "SYD",
         time: "2018-09-30",
         city: "Sydney"
     },
     arrival: {
         IATA: "LAX",
         time: "2018-09-29",
         city: "Los Angeles"
     }
 };
 flight.equipment = {
     model: 'Boring 777'
 };
 flight.status = 'overdue';
 console.log(flight);
 typeof flight.number;           // 'number', typeof类似于Java中的instanceof
 typeof flight.status;           // 'string'
 typeof flight.arrival;          // 'object'
 typeof flight.mainfest;         // 'undefined'

 typeof flight.toString;         // 'function'
 typeof flight.constructor;      // 'function'

 console.log("flight.number: " + flight.number);
 console.log("flight.hasOwnProperty('number'): " + flight.hasOwnProperty('number'));                 // true
 console.log("flight.hasOwnProperty('function'): " + flight.hasOwnProperty('function'));             // false
 console.log("flight.hasOwnProperty('constructor'): " + flight.hasOwnProperty('constructor'));       // false

 console.log("\n------------枚举测试------------");
 var body = {
     first_name: "First_Name",
     last_name: "Last_Name",
     'profession': "Profession"
 };
 body.middle_name = "Middle_Name";
 console.log(body);

 var properties = [
     'first_name',
     'last_name',
     'middle_name',
     'profession'
 ];

 for (var i = 0; i < body.length; i++) {
     document.writeln(properties[i] + ': ' +
         body.properties[i]);
 }

 console.log("\n------------删除测试------------");
 delete body.first_name;
 console.log(body);

 D:\Program Files\nodejs\node.exe test.js
 hello
 hello
 2018-09-30 11:13
 Los Angeles
 Jerome
 unknown
 Handsome
 { first_name: 'Yichun',
   last_name: 'Zhao',
   arrival: { city: 'Los Angeles', time: '2018-09-30 11:13' },
   middle: 'Handsome',
   test: { aa: 'Test' } }
 ------------反射测试------------
 { airline: 'Oceanic',
   number: 815,

function makePerson (first, last) {
    return {
        first: first,
        last: last
    };
}

function personFullName (person) {
    return person.first + ' ' + person.last;
}

function personFullNameReserved (person) {
    return person.last + ', ' + person.first;
}

var s = makePerson("Simon", "Willison");
console.log(personFullName(s));                 // Simon Willison
console.log(personFullNameReserved(s));         // Willison, Simon

function makePerson (first, last) {
    return {
        first: first,
        last: last,
        personFullName: function  () {
            return this.first + ' ' + this.last;
        },
        personFullNameReserved: function  () {
            return this.last + ', ' + this.first;
        }
    };
}

var s = makePerson("Simon", "Willison");
console.log(s.personFullName());                    // Simon Willison
console.log(s.personFullNameReserved());            // Willison, Simon

s = makePerson("Simon", "Willison");
var fullName = s.fullName;
fullName(); // undefined undefined

function Person (first, last) {
    this.first = first；
    this.last = last；
    this.personFullName = function  () {
        return this.first + ' ' + this.last;
    },
    this.personFullNameReserved = function  () {
        return this.last + ', ' + this.first;
    }
}

var s = new Person("Simon", "Willison");
console.log(s.personFullName());                    // Simon Willison
console.log(s.personFullNameReserved());            // Willison, Simon

var personFullName = function  () {
    return this.first + ' ' + this.last;
}
var personFullNameReserved = function  () {
    return this.last + ', ' + this.first;
}

function Person (first, last) {
    this.first = first；
    this.last = last；
    this.fullName = personFullName;
    this.fullNameReserved = personFullNameReserved;
}

var s = new Person("Simon", "Willison");
console.log(s.fullName());                      // Simon Willison
console.log(s.fullNameReserved());              // Willison, Simon

function Person (first, last) {
    this.first = first;
    this.last = last;
}
 Person.prototype.fullName = function () {
    return this.first + ' ' + this.last;
 }

 Person.prototype.fullNameReserved = function () {
    return this.last + ', ' + this.first;
 }

var s = new Person("Simon", "Willison");
console.log(s.fullName());                      // Simon Willison
console.log(s.fullNameReserved());              // Willison, Simon

// 增加原型链（proototype chain）属性
Person.prototype.firstNameCaps = function () {
    return this.first.toUpperCase();
}
console.log(s.firstNameCaps());                 // Simon

var str = "Simon";
// str.reserved();                                          // TypeError: str.reserved is not a function

String.prototype.reserved = function () {
    var r = '';
    for (let i = this.length - 1; i >= 0; i--) {
        r += this[i];
    }
    return r;
}

console.log(str.reserved());                                // nomiS

// 定义新变量也可以在字符串字面量上用（string literal）
console.log("This can now be reserved".reserved());         // devreser eb won nac sihT

var s = new Person("Simon", "Willison");
Person.prototype.toString = function () {
   return '<Person: ' + this.fullName() + '>';
}
console.log(s.toString());                      // <Person: Simon Willison>

 var add = function (a, b) {
     return a + b;
 }

 function add() {
     // let声明一个块级作用域的本地变量，并且可选的将其初始化为一个值，当然可以用var替代let
     let sum = 0;
     for (let i = 0; i < arguments.length; i++) {
         sum += arguments[i];
     }
     return sum;
 }

 var val = add(3, 4, 5, 6, 10);
 console.log("val: " + val);                         // 输出28

 // 接下来创建一个求取平均值的函数
 function avg() {
     // let声明一个块级作用域的本地变量，并且可选的将其初始化为一个值，当然可以用var替代let
     let sum = 0;
     for (let i = 0; i < arguments.length; i++) {
         sum += arguments[i];
     }
     return sum / arguments.length;
 }
 /*
 // JavaScript允许创建匿名函数，这个函数在语义上与function avg()相同。
 var avg = function () {
     // let声明一个块级作用域的本地变量，并且可选的将其初始化为一个值，当然可以用var替代let
     let sum = 0;
     for (let i = 0; i < arguments.length; i++) {
         sum += arguments[i];
     }
     return sum / arguments.length;
 }*/

 var val_avg1 = avg(3, 4, 5, 6, 10);
 console.log("val_avg1: " + val_avg1);               // 输出5.6

 // 这个很有用，但是却带来了新的问题。
 // avg() 函数处理一个由逗号连接的变量串，但如果想得到一个数组的平均值该怎么办呢？可以这么修改函数：
 function avgArray(arr) {
     // let声明一个块级作用域的本地变量，并且可选的将其初始化为一个值，当然可以用var替代let
     let sum = 0;
     for (let i = 0; i < arr.length; i++) {
         sum += arr[i];
     }
     return sum / arr.length;
 }
 var val_avgArray = avgArray([3, 4, 5, 6, 10]);
 console.log("val_avgArray: " + val_avgArray);       // 输出5.6

 // 但如果能重用我们已经创建的那个函数不是更好吗？
 // 幸运的是 JavaScript 允许使用任意函数对象的apply() 方法来调用该函数，并传递给它一个包含了参数的数组。
 // 传给 apply() 的第二个参数是一个数组，它将被当作 avg() 的参数使用，
 // 至于第一个参数 null，我们将在后面讨论。这也正说明一个事实——函数也是对象。
 var val_avg2 = avg.apply(null, [3, 4, 5, 6, 10]);
 console.log("val_avg2: " + val_avg2);               // 输出5.6

 var a = 1;
 var b = 2;

 (function() {
     var b = 3;
     a += b;
 })();

 console.log("a: " + a);         // a: 4
 console.log("b: " + b);         // b: 2

 var f = function () {
     return true;
 };

var f = function () {
    return ture;
}();

 // 因为函数是对象，所以它们可以像任何其它的值一样被使用。函数可以存放在变量、对象和数组中
 // 函数可以被当作参数传递给其它函数，函数也可以再返回函数
 // 因为函数是对象，所以函数可以拥有方法
 console.log("\n------------原型测试------------");
 function person() {
     person.prototype.name = "Jingzi";
     person.prototype.age = 20;
     person.prototype.sayName = function() {
         console.log(this.name);
     }
 }
 var person_1 = new person();
 person_1.sayName();

 console.log("\n------------函数字面量测试------------");
 // 认为是把一个匿名函数存放在一个add变量中
 var add = function (a, b) {
     return a + b;
 };
 console.log(add("Hello, ", "world!"));

 console.log("\n------------1.1 方法调用模式------------");
 // 创建myObject。它有一个value属性和一个increment方法
 // increment方法可以接受一个可选的参数。如果参数不是数字，那么默认使用数字1。
 var myObject = {
     value: 0,
     increment: function (inc) {
         this.value += typeof inc === 'number' ? inc : 1;
     }
 };

 myObject.increment();
 console.log(myObject.value);
 // document.writeln(myObject.value);
 myObject.increment(2);
 console.log(myObject.value);
 // document.writeln(myObject.value);

 console.log("\n------------1.2 函数调用模式------------");

 console.log(sum);
 // 给myObject增加一个double方法
 myObject.double = function () {
     var that = this;            // 解决方法
     var helper = function () {
         that.value = add(that.value, that.value);
     }
     helper();                   // 以函数的形式调用helper
     console.log(that);
 };
 // 以方法 的形式调用double
 myObject.double();

 console.log("\n------------1.3 构造器调用模式------------");
 // 创造一个名为Quo的构造器函数。它构造一个带有status属性的对象
 var Quo = function (str) {
     this.status = str;
 };
 // 给Quo的所有实例提供一个名为get_status的公共方法
 Quo.prototype.get_status = function () {
     return this.status;
 };
 // 构造一个Quo实例
 var myQuo = new Quo("confused");
 console.log(myQuo.get_status());

 // 因为JavaScript时一门函数式的面向对象编程语言，所以函数可以拥有方法
 // 1.3中的构造器函数Quo和为Quo实例的公共方法也是必需的
 console.log("\n------------1.4 Apply调用模式------------");
 // 构造一个包含两个数字的数组，并将它们相加
 var array = [3, 4];
 var sum = add.apply(null, array);          // sum值为7
 console.log(sum);
 // 构造一个包含status成员的对象
 var statusObject = {
     status: 'A-OK'
 };
 var status = Quo.prototype.get_status.apply(statusObject);
 console.log(status);

 ------------1.1 方法调用模式------------
 1
 3
 ------------1.2 函数调用模式------------
 7
 { value: 6,
   increment: [Function: increment],
   double: [Function] }
 ------------1.3 构造器调用模式------------
 confused
 ------------1.4 Apply调用模式------------
 7
 A-OK

 // 构造一个将很多个值相加的函数
 // 注意该函数内部定义的变量sum不会与函数外部定义的sum产生冲突
 // 该函数只会看到内部的那个变量
 var sum = function () {
     var i, sum = 0;
     for (i = 0; i < arguments.length; i++) {
         sum += arguments[i];
     }
     return sum;
 };
 console.log(sum(4, 7, 15, 16, 23, 42));                 // 输出107
 // document.writeln(sum(4, 7, 15, 16, 23, 42));

 // throw语句中断函数的执行。它应该抛出一个exception异常
 // 该对象包含可识别异常类型的name属性和一个描述性的message属性，当然也可以添加其它的属性。
 var add = function (a, b) {
     if ( (typeof a != 'number') || (typeof a != 'number') ) {
         throw {
             name: 'TypeError',
             message: 'add needs numbers'
         }
     }
     return a + b;
 };
 // 该exception对象被传递到一个try语句的catch从句
 var try_it = function () {
     try {
         add("seven");
     } catch (e) {
         console.log(e.name + ": " + e.message);
     }
 }
 try_it();

 TypeError: add needs numbers

1 Function.prototype.method = function () {
2     this.prototype[name] = func;
3     return this;
4 }

// 给类型增加方法
// JavaScript并没有单独的整数类型，因此有时候只提取数字中的整数部分是必要的。
// JavaScript本身提供的取整方法有些丑陋。我们可以通过给Number.prototype添加一个
// integer方法来改善它。它会根据数字的正负来判断是使用Math.ceiling还是Math.floor。
Number.method('integer', function () {
    return Math[this < 0 ? 'ceil' : 'floor'](this);
});
console.log((-10 / 3).integer());

 // 有条件地增加一个方法
 Function.prototype.method = function (name, func) {
     if (!this.prototype[name]) {
         this.prototype[name] = func;
     }
 };

 var hanoi = function (disc, src, aux, dst) {
     if (disc > 0) {
         hanoi(disc - 1, src, dst, aux);
         console.log('Move disc ' + disc + ' from ' + src + ' to ' + dst);
         hanoi(disc - 1, src, aux, dst);
     }
 };

 hanoi(3, 'Src', 'Aux', 'Dst');

 Move disc 1 from Src to Dst
 Move disc 2 from Src to Aux
 Move disc 1 from Src to Aux
 Move disc 3 from Src to Dst
 Move disc 1 from Src to Aux
 Move disc 2 from Src to Dst
 Move disc 1 from Src to Dst

function makeAddr(a) {
    return function(b) {
        return a + b;
    };
}
var x = makeAddr(5);
var y = makeAddr(20);
console.log(x(6));                  // 返回11
console.log(y(7));                  // 返回27

function sayHello(name) {
    var text = 'Hello ' + name;
    var say = function() {
        console.log(text);
    };
    say();
}

sayHello("Joe");                    // Hello Joe

// 以下代码返回对函数的引用
function sayHello2(name) {
    var text = "Hello " + name;
    var say = function() {
        console.log(text);
    };
    return say;
}
var say2 = sayHello2("Joe");
say2();                             // Hello Joe

// 以下代码返回对函数的引用
function sayHello2(name) {
    var text = "Hello " + name;
    var say = function() {
        console.log(text);
    };
    return say();
}
var say2 = sayHello2("Joe");
say2;                               // Hello Joe

 function a() {
     var n = 0;
     function inc() {
         n++;
         console.log(n);
     }
     return inc;
 }
 var c = a();
 c();
 c();

 var quo = function (status) {
     return {
         get_status: function () {
             return status;
         }
     }
 };
 // 创造一个Quo实例
 var myQuo = quo("amazed");
 console.log(myQuo.get_status());

 var quo = function (status) {
     return {
         get_status : status
     }
 };

 // 创造一个Quo实例
 var myQuo = quo("amazed");
 console.log(myQuo.get_status);

var quo = function (status) {
    return status;
};
// 创造一个Quo实例
var myQuo = quo("amazed");
console.log(myQuo);

 // 模块模式也可以用来产生安全的对象
 // 假设我们想要构造一个用来产生序列号的对象
 var serial_maker = function () {
     // 返回一个用来产生唯一字符串的对象
     // 唯一字符串由两个部分组成：前缀+序列号
     // 该对象包含一个设置前缀的方法，一个设置序列号的方法
     // 和一个产生唯一字符串的gensym方法
     var prefix = '';
     var seq = 0;
     return {
         set_prefix: function (p) {
             prefix = String(p);
         },
         set_seq: function (s) {
             seq = s;
         },
         gensym: function () {
             var result = prefix + '_' + seq;
             seq += 1;
             return result;
         }
     };
 };

 var seqer = serial_maker();
 seqer.set_prefix('ZYJ');
 seqer.set_seq('serialTest20181003');
 var test_seqer = seqer.gensym();
 console.log(test_seqer);

 var fibonacci = function (n) {
     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
 };

 for (var i = 0; i <= 10; i++) {
     console.log('//' + i + ": " + fibonacci(i));
 }

 //0: 0
 //1: 1
 //2: 1
 //3: 2
 //4: 3
 //5: 5
 //6: 8
 //7: 13
 //8: 21
 //9: 34
 //10: 55

 var fibonacci = function () {
     var memo = [0, 1];
     var fib = function (n) {
         var result = memo[n];
         if (typeof result !== 'number') {
             console.log(n);
             result = fib(n - 1) + fib(n - 2);
             memo[n] = result;
         }
         return result;
     };
     return fib;
 }();

 for (var i = 0; i <= 10; i++) {
     console.log('//' + i + ": " + fibonacci(i));
 }

 //0: 0
 //1: 1
 2
 //2: 1
 3
 //3: 2
 4
 //4: 3
 5
 //5: 5
 6
 //6: 8
 7
 //7: 13
 8
 //8: 21
 9
 //9: 34
 10
 //10: 55

function betterExampledNeeded() {
    var a = 1;
    function oneMoreThanA() {
        return a + 1;
    }
    return oneMoreThanA();
}

function leakMemory() {
    var el = document.getElementById('e1');
    var o = {
        'el': el
    };
    el.o = o;
}

function addHandler() {
    var el = document.getElementById('e1');
    el.onclick = function() {
        el.style.backgroundColor = 'red';
    };
}

function addHandler() {
    document.getElementById('el').onclick = function() {
        this.style.backgroundColor = 'red';
    };
}

 // numbers继承来自Array.prototype，所以numbers继承了大量有用的方法。
 // 同时numbers也有一个诡异的lenght属相，而numbers_object则（见下文中）没有
 var empty = [];
 var numbers = [
     'zero', 'one', 'two', 'three', 'four',
     'five', 'six', 'seven', 'eight', 'nine'
 ];

 console.log('1.1 ' + empty[1]);         // undefined
 console.log('1.2 ' + numbers[1]);       // 'one'
 console.log('1.3 ' + empty.length);
 console.log('1.4 ' + numbers.length);   

 // 对象字面量
 // numbers_object继承来自Object.prototype
 var numbers_object = {
     '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four',
     '5': 'five', '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine'
 };

 // 在大多数语言中一个数组的所有元素都要求是相同的类型。
 // JavaScript允许数组包含任意混合类型的值。
 var misc = [
     'str', 98.6, true, false, null, undefined,
     ['nested', 'array'], {object: true}, NaN, Infinity
 ];
 console.log('2.1 ' + misc.length);

1.1 undefined
1.2 one
1.3 0
1.4 10
2.1 10

 var myArray = [];
 console.log("1 " + myArray.length);     

 myArray[10000] = true;
 console.log("2 " + myArray.length);     // 10001, myArray数组只包含一个属性

1 0
2 10001

// 可以直接设置length的值。
// 设置大的length无须给数组分配更多的空间。
// 而把length设小，将导致所有虾苗大于等于新length的属性被删除
numbers.length = 3;
console.log('3.1 ' + numbers);
// 附加一个新元素到该数组的尾部
numbers[numbers.length] = 'ten';
console.log('3.2 ' + numbers);
// 有时用push方法可以更方便地完成同样的事情
numbers.push('go');
console.log('3.3 ' + numbers);

3.1 zero,one,two
3.2 zero,one,two,ten
3.3 zero,one,two,ten,go

 // 由于JavaScript的数组其实就是对象，
 // 所以delete云算法可以用来从数组中移出元素
 // 不幸的是，那样会在数组中遗留一个空洞
 delete numbers[2];
 console.log("4.1 " + numbers);

 // 幸运的是JavaScript数组有一个splice方法。
 // 它可以对数组做个手术，删除一些元素并将它们替换为其它的元素
 // 第一个参数是数组中的一个序号，第二个参数是要删除的元素个数
 numbers.splice(2, 1);
 console.log("4.2 " + numbers);

4.1 zero,one,,ten,go
4.2 zero,one,ten,go

 // 查询数组
 for (var i = 0; i < numbers.length; i++) {
     console.log("5.1 " + numbers[i]);
 }

5.1 zero
5.1 one
5.1 ten
5.1 go

 // 自己创建的Array.dim方法
 Array.dim = function (dimension, initial) {
     var a = [];
     for (var i = 0; i < dimension; i++) {
         a[i] = initial;
     }
     return a;
 };
 // 创建一个包含10个0的数组
 var myArray = Array.dim(10, 0);
 console.log('1.1: ' + myArray);

 // JavaScript没有多维数组，但就像大多数类C语言一样，它支持元素为数组的数组
 var matrix = [
     [0, 1, 2],
     [3, 4, 5],
     [6, 7, 8]
 ];
 console.log('2.1: ' + matrix[2][1]);
 console.log('2.2: ' + matrix);

 // 修改Array.dim方法为Array.matrix
 Array.matrix = function (m, n, initial) {
     var a;
     var mat = [];
     for (var i = 0; i < m; i++) {
         a = [];
         for (var j = 0; j < n; j++) {
             a[j] = initial;
         }
         mat[i] = a;
     }
     return mat;
 };

 // 构造一个用0填充的4*4矩阵
 var myMatrix = Array.matrix(4, 4, 0);
 console.log('3.1: ' + myMatrix[3][3]);
 console.log('3.2: ' + myMatrix);

 // 自己创建一个用来构造一个恒等矩阵的方法
 Array.identity = function (n) {
     var mat = Array.matrix(n, n, 0);
     for (var i = 0; i < n; i++) {
         mat[i][i] = 1;
     }
     return mat;
 };
 myMatrix = Array.identity(4);
 console.log('4.1: ' + myMatrix[3][3]);
 console.log('4.2: ' + myMatrix);

1.1: 0,0,0,0,0,0,0,0,0,0
2.1: 7
2.2: 0,1,2,3,4,5,6,7,8
3.1: 0
3.2: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
4.1: 1
4.2: 1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1

 // array.concat(item...)
 // concat方法返回一个新数组，它包含array的浅复制（shallow copy），
 // 并将1个或多个参数与item附加在其后。
 // 如果item是一个数组，那么它的每个元素都会被分别添加
 var a = ['a', 'b', 'c'];
 var b = ['x', 'y', 'z'];
 var c = ['1', '2', '3'];
 var d1 = a.concat(b, true);
 console.log("d1: " + d1);
 var d2 = a.concat(b, false);
 console.log("d2: " + d2);
 var d3 = a.concat(b, c, true);
 console.log("d3: " + d3);
 console.log("----------------1 array.concat(item...) end----------------");

 // array.join(separator)
 // join方法是把一个array构造成一个字符串。
 // 它将array中的每个元素构造成一个字符串
 // 并用一个separator为分隔符把它们连接在一起
 // 默认的separator是','。
 var a = ['a', 'b', 'c'];
 a.push('d');
 var c = a.join('');
 console.log("a: " + a);
 console.log("c: " + c);
 console.log("----------------2 array.join(separator) end----------------");

 // array.pop()
 // pop和push方法使数组array像堆栈（stack）一样工作
 // pop方法移除array中最后一个元素并返回该元素。如果该array为空，它会返回undefined
 var a = ['a', 'b', 'c'];
 var c = a.pop();
 console.log("a: " + a);
 console.log("c: " + c);
 console.log("----------------3 array.pop() end----------------");
 // array.push(item...)
 // push方法将一个或多个item附加到一个数组的尾部
 // 不像concat方法那样，它会修改数组array，如果item是一个数组，
 // 它会将参数数组作为单个元素整个添加到数组中。它返回这个数组array的新长度值
 var a = ['a', 'b', 'c'];
 var b = ['x', 'y', 'z'];
 var c1 = a.push(b, true);               // a,b,c, [x,y,z], true, c1 = 5;
 var c2 = a.push(b, false);              // a,b,c, [x,y,z], true, [x,y,z], false, c2 = 7
 console.log("a: " + a);
 console.log("c1: " + c1);
 console.log("c2: " + c2);
 console.log("----------------4 array.push(item...) end----------------");

 // array.reverse()
 // 反转array中的元素的顺序
 var a = ['a', 'b', 'c'];
 var b = a.reverse();
 console.log("a: " + a);
 console.log("b: " + b);
 console.log("----------------5 array.reverse() end----------------");

 // array.shift()
 // shift方法移除数组array中的第一个元素并返回该元素
 var a = ['a', 'b', 'c'];
 var b = a.shift();
 console.log("a: " + a);
 console.log("b: " + b);
 console.log("----------------6 array.shift() end----------------");

 // array.slice(start, end)，前开后闭，end参数是可选的
 // slice方法对array中的一段做浅复制
 // 如果start大于等于array.length，得到的结果将是一个空数组
 var a = ['a', 'b', 'c'];
 var b = a.slice(0, 1);                  // 'a'
 var c = a.slice(1);                     // 'b', 'c'
 var d = a.slice(1, 2);                  // 'b'
 console.log("a: " + a);
 console.log("b: " + b);
 console.log("c: " + c);
 console.log("d: " + d);
 console.log("----------------7 array.slice() end----------------");

 // array.spice(start, deleteCount, item...)
 // splice方法从array中移除1个或多个元素，并用新的item替换它们，
 // deleteCount是要移除的元素个数，它返回一个包含被移除元素的数组
 var a = ['a', 'b', 'c'];
 var b = a.splice(1, 1, 'ache', 'bug');
 console.log("a: " + a);                 // 'a', 'ache', 'bug', 'c'
 console.log("b: " + b);                 // 'b'
 console.log("----------------8 array.spice() end----------------");

 // array.sort(comparefn)
 // sort方法对array中的内容进行适当的排序。
 // 它不能正确地给一组数字排序
 var a = ['a', 'c', 'b'];
 var n = [4, 5, 15, 16, 23, 42];
 a.sort();
 n.sort();
 console.log("a: " + a);                 // a, b, c
 console.log("n: " + n);                 // 15, 16, 23, 4, 42, 5
 console.log("----------------9 array.sort(comparefn) end----------------");

 // array.unshift(item...)
 // unshift方法像push方法一样用于将元素添加到数组中
 // 但它是把item插入到array的开始部分而不是尾部。
 // 它返回array的新的长度值
 var a = ['a', 'b', 'c'];
 var b = ['x', 'y', 'z'];
 var c1 = a.push(b);
 console.log("a: " + a);                 // [a,b,c], x, y, z
 console.log("c1: " + c1);
 console.log("----------------10 array.unshift(item...) end----------------");

d1: a,b,c,x,y,z,true
d2: a,b,c,x,y,z,false
d3: a,b,c,x,y,z,1,2,3,true
----------------1 array.concat(item...) end----------------
a: a,b,c,d
c: abcd
----------------2 array.join(separator) end----------------
a: a,b
c: c
----------------3 array.pop() end----------------
a: a,b,c,x,y,z,true,x,y,z,false
c1: 5
c2: 7
----------------4 array.push(item...) end----------------
a: c,b,a
b: c,b,a
----------------5 array.reverse() end----------------
a: b,c
b: a
----------------6 array.shift() end----------------
a: a,b,c
b: a
c: b,c
d: b
----------------7 array.slice() end----------------
a: a,ache,bug,c
b: b
----------------8 array.spice() end----------------
a: a,b,c
n: 15,16,23,4,42,5
----------------9 array.sort(comparefn) end----------------
a: a,b,c,x,y,z
c1: 4
----------------10 array.unshift(item...) end----------------

// 1、Function 属性和方法
// 全局的Function对象没有自己的属性和方法, 但是, 因为它本身也是函数，所以它也会通过原型链从Function.prototype上继承部分属性和方法。
// 1.1 原型对象：属性
// （1）Function.arguments（此属性已被 arguments 替代）
// （2）Function.caller（获取调用函数的具体对象）
//      如果一个函数f是在全局作用域内被调用的,则f.caller为null,相反,如果一个函数是在另外一个函数作用域内被调用的,则f.caller指向调用它的那个函数.
// （3）Function.length（获取函数的接收参数个数）
// （4）Function.name（获取函数的名称）
// （5）Function.displayName（获取函数的display name）
// （6）Function.prototype.constructor（声明函数的原型构造方法，详细请参考 Object.constructor, Object.prototype.constructor）

// 1.2 原型对象：方法
// （1）Function.prototype.apply()
//      在一个对象的上下文中应用另一个对象的方法；参数能够以数组形式传入
// （2）Function.prototype.call()
//      在一个对象的上下文中应用另一个对象的方法；参数能够以列表形式传入。
// （3）Function.prototype.bind()
//      bind()方法会创建一个新函数，称为绑定函数.当调用这个绑定函数时,绑定函数会以创建它时传入 bind()方法的第一个参数作为 this,传入 bind()方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数.
// （4）Function.prototype.toSource()
//      获取函数的实现源码的字符串。 覆盖了 Object.prototype.toSource 方法。
// （5）Function.prototype.toString()
//      获取函数的实现源码的字符串。覆盖了 Object.prototype.toString 方法。

// 1、Function 属性和方法
// 全局的Function对象没有自己的属性和方法, 但是, 因为它本身也是函数，所以它也会通过原型链从Function.prototype上继承部分属性和方法。
// 1.1 原型对象：属性
// （1）Function.arguments（此属性已被 arguments 替代）
// 在函数递归调用时（）在某一刻同一个函数运行了多次，也就是有多套实参，那么 arguments 属性的值就是最近一次该函数调用时传入的参数
// 如果函数不在执行期间，那么该函数的 arguments 属性的值是 null
console.log("\n");
function f1(n) { g1(n - 1); }
function g1(n) {
    console.log("1.1 before: " + g1.arguments[0]);
    if (n > 0) { f1(n); }
    console.log("1.2 after: " + g1.arguments[0]);
}
f1(2);
console.log("1.3 函数退出后的 arguments 属性值: " + g1.arguments);
// 输出：
// before: 1
// before: 0
// after: 0
// after: 1
// 函数退出后的 arguments 属性值: null

// （2）Function.caller（获取调用函数的具体对象，返回调用制定函数的函数）
//      如果一个函数f是在全局作用域内被调用的,则f.caller为null,相反,如果一个函数是在另外一个函数作用域内被调用的,则f.caller指向调用它的那个函数.
console.log("\n");
function stop() { console.log("2.1 Stop function."); }
function f(n) {
    stop();
    if (f.caller == null) {
        console.log("2.2 n: " + n + "该函数在全局作用域内被调用!");
    } else
        console.log("2.3 n: " + n + "调用我的是函数是" + f.caller);
}
f(2);

// （3）Function.length（获取函数的接收参数个数）
console.log("\n");
function sum(a, b) {
    return a + b;
}
console.log("sum.length: " + sum.length); // sum.length: 2

// （4）Function.name（获取函数的名称）
console.log("sum.name: " + sum.name); // sum.name: sum

// （5）Function.displayName（获取函数的显示名称）
console.log("sum.displayName: " + sum.displayName); // sum.displayName: undefined
// 当一个函数的 displayName 属性被定义，这个函数的 displayName 属性将返回显示名称
sum.displayName = "Sum Function";
console.log("sum.displayName: " + sum.displayName); // sum.displayName: Sum Function

// （6）Function.prototype.constructor（声明函数的原型构造方法，详细请参考 Object.constructor, Object.prototype.constructor）
// 所有的对象都会从它的原型上继承一个 constructor 属性
console.log("\n");
var o = {};
console.log("o.constructor === Object: " + (o.constructor === Object)); // true
var o = new Object;
console.log("o.constructor === Object: " + (o.constructor === Object)); // true
var a = [];
console.log("a.constructor === Array: " + (a.constructor === Array)); // true
var a = new Array;
console.log("a.constructor === Array: " + (a.constructor === Array)); // true
var n = new Number;
console.log("n.constructor === Number: " + (n.constructor === Number)); // true
// 创建一个原型：Tree，以及该类型的对象，即 theTree。然后打印 theTree对象的 constructor 属性
function Tree(name) {
    this.name = name;
}
var theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);

// 1.2 原型对象：方法
// （1）Function.prototype.apply()
//      语法：func.apply(thisArg, [argsArray])
//      thisArg：可选的。在 func 函数运行时使用的 this 值。请注意，this可能不是该方法看到的实际值：如果这个函数处于非严格模式下，则指定为 null 或 undefined 时会自动替换为指向全局对象，原始值会被包装。
//      argsArray：可选的。一个数组或者类数组对象，其中的数组元素将作为单独的参数传给 func 函数。如果该参数的值为 null 或  undefined，则表示不需要传入任何参数。从ECMAScript 5 开始可以使用类数组对象。
//      返回值：调用有指定this值和参数的函数的结果。
//      在一个对象的上下文中应用另一个对象的方法；参数能够以数组形式传入
// 注意：call()方法的作用和 apply() 方法类似，区别就是call()方法接受的是参数列表，而apply()方法接受的是一个参数数组。
console.log("\n");
var numbers = [5, 6, 2, 3, 7];
var max = Math.max.apply(null, numbers); // 基本等同于 Math.max(numbers[0], ...) 或 Math.max(5, 6, ..)
var min = Math.min.apply(null, numbers); // 基本等同于 Math.min(numbers[0], ...) 或 Math.min(5, 6, ..)
console.log("max: " + max + ", min: " + min);
// 用 apply() 将数组添加到另一个数组中
var array = ['a', 'b'];
var elements = [0, 1, 2];
array.push.apply(array, elements); // max: 7, min: 2
console.log("array: " + array); // array: a,b,0,1,2

// （2）Function.prototype.call()
//      语法：fun.call(thisArg, arg1, arg2, ...)
//      thisArg：在fun函数运行时指定的this值。需要注意的是，指定的this值并不一定是该函数执行时真正的this值，如果这个函数处于non-strict mode，
//          则指定为null和undefined的this值会自动指向全局对象(浏览器中就是window对象)，同时值为原始值(数字，字符串，布尔值)的this会指向该原始值的自动包装对象。
//      arg1, arg2, ...：指定的参数列表。
//      返回值：使用调用者提供的this值和参数调用该函数的返回值。若该方法没有返回值，则返回undefined。
//      在一个对象的上下文中应用另一个对象的方法；参数能够以列表形式传入。
// 1）使用call方法调用父构造函数
function Product(name, price) {
    this.name = name;
    this.price = price;
}
function Food(name, price) {
    Product.call(this, name, price);
    this.category = 'food';
}
function Toy(name, price) {
    Product.call(this, name, price);
    this.category = 'toy';
}
var cheese = new Food("feta", 5);
var fun = new Toy("robot", 40);
console.log("cheese: " + JSON.stringify(cheese)); // cheese: {"name":"feta","price":5,"category":"food"}
console.log("fun: " + JSON.stringify(fun)); // fun: {"name":"robot","price":40,"category":"toy"}
// 2）使用call方法调用匿名函数
var animals = [
    { species: 'Lion', name: 'King' },
    { species: 'Whale', name: 'Fail' }
];
for (var i = 0; i < animals.length; i++) {
    (function (i) {
        this.print = function () {
            console.log("#" + i + " " + this.species + ": " + this.name);
        }
        this.print();
    }).call(animals[i], i);
}
// 3）使用call方法调用函数并且没有确定第一个参数（argument）
var sData = 'Wisen';
function display() {
    console.log('sData value is %s ', this.sData);
}
display.call();  // sData value is Wisen, 在严格模式下this的值将会是undefined.

// （3）Function.prototype.bind()
//      bind()方法会创建一个新函数，称为绑定函数.
//      当调用这个绑定函数时,绑定函数会以创建它时传入 bind()方法的第一个参数作为 this,传入 bind()方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数.
// 1）创建绑定函数
var module = {
    x: 42,
    getX: function () {
        return this.x;
    }
};
console.log("module.getX(): " + module.getX());
var unboundGetX = module.getX;
console.log("unboundGetX: " + unboundGetX());
boundGetX = unboundGetX.bind(module); // 创建一个新函数，把 'this' 绑定到 module 对象
console.log("boundGetX: " + boundGetX());
// （4）Function.prototype.toSource()
//      获取函数的实现源码的字符串。 覆盖了 Object.prototype.toSource 方法。
// （5）Function.prototype.toString()
//      获取函数的实现源码的字符串。覆盖了 Object.prototype.toString 方法。
console.log("module.toSource: " + display.toString());

console.log(0.1 + 0.2);                     // 0.30000000000000004

console.log(Math.sin(3.5));                 // -0.35078322768961984
var r = 0.5;
var d = Math.PI * (r + r);                  // 3.141592653589793
console.log(d);

 // 可以使用内置函数 parseInt() 将字符串转换为整型
 // 该函数的第二个参数（可选）表示字符串所表示数字的基（进制）
 console.log(parseInt("123"));
 console.log(parseInt("123", 10));
 console.log(parseInt("010"));
 console.log(parseInt("010", 10));
 console.log(parseInt("0x10"));
 console.log(parseInt("11", 2));             

console.log(+ "42");
console.log(+ "010");
console.log(+ "0x10");                      

console.log(parseInt("hello", 10));         // NaN
console.log(NaN + 5);                       // NaN

console.log(isNaN(NaN));                    // true

console.log(1 / 0);                         // Infinity
console.log(-1 / 0);                        // -Infinity

// isFinit()判断数字是否是有限的
// 如果类型为Infinity, -Infinity 或 NaN则返回false
console.log(isFinite(1 / 0));               // false
console.log(isFinite(Infinity));            // false
console.log(isFinite(NaN));                 // false
console.log(isFinite(-Infinity));           // false

console.log(isFinite(0));                   // true
console.log(isFinite(2e64));                // true

console.log(isFinite('0'));                 // true，如果是纯数值类型的检测，则返回false：Number.isFinite("0");

 // parseFloat返回正常数字
 console.log(parseFloat("3.14"));                            // 3.14
 console.log(parseFloat("314e-2"));                          // 3.14
 console.log(parseFloat("0.0314e2"));                        // 3.14
 console.log(parseFloat("3.14more non-digit characters"));   // 3.14
 // 下面例子返回NaN
 console.log(parseFloat("FF2"));            // NaN

 // 该函数通过正则表达式的方式,在需要更严格地转换float值时可能会有用
 var filterFloat = function (value) {
     if(/^(\-|\+)?|(\.\d+)(\d+(\.\d+)?(\d+\.)|Infinity)$/.test(value)) {
         return Number(value);
     }
 };
 console.log(filterFloat('421'));
 console.log(filterFloat('-421'));              // -421
 console.log(filterFloat('+421'));
 console.log(filterFloat('Infinity'));          // Infinity
 console.log(filterFloat('1.61803398875'));     // 1.61803398875
 console.log(filterFloat('421e+0'));
 console.log(filterFloat('421hop'));            // NaN
 console.log(filterFloat('hop1.61803398875'));  // NaN
 console.log(filterFloat("999 888"));           // NaN
 console.log(filterFloat('.421'));              // 0.421
 console.log(filterFloat('421.'));              

console.log(parseInt("10.2abc"));
console.log(parseFloat("10.2abc"));             // 10.2

 // number.toExponential(fractionDigits)
 // toExponential方法把这个number转换成一个指数形式的字符串
 // 可选参数fractionDigits控制其小数点后的数字位数。它的值必须在0~2之间
 console.log("Math.PI.toExponential(0): " + Math.PI.toExponential(0));
 console.log("Math.PI.toExponential(2): " + Math.PI.toExponential(2));
 console.log("Math.PI.toExponential(7): " + Math.PI.toExponential(7));
 console.log("Math.PI.toExponential(16): " + Math.PI.toExponential(16));
 console.log("Math.PI.toExponential(): " + Math.PI.toExponential());
 console.log("----------------1 number.toExponential(fractionDigits) end----------------");

 // number.toFixed(fractionDigits)
 // toFixed方法把这个number转换成一个十进制数形式的字符串
 // 可选参数fractionDigits控制其小数点后的数字位数。它的值必须在0~20之间，默认值为0
 console.log("Math.PI.toFixed(0): " + Math.PI.toFixed(0));
 console.log("Math.PI.toFixed(2): " + Math.PI.toFixed(2));
 console.log("Math.PI.toFixed(7): " + Math.PI.toFixed(7));
 console.log("Math.PI.toFixed(16): " + Math.PI.toFixed(16));
 console.log("Math.PI.toFixed(): " + Math.PI.toFixed());
 console.log("----------------2 number.toFixed(fractionDigits) end----------------");

 // number.toPrecision(precision)
 // toFixed方法把这个number转换成一个十进制数形式的字符串
 // 可选参数precision控制有效数字的位数。它的值必须在1~21之间。
 console.log("Math.PI.toPrecision(1): " + Math.PI.toPrecision(1));
 console.log("Math.PI.toPrecision(2): " + Math.PI.toPrecision(2));
 console.log("Math.PI.toPrecision(7): " + Math.PI.toPrecision(7));
 console.log("Math.PI.toPrecision(16): " + Math.PI.toPrecision(16));
 console.log("Math.PI.toPrecision(): " + Math.PI.toPrecision());
 console.log("----------------3 number.toPrecision(precision) end----------------");

 // number.toString(radix)
 // toString方法把这个number转换成字符串
 // 可选参数radix控制基数。它的值必须在2~36之间。默认的radix是以10为基数的。
 // radix最常用的是整数，但是它可以用任意的数字
 // 在最普通情况下，number.toString()可以更简单的写成String(number)
 console.log("Math.PI.toString(2): " + Math.PI.toString(2));
 console.log("Math.PI.toString(8): " + Math.PI.toString(8));
 console.log("Math.PI.toString(16): " + Math.PI.toString(16));
 console.log("Math.PI.toString(): " + Math.PI.toString());
 console.log("String(Math.PI): " + String(Math.PI));
 console.log("----------------4 number.toString(radix) end----------------");

Math.PI.toExponential(0): 3e+0
Math.PI.toExponential(2): 3.14e+0
Math.PI.toExponential(7): 3.1415927e+0
Math.PI.toExponential(16): 3.1415926535897931e+0
Math.PI.toExponential(): 3.141592653589793e+0
----------------1 number.toExponential(fractionDigits) end----------------
Math.PI.toFixed(0): 3
Math.PI.toFixed(2): 3.14
Math.PI.toFixed(7): 3.1415927
Math.PI.toFixed(16): 3.1415926535897931
Math.PI.toFixed(): 3
----------------2 number.toFixed(fractionDigits) end----------------
Math.PI.toPrecision(1): 3
Math.PI.toPrecision(2): 3.1
Math.PI.toPrecision(7): 3.141593
Math.PI.toPrecision(16): 3.141592653589793
Math.PI.toPrecision(): 3.141592653589793
----------------3 number.toPrecision(precision) end----------------
Math.PI.toString(2): 11.001001000011111101101010100010001000010110100011
Math.PI.toString(8): 3.1103755242102643
Math.PI.toString(16): 3.243f6a8885a3
Math.PI.toString(): 3.141592653589793
String(Math.PI): 3.141592653589793
----------------4 number.toString(radix) end----------------

 // object.hasOwnProperty(name)
 // 判断object是否包含name属性参数
 var a = {member: "Hello, world"};
 // var b = Object.beget(a);
 var t = a.hasOwnProperty('member');         // t: true
 console.log("t: " + t);
 console.log("a.member: " + a.member);       // a.member: Hello, world

 // string.charAt(pos )
 // charAt方法返回在string中pos位置处的字符
 // 如果pos小于0或者大于等于字符串的长度string.length，它会返回空字符串
 var name = "Curly";
 var initial = name.charAt(0);
 console.log("initial: " + initial);
 console.log("----------------1 string.charAt(pos ) end----------------");

 // string.charCodeAt(pos )
 // charCodeAt方法返回在string中pos位置处的字符的字符码位（整数形式表示）
 // 如果pos小于0或者大于等于字符串的长度string.length，它会返回NaN
 var name = "Curly";
 var initial = name.charCodeAt(0);
 console.log("initial: " + initial);
 console.log("----------------2 string.charCodeAt(pos ) end----------------");

 // string.concat(item...)，很少被使用，因为'+'使用会更方便
 var str = 'C'.concat('a', 't');
 console.log("str: " + str);
 console.log("----------------3 string.concat(item...) end----------------");

 // string.indexOf(searchString, position)
 // indexOf方法在string中查找另一个字符串searchString。
 // 如果它被找到，则返回第一个匹配字符的位置，否则返回-1。
 // 可选参数position可设置从string的某个指定的位置开始查找
 var text = "Mississippi";
 var p1 = text.indexOf('ss');
 var p2 = text.indexOf('ss', 3);
 var p3 = text.indexOf('ss', 6);
 console.log("p1: " + p1 + ", p2: " + p2 + ", p3: " + p3);
 console.log("----------------4 string.indexOf(searchString, position) end----------------");

 // string.lastIndexOf(searchString, position)
 // lastIndexOf方法在string中（从末尾开始）查找另一个字符串searchString。
 // 如果它被找到，则返回第一个匹配字符的位置（即从后往前找的第一个匹配字符的位置），否则返回-1。
 // 可选参数position可设置从string的某个指定的位置开始查找
 var text = "Mississippi";
 var p1 = text.lastIndexOf('ss');
 var p2 = text.lastIndexOf('ss', 3);
 var p3 = text.lastIndexOf('ss', 6);
 console.log("p1: " + p1 + ", p2: " + p2 + ", p3: " + p3);
 console.log("----------------5 string.lastIndexOf(searchString, position) end----------------");

 // string.localCompare(stringOther)
 // localCompare方法比较两个字符串。如何比较字符串的规则没有详细的说明（从第一个字符开始比较）
 // 如果string比字符串that小，那么结果为负数；如果它们是相等的，那么结果为0
 var str1 = "Mississippi";
 var str2 = "Mississippi, hahaha";
 var result1 = str1.localeCompare(str2);                     // -1

 console.log("6.1 result1: " + result1 + ", ressult2: " + result2);
 var str1 = "Mississippi";
 var str2 = "Mississippi";

 var result2 = str2.localeCompare(str1);                     // -1
 console.log("6.2 result1: " + result1 + ", ressult2: " + result2);
 var str1 = "aississippi";
 var str2 = "bississipp, hahaha";
 var result1 = str1.localeCompare(str2);                     // -1

 console.log("6.3 result1: " + result1 + ", ressult2: " + result2);
 var str1 = "bississippi";
 var str2 = "aississipp, hahaha";

 var result2 = str2.localeCompare(str1);                     // -1
 console.log("6.4 result1: " + result1 + ", ressult2: " + result2);
 console.log("----------------6 string.localCompare(stringOther) end----------------");

 // string.match(regexp)
 // match方法匹配一个字符串和一个正则表达式
 // 它依据g标识来决定如何进行匹配。如果没有g标识，那么调用string.match(regexp)的结果与调用regexp.exec(string)的结果相同
 // 如果带有g标识，那么它返回一个包含捕获分组之外的所有匹配的数组
 var text = '<html><body bgcolor=linen><p>' + 'This is <b>bold<\/b>!<\/p><\/body><\/html>';
 var tags = /[^<>]+|<(\/?)(a-zA-Z+)([^<>]*)>/g;
 var a = text.match(tags);
 console.log(a);
 console.log("----------------7 string.match(regexp) end----------------");

 // string.replace(searchValue, replaceVale)
 // 查找和替换操作，并返回一个新的字符串
 // searchValue可以是一个字符串或者一个正则表达式对象
 // 如果searchValue它是一个字符串，那么searchValue只会在第一次出现的地方被替换
 var result = "mother_in_law".replace('_', '-');
 console.log("result: " + result);                           // result: mother-in_law
 // 如果searchValue它是一个正则表达式并且带有g标志，那么searchValue会替换所有匹配支出，如果没有带g标识，那么它将仅替换第一个匹配之处。
 // 捕获括号中的3个数字
 var oldaracode = /\((d{3})\)/g;
 var p = '(555)666-1212'.replace(oldaracode, '$1-');
 console.log("p: " + p);                                     // p: (555)666-1212
 console.log("----------------8 string.replace(searchValue, replaceVale) end----------------");

 // string.search(regexp)
 // search方法和indexOf方法类似，只是它只接受一个正则表达式对象作为参数而不是一个字符串。
 // 如果找到匹配，它返回第一个匹配的首字符位置，如果没有找到匹配，则返回-1，此方法会忽略g标志，且没有position参数
 var text = 'and in it he says "Any damn fool could"';
 var pos1 = text.search(/["']/);
 var pos2 = text.search(/[h]/);
 console.log("pos1: " + pos1 + ", pos2: " + pos2);
 console.log("----------------9 string.search(regexp) end----------------");

 // string.slice(start, end)
 // slice方法复制string的一部分来构造一个新的字符串。
 // 如果start参数是负值，它将于string.length相加。即截取从最后往前数的多少个字符
 // end参数是可选的，并且它的默认值是string.length，如果end参数是负数，那么它将于string.length相加。
 var text = 'and in it he says "Any damn fool could"';
 var a = text.slice(18);
 var b = text.slice(0, 3);
 var c = text.slice(-5);
 var d = text.slice(18);
 console.log("a: " + a);
 console.log("b: " + b);
 console.log("c: " + c);
 console.log("d: " + d);
 console.log("----------------10 string.slice(start, end) end----------------");

 // string.substring(start, end)
 // substring的用法与slice方法一样，只是substring方法不能处理负数参数。
 // 没有任何理由去使用substring方法。请用slice替代它。

 // string.split(separator, limit)
 // split方法把这个string分割成片段来创建一个字符串数组。
 // 可选参数limit可以限制被分割的片段数量。
 // separator参数可以是一个字符串或者一个正则表达式
 // 如果separator参数是一个空字符串，将返回一个单字符的数组
 var str_digits = '0123456789';
 var a = str_digits.split('', 5);
 console.log(a);                                             // [ '0', '1', '2', '3', '4' ]
 var ip = "192.168.1.0";
 var b = ip.split('.');
 console.log(b);                                             // [ '192', '168', '1', '0' ]
 var c1 = '|a|b|c'.split('|');
 console.log(c1);                                            // [ '', 'a', 'b', 'c' ]
 var c2 = '|a|b|c'.split('|');
 console.log(c2);                                            // [ '', 'a', 'b', 'c' ]
 var text = 'last, first, middle';
 var d1 = text.split(/\s*, \s*/);
 console.log(d1);                                            // [ 'last', 'first', 'middle' ]
 var d1 = text.split(/\s*(,)\s*/);
 console.log(d1);                                            // [ 'last', ',', 'first', ',' 'middle' ]
 var d2 = text.split(/\s*/);
 console.log(d2);                                            // 'l', 'a', ...，单个字符组成的数组
 console.log("----------------11 string.split(start, end) end----------------");

 // string.toLocaleLowerCase()
 // 使用本地化的规则把这个string中的所有字母转换为小写格式。
 // 这个方法主要用在土耳其语上，因为在土耳其语中'I'转换为'l'，而不是'i'
 var text = "Hello, world, PI, Pi";
 var str1 = text.toLocaleLowerCase();
 console.log("str1: " + str1);                               // hello, world, pi, pi
 // string.toLocaleUpperCase()
 // 使用本地化的规则把这个string中的所有字母转换为小写格式。这个方法主要用在土耳其语上
 var str2 = text.toLocaleUpperCase();
 console.log("str2: " + str2);                               // HELLO, WORLD, PI, PI
 // string.toLowerCase()，返回一个新的字符串，这个string中的所有字母都被转化为小写格式
 var str3 = text.toLowerCase();
 console.log("str3: " + str3);                               // hello, world, pi, pi
 // string.toUpperCase()，返回一个新的字符串，这个string中的所有字母都被转化为小写格式
 var str4 = text.toUpperCase();
 console.log("str4: " + str4);                               // HELLO, WORLD, PI, PI
 console.log("----------------12 string.toLocaleLowerCase/toLocaleUpperCase/toLowerCase/toUpperCase end----------------");

 // string.fromCharCode(char...)，该函数从一串数字中返回一个字符串
 var a1 = String.fromCharCode(67, 97, 116);
 console.log("a1: " + a1);                                   // a1: Cat
 var nums = (67, 97, 116);
 var a2 = String.fromCharCode(nums);
 console.log("a2: " + a2);                                   // a2: t
 var nums = '67, 97, 116';
 var a3 = String.fromCharCode(nums);
 console.log("a3: " + a3);                                   // a3:
 console.log("----------------13 string.fromCharCode(char...) end----------------");

initial: C
----------------1 string.charAt(pos ) end----------------
initial: 67
----------------2 string.charCodeAt(pos ) end----------------
str: Cat
----------------3 string.concat(item...) end----------------
p1: 2, p2: 5, p3: -1
----------------4 string.indexOf(searchString, position) end----------------
p1: 5, p2: 2, p3: 5
----------------5 string.lastIndexOf(searchString, position) end----------------
6.1 result1: -1, ressult2: 1
6.2 result1: 0, ressult2: 0
6.3 result1: -1, ressult2: 1
6.4 result1: 1, ressult2: -1
----------------6 string.localCompare(stringOther) end----------------
[ 'html',
  'body bgcolor=linen',
  'p',
  'This is ',
  'b',
  'bold',
  '/b',
  '!',
  '/p',
  '/body',
  '/html' ]
----------------7 string.match(regexp) end----------------
result: mother-in_law
p: (555)666-1212
----------------8 string.replace(searchValue, replaceVale) end----------------
pos1: 18, pos2: 10
----------------9 string.search(regexp) end----------------
a: "Any damn fool could"
b: and
c: ould"
d: "Any damn fool could"
----------------10 string.slice(start, end) end----------------
[ '0', '1', '2', '3', '4' ]
[ '192', '168', '1', '0' ]
[ '', 'a', 'b', 'c' ]
[ '', 'a', 'b', 'c' ]
[ 'last', 'first', 'middle' ]
[ 'last', ',', 'first', ',', 'middle' ]
[ 'l',
  'a',
  's',
  't',
  ',',
  'f',
  'i',
  'r',
  's',
  't',
  ',',
  'm',
  'i',
  'd',
  'd',
  'l',
  'e' ]
----------------11 string.split(start, end) end----------------
str1: hello, world, pi, pi
str2: HELLO, WORLD, PI, PI
str3: hello, world, pi, pi
str4: HELLO, WORLD, PI, PI
----------------12 string.toLocaleLowerCase/toLocaleUpperCase/toLowerCase/toUpperCase end----------------
a1: Cat
a2: t
a3:
----------------13 string.fromCharCode(char...) end----------------

 // 判空函数
 function isNull(value)
 {
     if (value == null || value == undefined) {
         return true;
     }
     var valstr = value.toString();
     if (valstr == 'null' || valstr == 'undefined' || valstr == '') {
         return true;
     }
     return false;
 }

 // 判非空函数
 function isNotNull(value)
 {
     if (value == null || value == undefined) {
         return false;
     }
     var valstr = value.toString();
     if (valstr == 'null' || valstr == 'undefined' || valstr == '') {
         return false;
     }
     return true;
 }

 <script language="javascript">
     var str='中国';
     if(escape(str).indexOf("%u")<0){
         alert("没有包含中文");
     }
     else{
         alert("包含中文");
     }
 </script>

console.log(Boolean(''));                       // false
console.log(Boolean(234));                      // true

typeof ''; // string 有效
typeof 1; // number 有效
typeof Symbol(); // symbol 有效
typeof true; //boolean 有效
typeof undefined; //undefined 有效
typeof null; //object 无效
typeof [] ; //object 无效
typeof new Function(); // function 有效
typeof new Date(); //object 无效
typeof new RegExp(); //object 无效

var one = {x: 1};
var two = new Object();
one.__proto__ === Object.prototype // true
two.__proto__ === Object.prototype // true
one.toString === one.__proto__.toString // true

instanceof (A, B) = {
    var L = A.__proto__;
    var R = B.prototype;
    if (L === R) {
        // A的内部属性 __proto__ 指向 B 的原型对象
        return true;
    }
    return false;
}

[] instanceof Array; // true
{ } instanceof Object; // true
new Date() instanceof Date; // true

function Person() {};
new Person() instanceof Person;

[] instanceof Object; // true
new Date() instanceof Object; // true
new Person instanceof Object; // true

var iframe = document.createElement('iframe');
document.body.appendChild(iframe);
xArray = window.frames[0].Array;
var arr = new xArray(1, 2, 3); // [1,2,3]
arr instanceof Array; // false

if (Array.isArray(value)) {
    // 对数组执行某些操作
}

Object.prototype.toString.call(''); // [object String]
Object.prototype.toString.call(1); // [object Number]
Object.prototype.toString.call(true); // [object Boolean]
Object.prototype.toString.call(Symbol()); //[object Symbol]
Object.prototype.toString.call(undefined); // [object Undefined]
Object.prototype.toString.call(null); // [object Null]
Object.prototype.toString.call(new Function()); // [object Function]
Object.prototype.toString.call(new Date()); // [object Date]
Object.prototype.toString.call([]); // [object Array]
Object.prototype.toString.call(new RegExp()); // [object RegExp]
Object.prototype.toString.call(new Error()); // [object Error]
Object.prototype.toString.call(document); // [object HTMLDocument]
Object.prototype.toString.call(window); //[object global] window 是全局对象 global 的引用

 // 1. 获取当前时间（标准时间格式）
 // 1.1 获取当前时间：YYYY-MM-DD
 function getNowFormatDate1() {
     var date = new Date();
     var currentdate = date.getFullYear() + '-' +
         ('0' + (date.getMonth() + 1)).slice(-2) + '-' +
         ('0' + date.getDate()).slice(-2);
     return currentdate;
 }
 console.log("getNowFormatDate1(): " + getNowFormatDate1());

 // 1.2 获取当前时间：YYYY-MM-DD hh:mm:ss
 function getNowFormatDate4() {
     var date = new Date();
     var currentdate = date.getFullYear() + '-' +
         ('0' + (date.getMonth() + 1)).slice(-2) + '-' +
         ('0' + date.getDate()).slice(-2) + ' ' +
         ('0' + date.getHours()).slice(-2) + ':' +
         ('0' + date.getMinutes()).slice(-2) + ':' +
         ('0' + date.getSeconds()).slice(-2);
     return currentdate;
 }
 console.log("getNowFormatDate4(): " + getNowFormatDate4());

 // 2. 将时间戳转换成标准的时间格式，1398250549123: 2014-04-23 18:55:49
 // 2.1 将时间戳转换成：YYYY-MM-DD
 function getTimeStamp1(timeStamp) {
     var date = new Date(timeStamp);
     var currentdate = date.getFullYear() + '-' +
         ('0' + (date.getMonth() + 1)).slice(-2) + '-' +
         ('0' + date.getDate()).slice(-2);
     return currentdate;
 }
 console.log("getTimeStamp1(1398250549123): " + getTimeStamp1(1398250549123));       // 2014-04-23

 // 2.2 将时间戳转换成：YYYY-MM-DD hh:mm:ss
 function getTimeStamp2(timeStamp) {
     var date = new Date(timeStamp);
     var currentdate = date.getFullYear() + '-' +
         ('0' + (date.getMonth() + 1)).slice(-2) + '-' +
         ('0' + date.getDate()).slice(-2) + ' ' +
         ('0' + date.getHours()).slice(-2) + ':' +
         ('0' + date.getMinutes()).slice(-2) + ':' +
         ('0' + date.getSeconds()).slice(-2);
     return currentdate;
 }
 console.log("getTimeStamp2(1398250549123): " + getTimeStamp2(1398250549123));       // 2014-04-23 18:55:49

 // 3. 将标准时间格式转换为时间戳
 var startTime = '2014-04-23 18:55:49:123';
 startTime = startTime.replace(/-/g, '/')    // 可选操作："2014-04-23 18:55:49:123" 转换为 "2014/04/23 18:55:49:123"
 console.log("startTime: " + startTime);
 var date = new Date(startTime);
 console.log("date: " + date);               // Wed Apr 23 2014 18:55:49 GMT+0800 (中国标准时间)

 var time1 = date.getTime();                 // 精确到毫秒
 var time2 = date.valueOf();                 // 精确到毫秒
 var time3 = Date.parse(date);               // 精确到秒，毫秒将用 0 来代替
 console.log("time1: " + time1);
 console.log("time2: " + time2);
 console.log("time3: " + time3);             

(参数1, 参数2, …, 参数N) => { 函数声明 }

//相当于：(参数1, 参数2, …, 参数N) =>{ return 表达式; }
(参数1, 参数2, …, 参数N) => 表达式（单一）

// 当只有一个参数时，圆括号是可选的：
(单一参数) => {函数声明}
单一参数 => {函数声明}

// 没有参数的函数应该写成一对圆括号。
() => {函数声明}

//加括号的函数体返回对象字面表达式：
参数=> ({foo: bar})

//支持剩余参数和默认参数
(参数1, 参数2, ...rest) => {函数声明}
(参数1 = 默认值1,参数2, …, 参数N = 默认值N) => {函数声明}

//同样支持参数列表解构
let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f();  

var testFunc1 = () => console.log("hello");
var testFunc2 = (x) => console.log("x: " + x);
var testFunc3 = (x, y) => console.log("x + y: " + (x + y));

testFunc1();
testFunc2("Hello, 2");
testFunc3(3, 5);

var func1 = ({value1, value2}) => ({total: value1 + value2})
var result = func1({value1: 2, value2: 3})
console.log("result: " + result);

1 /正则表达式主体/修饰符（修饰符为可选）

1 var patt = /runoob/i;

 // 使用正则表达式搜索"Runoob"字符串，且不区分大小写
 // 返回子串的起始位置
 var str = "Visit Runoob!";
 var n = str.search(/Runoob/i);
 console.log(n);

var str = "Visit Runoob!";
var n = str.search("Runoob");
console.log(n);

 // repleace()方法使用正则表达式
 var str = "Visit Microsoft!";
 console.log("str old: " + str);
 var txt = str.replace(/microsoft/i, "Runoob");
 console.log("str self is not changed: " + str);
 console.log("str new (txt): " + txt);

str old: Visit Microsoft!
str self is not changed: Visit Microsoft!
str new (txt): Visit Runoob!

 // repleace()方法使用字符串
 var str = "Visit Microsoft!";
 console.log("str old: " + str);
 var txt = str.replace("Microsoft", "Runoob");
 console.log("str self is not changed: " + str);
 console.log("str new (txt): " + txt);

str old: Visit Microsoft!
str self is not changed: Visit Microsoft!
str new (txt): Visit Runoob!

 // 搜索字符串中的字符'e'
 // 即判断字符串中是否包含字符'e'，是返回true，否则返回false
 var patt = /e/;
 var ret;
 ret = patt.test("The best things in life are free.");
 console.log("1 ret_test: " + ret);

 // 以上语句等价于
 console.log("2 ret_test: " + /e/.test("The best things in life are free."));

1 ret_test: true
2 ret_test: true

// 搜索字符串中的字符'e'
// 即判断字符串中是否包含字符'e'，是返回true，否则返回false
console.log("3 ret_exec: " + /e/.exec("The best things in life are free."));

 var isValid = function(str) {
     return /^\w+$/.test(str);　　　　　　// '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234abd__";
 console.log("'1234abd__' isValid? " + isValid(str1));
 var str2 = "$32343";
 console.log("'$32343' isValid? " + isValid(str2));

'1234abd__' isValid? true
'$32343' isValid? false

 var isLetter = function(str) {
     return /^[a-zA-Z]+$/.test(str);　　// '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234abd__";
 console.log("'1234abd__' isLetter? " + isLetter(str1));
 var str2 = "$32343";
 console.log("'$32343' isLetter? " + isLetter(str2));
 var str3 = "hello";
 console.log("'hello' isLetter? " + isLetter(str3));
 var str4 = "hello, world";
 console.log("'hello, world' isLetter? " + isLetter(str4));

'1234abd__' isLetter? false
'$32343' isLetter? false
'hello' isLetter? true
'hello, world' isLetter? false

 var isLetter = function(str) {
     return /[a-zA-Z]/.test(str);    // '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234abd__";
 console.log("'1234abd__' isLetter? " + isLetter(str1));
 var str2 = "$32343";
 console.log("'$32343' isLetter? " + isLetter(str2));
 var str3 = "hello";
 console.log("'hello' isLetter? " + isLetter(str3));
 var str4 = "hello, world";
 console.log("'hello, world' isLetter? " + isLetter(str4));
 var str5 = "hello, 1234";
 console.log("'hello, 1234' isLetter? " + isLetter(str5));
 var str6 = "1234, world";
 console.log("'1234, world' isLetter? " + isLetter(str6));

'1234abd__' isLetter? true
'$32343' isLetter? false
'hello' isLetter? true
'hello, world' isLetter? true
'hello, 1234' isLetter? true
'1234, world' isLetter? true

 var isLetter = function(str) {
     return /^[a-zA-Z]/.test(str);    // '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234abd__";
 console.log("'1234abd__' isLetter? " + isLetter(str1));
 var str2 = "$32343";
 console.log("'$32343' isLetter? " + isLetter(str2));
 var str3 = "hello";
 console.log("'hello' isLetter? " + isLetter(str3));
 var str4 = "hello, world";
 console.log("'hello, world' isLetter? " + isLetter(str4));
 var str5 = "hello, 1234";
 console.log("'hello, 1234' isLetter? " + isLetter(str5));
 var str6 = "1234, world";
 console.log("'1234, world' isLetter? " + isLetter(str6));

'1234abd__' isLetter? false
'$32343' isLetter? false
'hello' isLetter? true
'hello, world' isLetter? true
'hello, 1234' isLetter? true
'1234, world' isLetter? false

 var isLetter = function(str) {
     return /[a-zA-Z]+$/.test(str);    // '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234abd__";
 console.log("'1234abd__' isLetter? " + isLetter(str1));
 var str2 = "$32343";
 console.log("'$32343' isLetter? " + isLetter(str2));
 var str3 = "hello";
 console.log("'hello' isLetter? " + isLetter(str3));
 var str4 = "hello, world";
 console.log("'hello, world' isLetter? " + isLetter(str4));
 var str5 = "hello, 1234";
 console.log("'hello, 1234' isLetter? " + isLetter(str5));
 var str6 = "1234, world";
 console.log("'1234, world' isLetter? " + isLetter(str6));

'1234abd__' isLetter? false
'$32343' isLetter? false
'hello' isLetter? true
'hello, world' isLetter? true
'hello, 1234' isLetter? false
'1234, world' isLetter? true

 var isNum = function(str) {
     return /^\d+$/.test(str);        // '^'表示从字符串开头开始，'+$'表示到字符串结束
 };

 var str1 = "1234";
 console.log("'1234' isNum? " + isNum(str1));
 var str2 = "1234 3456";
 console.log("'1234 3456' isNum? " + isNum(str2));
 var str3 = "1234 abcd";
 console.log("'1234 abcd' isNum? " + isNum(str3));
 var str4 = "abcd 3456";
 console.log("'abcd 3456' isNum? " + isNum(str4));
 var str5 = "1234abd__";
 console.log("'1234abd__' isNum? " + isNum(str5));
 var str6 = "$32343";
 console.log("'$32343' isNum? " + isNum(str6));
 var str7 = "hello";
 console.log("'hello' isNum? " + isNum(str7));
 var str8 = "hello, world";
 console.log("'hello, world' isNum? " + isNum(str8));
 var str9 = "hello, 1234";
 console.log("'hello, 1234' isNum? " + isNum(str9));
 var str10 = "1234, world";
 console.log("'1234, world' isNum? " + isNum(str10));

'1234' isNum? true
'1234 3456' isNum? false
'1234 abcd' isNum? false
'abcd 3456' isNum? false
'1234abd__' isNum? false
'$32343' isNum? false
'hello' isNum? false
'hello, world' isNum? false
'hello, 1234' isNum? false
'1234, world' isNum? false

// 全局命名空间
var MYAPP = MYAPP || {};

// 子命名空间
MYAPP.event = {};

 // 给普通方法和属性创建一个叫做MYAPP.commonMethod的容器
 MYAPP.commonMethod = {
     regExForName: "", // 定义名字的正则验证
     regExForPhone: "", // 定义电话的正则验证
     validateName: function(name){
         // 对名字name做些操作，你可以通过使用“this.regExForname”
         // 访问regExForName变量
     },

     validatePhoneNo: function(phoneNo){
         // 对电话号码做操作
     }
 }

 // 对象和方法一起申明
 MYAPP.event = {
     addListener: function(el, type, fn) {
         //  代码
     },
     removeListener: function(el, type, fn) {
         // 代码
     },
     getEvent: function(e) {
         // 代码
     }

     // 还可以添加其他的属性和方法
 }

 //使用addListener方法的写法:
 MYAPP.event.addListener("yourel", "type", callback);

console.log(Math.random());                 // 比如输出值为：0.1400815874857133

 function Person() {
     // 函数体
 }

 // 或者
 var Person = function() {
     // 函数体
 };

 // 定义一个新类Person
 function Person() {
     // 函数体
 }

 // 创建两个Person的实例
 var person1 = new Person();
 var person2 = new Person();

 // 定义一个新类Person
 function Person() {
     // 函数体
     alert('Person instantiated');
 }

 // 创建两个Person的实例
 var person1 = new Person();
 var person2 = new Person();

 // 定义一个新类Person
 function Person(firstName) {
     this.firstName = firstName;
     console.log('Person instantiated');
 }

 // 创建两个Person的实例
 var person1 = new Person('Alice');
 var person2 = new Person('Bob');
 // Show the firstName properties of the objects
 console.log('person1 is ' + person1.firstName);         // person1 is Alice
 console.log('person2 is ' + person2.firstName);         // person2 is Bob

 // 定义一个新类Person
 function Person(firstName) {
     this.firstName = firstName;
     console.log('Person instantiated');
 }

 Person.prototype.sayHello = function() {
     console.log("Hello, I'm " + this.firstName);
 }

 // 创建两个Person的实例
 var person1 = new Person('Alice');
 var person2 = new Person('Bob');
 // Show the firstName properties of the objects
 console.log('person1 is ' + person1.firstName);         // person1 is Alice
 console.log('person2 is ' + person2.firstName);         // person2 is Bob
 person1.sayHello();                                     // Hello, I'm Alice
 person2.sayHello();                                     // Hello, I'm Bob

 // 定义一个新类Person
 function Person(firstName) {
     this.firstName = firstName;
     console.log('Person instantiated');
 }

 Person.prototype.sayHello = function() {
     console.log("Hello, I'm " + this.firstName);
 }

 // 创建两个Person的实例
 var person1 = new Person('Alice');
 var person2 = new Person('Bob');
 var helloFunction = person1.sayHello;
 // Show the firstName properties of the objects
 console.log('person1 is ' + person1.firstName);         // person1 is Alice
 console.log('person2 is ' + person2.firstName);         // person2 is Bob
 person1.sayHello();                                     // Hello, I'm Alice
 person2.sayHello();                                     // Hello, I'm Bob
 helloFunction();                                        // Hello, I'm undefined

 console.log(helloFunction === person1.sayHello);            // true
 console.log(helloFunction === Person.prototype.sayHello);   // true
 helloFunction.call(person1);                                // Hello, I'm Alice

 // 定义一个Person构造器
 function Person(firstName) {
     this.firstName = firstName;
     console.log('Person instantiated');
 }

 // 在Person.prototype中加入方法
 Person.prototype.walk = function() {
     console.log("I am walking");
 };
 Person.prototype.sayHello = function() {
     console.log("(Person) Hello, I'm " + this.firstName);
 };

 // 定义Student构造器
 function Student(firstName, subject) {
     // 调用父类构造器，确保（使用Function#call）"this"在调用过程中设置正确
     Person.call(this, firstName);
     // 初始化Student类特有属性
     this.subject = subject;
 }

 // 建立一个由Person.prototype继承而来的Student.prototype对象
 // 注意：常见的错误是使用new Person()来建立Student.prototype
 // 这样做的错误之处有很多, 最重要的一点是我们在实例化时
 // 不能赋予Person类任何的FirstName参数
 // 调用Person的正确位置如下，我们从Student中来调用它
 Student.prototype = Object.create(Person.prototype);

 // Student.prototype更换"sayHello"方法
 Student.prototype.sayHello = function() {
     console.log("(Student) Hello, I'm " + this.firstName + ". I'm studying " + this.subject + ".");
 }

 // Student.prototype加入"sayGoodbye"方法
 Student.prototype.sayGoodbye = function() {
     console.log("(Student) Goodbye!");
 }

 // 测试实例
 var person1 = new Person('(Person) Alice');
 var student1 = new Student("(Student) Janet", "Applied Physics");
 person1.sayHello();                                 // (Person) Hello, I'm (Person) Alice
 student1.sayHello();                                // (Student) Hello, I'm (Student) Janet. I'm studying Applied Physics.
 student1.sayGoodbye();                              // (Student) Goodbye!
 console.log(student1 instanceof Person);            // true
 console.log(student1 instanceof Student);           // true

 var foo = function() {};

 console.log("foo is a Function: " + (foo instanceof Function));                     // foo is a Function: true
 console.log( 'foo.prototype is an Object: ' + (foo.prototype instanceof Object) );  // foo.prototype is an Object: true

 // 1. 语法结构创建的对象
 // 创建一个自身拥有属性a和b的函数里创建一个对象o
 function f() {
     this.a = 1;
     this.b = 2;
 }

 var o = new f();
 // 在f函数的原型上定义属性
 f.prototype.c = 3;
 f.prototype.d = 3;

 f.prototype.func = function () {
     console.log("1.5 hello");
 }

 console.log("1.1 f: " + f);
 console.log("1.2 f.prototype: " + JSON.stringify(f.prototype));
 console.log("1.3 f.prototype.prototype: " + f.prototype.prototype);
 console.log("1.4 o.a: " + o.a + ", o.b: " + o.b + ", o.c: " + o.c + ", o.d: " + o.d);
 o.func();

 var o1 = {
     a: 2,
     m: function () {
         return this.a + 2;
     }
 }
 console.log("1.6 " + o1.m()); // 当调用 o.m 时，"this" 指向了 o1.

 var p = Object.create(o1); // p 是一个继承来自 o1 的对象
 p.a = 4;
 console.log("1.7 " + p.m());
 console.log("1.8 " + Object.prototype + "\n");

 // 2. 构造器创建的对象
 function Graph() {
     this.vertices = [];
     this.edges = [];
 }
 Graph.prototype = {
     addVertex: function (v) {
         this.vertices.push(v);
     }
 };

 var g = new Graph();
 g.addVertex(15);
 console.log("2.1 g.vertices[0]: " + g.vertices[0] + "\n");

 // 3. Object.create创建的对象
 var aa = {
     a1: 1
 };
 // aa ---> Object.prototype ---> null
 console.log("3.1 " + aa.hasOwnProperty);
 var b = Object.create(aa); // 创建一个新的对象
 // b ---> aa ---> Object.prototype ---> null
 console.log("3.2 " + b.hasOwnProperty);
 var c = Object.create(b); // 创建一个新的对象
 // c ---> b ---> aa ---> Object.prototype ---> null
 console.log("3.3 " + c.hasOwnProperty);
 var d = Object.create(null); // 创建一个新的对象
 // d ---> null
 console.log("3.4 " + d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype

 // 4. class 关键字创建的对象
 "use strict";

 class Polygon {
     constructor(height, width) {
         this.height = height;
         this.width = width;
     }
 }

 class Square extends Polygon {
     constructor(sideLength) {
         super(sideLength, sideLength);
     }
     get area() {
         return this.height * this.width;
     }
     set sideLength(newLength) {
         this.height = newLength;
         this.width = newLength;
     }
     call() {
         console.log("4.2 hello");
     }
 }

 var square = new Square(2);
 console.log("4.1 square.height: " + square.height + ", square.width: " + square.width + "\n");

 // 5. 性能
 // 在原型链上查找属性比较耗时，对性能有副作用，这在性能要求苛刻的情况下很重要。另外，试图访问不存在的属性时会遍历整个原型链。
 // 遍历对象的属性时，原型链上的每个可枚举属性都会被枚举出来。
 // 要检查对象是否具有自己定义的属性，而不是其原型链上的某个属性，则必须使用所有对象从Object.prototype继承的 hasOwnProperty 方法。
 console.log("5.1 " + square.hasOwnProperty("height"));
 console.log("5.2 " + square.hasOwnProperty("height2"));
 // hasOwnProperty 是 JavaScript 中处理属性并且不会遍历原型链的方法之一。(另一种方法: Object.keys())
 // 注意：检查属性是否undefined还不够。该属性可能存在，但其值恰好设置为undefined。

this.prototype = {constructor: this};

var Mammal = function (name) {
    this.name = name;
};
Mammal.prototype.get_name = function () {
    return this.name;
};
Mammal.prototype.says = function () {
    return this.saying || '';
};

// 现在可以构造一个实例
var myMammal = new Mammal("Herb the Mammal");
var name = myMammal.get_name();
console.log(name);

 var Mammal = function (name) {
     this.name = name;
 };
 Mammal.prototype.get_name = function () {
     return this.name;
 };
 Mammal.prototype.says = function () {
     return this.saying || '';
 };

 // // 现在可以构造一个实例
 // var myMammal = new Mammal("Herb the Mammal");
 // var name = myMammal.get_name();
 // console.log(name);

 var Cat = function (name) {
     this.name = name;
     this.saying = 'meow';
 };
 // 替换Cat.prototype为一个新的Mammal实例
 Cat.prototype = new Mammal();
 // 扩充新原型对象，增加purr和get_name方法
 Cat.prototype.purr = function (n) {
     var i, s = '';
     for (i = 0; i < n; i++) {
         if (s) {
             s += '-';
         }
         s += 'r';
     }
     return s;
 };
 Cat.prototype.get_name = function () {
     return this.says() + ' ' + this.name + ' ' + this.says();
 };

 var myCat = new Cat('Henrietta');
 var says = myCat.says();
 console.log(says);                  // 'meow'
 var purr = myCat.purr(5);
 console.log(purr);                  // r-r-r-r-r
 var name = myCat.get_name();
 console.log(name);                  // 'meow Henrietta meow'

r-r-r-r-r
meow Henrietta meow

1 var myObject = maker(f, l, m, c, s);

var myObject = maker({
    first: f,
    last: l,
    state: s,
    city: c
});

var person = {
    name: "Nicholas",
    _job: "Software Engineer",
    sayName: function () {
        console.log(this.name);
    },
    get job() {
        return this._job;
    },
    set job(newJob) {
        this._job = newJob;
    }
};

console.log(person.name);                   // 输出Nicholas
console.log(person._job);                   // "Software Engineer"
console.log(person.job);                    // "Software Engineer"
person.job = 'Coder';
console.log(person.job);                    // Coder
console.log(person._job);                   // Coder

var descriptors= Object.getOwnPropertyDescriptors(person);
console.log(descriptors);

{ name:
   { value: 'Nicholas',
     writable: true,
     enumerable: true,
     configurable: true },
  _job:
   { value: 'Coder',
     writable: true,
     enumerable: true,
     configurable: true },
  sayName:
   { value: [Function: sayName],
     writable: true,
     enumerable: true,
     configurable: true },
  job:
   { get: [Function: get job],
     set: [Function: set job],
     enumerable: true,
     configurable: true } }

 var person ={};
 // 除了configrable之外，其他三个属性相互之间不会影响，读者可以自己测试

 console.log('---------------------1 writable start---------------------');
 Object.defineProperty(person, "name", {
     writable: false,
     enumerable: true,
     configurable: true,
     value: "Nicholas"
 });

 console.log("1.1 " + person.name);  // "Nicholas"
 person.name = "Greg";
 // writable为false，属性不可修改
 console.log("1.2 " + person.name);  // "Nicholas"

 // writable为false，但configrable为true，我们可以重新配置属性描述符，
 Object.defineProperty(person, "name", {
     writable: false,
     enumerable: true,
     configurable: true,
     value: "John"
 });
 console.log("1.3 " + person.name)   // John

 delete person.name
 //但configrable为true，属性可以被删除
 console.log("1.4 " + person.name)   // undefined
 console.log('---------------------1 writable end---------------------\n');

 console.log('---------------------2 enumerable start---------------------');
 var person = {};
 Object.defineProperty(person, "name", {
     writable: false,
     enumerable: true,
     configurable: true,
     value: "Nicholas"
 });
 // enumerable为true属性可枚举
 for (var prop in person) {
     console.log("2.1 " + prop);      // name
 }

 Object.defineProperty(person, "name", {
     writable: false,
     enumerable: false,
     configurable: true,
     value: "Nicholas"
 });
 // enumerable为false属性不可枚举,循环体不执行
 for (var prop in person) {
     console.log("2.2 " + prop)         //
 }
 console.log('---------------------2 enumerable end---------------------\n');

 console.log('---------------------3 configurable start---------------------');
 var person = {};
 Object.defineProperty(person, "name", {
     writable: true,
     enumerable: true,
     configurable: false,
     value: "Nicholas"
 });
 // configurable为false,writable为true，属性仍然可修改
 person.name = "John"
 console.log("3.1 " + person.name);   // John

 // configurable为false,writable为true,仍然可以通过配置的方式改变属性值
 Object.defineProperty(person, "name", {
     writable: true,
     enumerable: true,
     configurable: false,
     value: "Nicholas"
 });
 console.log("3.2 " + person.name)    // Nicholas

 // configurable为false,enumerable为ture，属性可枚举
 for (var prop in person) {
     console.log("3.3 " + prop)         // name
 }

 // configurable为false,我们仍然可以把writable属性由true改为false
 Object.defineProperty(person, "name", {
     writable: false,
     enumerable: true,
     configurable: false,
     value: "Nicholas"
 });
 console.log("3.4 " + Object.getOwnPropertyDescriptor(person, "name"))//{value: "Nicholas", writable: false, enumerable: true, configurable: false}

 // configurable为false,writable为false,不能通过配置改变value的值
 try{
     Object.defineProperty(person, "name", {
         writable: false,
         enumerable: true,
         configurable: false,
         value: "John"
     });
 } catch(error) {
     console.log("3.5 " + "value change error");
     console.log(Object.getOwnPropertyDescriptor(person, "name"))//{value: "Nicholas", writable: false, enumerable: true, configurable: false}
 }

 // configurable为false,但是不能把writable属性由false改为true
 try{
     Object.defineProperty(person, "name", {
         writable: true,
         enumerable: true,
         configurable: false,
         value: "Nicholas"
     });
 } catch(error) {
     console.log("3.6 " + "writable false to true error")
     console.log(Object.getOwnPropertyDescriptor(person, "name"))//{value: "Nicholas", writable: false, enumerable: true, configurable: false}
 }

 // configurable为false,不能改变enumerable的值
 try{
     Object.defineProperty(person, "name", {
         writable: false,
         enumerable: false,
         configurable: false,
         value: "Nicholas"
     });
 } catch(error) {
     console.log("3.7 " + "enumerable change error");
     console.log(Object.getOwnPropertyDescriptor(person, "name"))//{value: "Nicholas", writable: false, enumerable: true, configurable: false}
 }

 var person = {};
 Object.defineProperty(person, "name", {
     writable: true,
     enumerable: true,
     configurable: true,
     value: "Nicholas"
 });

 // configurable为true,可以把数据属性修改为访问器属性
 try{
     Object.defineProperty(person, "name", {

         get: function(){return "Nicholas"},
         enumerable: true,
         configurable: false
     });
 } catch(error) {
     console.log("3.8 " + "get error");
 }
 console.log("3.9 " + Object.getOwnPropertyDescriptor(person, "name"))//{set: undefined, enumerable: true, configurable: false, get: ƒ}

 var person = {};
 Object.defineProperty(person, "name", {
     writable: true,
     enumerable: true,
     configurable: false,
     value: "Nicholas"
 });
 // configurable为false,不可以把数据属性修改为访问器属性
 try{
     Object.defineProperty(person, "name", {
         get: function(){return "Nicholas"},
         enumerable: true,
         configurable: false
     });
 } catch(error) {
     console.log("3.10 " + "get error");
 }
 console.log("3.11 " + Object.getOwnPropertyDescriptor(person, "name"))//{value: "Nicholas", writable: true, enumerable: true, configurable: false}
 console.log('---------------------3 configurable end---------------------\n');

1.3 John
1.4 undefined
---------------------1 writable end---------------------
---------------------2 enumerable start---------------------
2.1 name
---------------------2 enumerable end---------------------
---------------------3 configurable start---------------------
3.1 John
3.2 Nicholas
3.3 name
{ value: 'Nicholas',
  writable: false,
  enumerable: true,
  configurable: false }
3.5 value change error
{ value: 'Nicholas',
  writable: false,
  enumerable: true,
  configurable: false }
3.6 writable false to true error
{ value: 'Nicholas',
  writable: false,
  enumerable: true,
  configurable: false }
3.7 enumerable change error
{ value: 'Nicholas',
  writable: false,
  enumerable: true,
  configurable: false }
3.9 [object Object]
3.10 get error
3.11 [object Object]
---------------------3 configurable end---------------------

 console.log("----------------------1 访问器属性开始----------------------");
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
     get: function () {
         console.log("1.1 get被调用");
         return this._name;
     },
     set: function (newName) {
         console.log("1.2 set被调用");
         this._name = newName;
     },
     enumerable: true,
     configurable: true
 });
 person.name;                            // get被调用
 person.name = "John";                   // set被调用
 console.log("----------------------1 访问器属性结束----------------------\n");

 console.log("----------------------2 不设set开始----------------------");
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
   get: function () {
             console.log("2.1 get被调用");
             return this._name;
         },
     enumerable: true,
     configurable: true
 });
 person.name;                            // get被调用
 person.name = "John";                   // 没有设置set，什么也没发生
 console.log("2.2 " + person.name)       // Nicholas
 console.log("----------------------2 不设set结束----------------------\n");

 console.log("----------------------3 不设get开始----------------------");
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
     set: function (newName) {
         console.log("3.1 set被调用");
         this._name = newName;
     },
     enumerable: true,
     configurable: true
 });
 console.log("3.2 " + person.name);      // 没有get，得到 undefined
 console.log("3.3 " + person._name);     // Nicholas
 person.name = "John";                   // set被调用
 console.log("3.4 " + person._name)      // John，通过set，_name的值被改变
 console.log("----------------------3 不设get结束----------------------\n");

 console.log("----------------------4 不设get set开始----------------------");
 // 虽然不报错，但是这个属性没有任何意义
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
     enumerable: true,
     configurable: true
 });
 console.log("----------------------4 不设get set结束----------------------\n");

 console.log("----------------------5 enumerable 开始----------------------");
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
     get: function () {
         console.log("5.1 " + "get被调用");
         return this._name;
     },
     set: function (newName) {
         console.log("5.2 " + "set被调用");
         this._name = newName;
     },
     enumerable: true,
     configurable: true
 });
 for (var prop in person) {
     console.log("5.3 " + prop);         // _name,name
 }

 Object.defineProperty(person, "name", {
     get: function () {
         console.log("5.4 " + "get被调用");
         return this._name;
     },
     set: function (newName) {
         console.log("5.5 " + "set被调用");
         this._name = newName;
     },
     enumerable: false,
     configurable: true
 });
 for (var prop in person) {
     console.log("5.6 " + prop);         // _name
 }
 console.log("----------------------5 enumerable 结束----------------------\n");

 console.log("----------------------6 configurable 开始----------------------");
 var person = {_name: "Nicholas"};
 Object.defineProperty(person, "name", {
     get: function () {
         console.log("6.1 " + "get被调用");
         return this._name;
     },
     set: function (newName) {
         console.log("6.2 " + "set被调用");
         this._name = newName;
     },
     enumerable: true,
     configurable: false
 });
 person.name;                            // get被调用
 person.name = "John";                   // set被调用
 console.log("6.3 " + person.name);      // John

 // configurable: false,重新配置访问器属性报错
 try{
 Object.defineProperty(person, "name", {
     get: function () {
         console.log("6.4 " + "get被调用");
         return this._name;
     },
     set: function (newName) {
         console.log("6.5 " + "set被调用");
         this._name = newName;
     },
         enumerable: true,
         configurable: false
     });
 } catch (e) {
     console.log("6.6 " + "不能重新定义name的属性标识符");
 }

 // configurable: false,重新配置数据属性报错
 try{
     Object.defineProperty(person, "name", {
         value: "123",
         writable: true,
         enumerable: true,
         configurable: false
     });
 } catch (e) {
   console.log("6.7 " + "不能重新定义name的属性标识符");
 }
 console.log("----------------------6 configurable 结束----------------------\n");

----------------------1 访问器属性开始----------------------
1.1 get被调用
1.2 set被调用
----------------------1 访问器属性结束----------------------
----------------------2 不设set开始----------------------
2.1 get被调用
2.1 get被调用
2.2 Nicholas
----------------------2 不设set结束----------------------
----------------------3 不设get开始----------------------
3.2 undefined
3.3 Nicholas
3.1 set被调用
3.4 John
----------------------3 不设get结束----------------------
----------------------4 不设get set开始----------------------
----------------------4 不设get set结束----------------------
----------------------5 enumerable 开始----------------------
5.3 _name
5.3 name
5.6 _name
----------------------5 enumerable 结束----------------------
----------------------6 configurable 开始----------------------
6.1 get被调用
6.2 set被调用
6.1 get被调用
6.3 John
6.6 不能重新定义name的属性标识符
6.7 不能重新定义name的属性标识符
----------------------6 configurable 结束----------------------

 function Person () {}

 var p = Person.prototype;
 p._name = "John";
 Object.defineProperty(p, "name", {
     get: function () {return this._name;},
     set: function (newName) {this._name = newName;},
     enumerable: true,
     configurable: true
 });

 var person = new Person();
 console.log("1 " + person.name);                        // John
 console.log("2 " + person.hasOwnProperty("_name"));     // false
 console.log("3 " + person.hasOwnProperty("name"));      // false

 // 虽然name属性的set get方法是定义在原型中的
 // 但是通过person调用时，它们的this属性会指向person
 // 所以通过person.name设置属性时，执行set方法中this._name = newName时
 // 会给person对象添加_name属性，并把newName赋给person新建的属性_name
 person.name = "Nicholas";
 console.log("4 " + person.name);                        // Nicholas
 console.log("5 " + p._name);                            // John
 console.log("6 " + person.hasOwnProperty("name"));      // false
 console.log("7 " + person.hasOwnProperty("_name"));     // true

// 函数化构造器的伪代码模板
var constructor = function (spec, my) {
    var that, 其它的私有实例变量;
    my = my || {};
    // 把共享的变量和函数添加到my中
    that = 一个新对象;
    添加给that的特权方法
    return that;
};

 var mammal = function (spec) {
     var that = {};
     that.get_name = function () {
         return spec.name;
     };
     that.says = function () {
         return spec.saying || '';
     };
     return that;
 };
 var myMammal_1 = mammal({name: 'Herb'});
 console.log("1.1 " + myMammal_1.get_name());
 console.log("1.2 " + myMammal_1.says());

 var myMammal_2 = mammal({name: 'Herb', saying: 'Hello, world!'});
 console.log("2.1 " + myMammal_2.get_name());
 console.log("2.2 " + myMammal_2.says());

 // 在伪类模式中，构造器函数Cat不得不重复构造器Mammal已经完成的工作。
 // 在函数话模式中那不再需要了，因为构造器将会调用构造器Mammal，
 // 让Mammal去做创建对象中的大部分工作，所以Cat只需关注自身的差异即可。
 var cat = function (spec) {
     spec.saying = spec.saying || 'meow';
     var that = mammal(spec);
     that.purr = function (n) {
         var i, s = '';
         for (i = 0; i < n; i++) {
             if (s) {
                 s += '-';
             }
             s += 'r';
         }
         return s;
     };
     that.get_name = function () {
         return this.says() + " " + spec.name + " " + this.says();
     };
     return that;
 };
 var myCat = cat({name: 'Henrietta'});
 console.log("3.1 " + myCat.get_name());
 console.log("3.2 " + myCat.purr(5));

1.1 Herb
1.2
2.1 Herb
2.2 Hello, world!
3.1 meow Henrietta meow
3.2 r-r-r-r-r

• 参考：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Strict_mode

// 整个脚本都开启严格模式的语法
"use strict";
var v = "Hi!  I'm a strict mode script!";

function strict() {
    // 函数级别严格模式语法
    'use strict';
    function nested() { return "And so am I!"; }
    return "Hi!  I'm a strict mode function!  " + nested();
}
function notStrict() { return "I'm not strict."; }

1 <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js">
2 </script>