JavaScript

var scope = "global";        // Declare a global variable

function checkscope( ) {
  var scope = "local";       // 全局变量scope被局部变量遮盖了
  console.log(scope);        // Use the local variable, not the global one
}
checkscope();                // Prints "local"

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // 同样的变量!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // 不同的变量
    console.log(x);  // 2
  }
  console.log(x);  // 1
}

// Test Infinity
console.log(Number.MAX_VALUE);      // 1.7976931348623157e+308
console.log(Number.MAX_VALUE * 2);  // Infinity
console.log(1/0);                   // Infinity
console.log(-1/0);                  // -Infinity

// Test NaN
console.log(0/0);                   // NaN
console.log(Infinity/Infinity);     // NaN
console.log(Math.sqrt(-1));         // NaN
console.log(parseInt("abcd"));      // NaN

isNaN = function(value) {
    Number.isNaN(Number(value));
}

// Test isFinite
console.log(isFinite(5));          // true
console.log(isFinite("5"));        // true

console.log(isFinite("abcd"));     // false

console.log(isFinite(Infinity));   // false
console.log(isFinite(NaN));        // false

console.log(isFinite(true));       // true
console.log(isFinite(false));      // true

console.log(isFinite(null));       // true
console.log(isFinite(undefined));  // false


// Test isNaN
console.log(isNaN(NaN));       // true
console.log(isNaN(undefined)); // true
console.log(isNaN({}));        // true

console.log(isNaN(true));      // false
console.log(isNaN(null));      // false
console.log(isNaN(37));        // false

// strings
console.log(isNaN("37"));      // false: "37" is converted to the number 37 which is not NaN
console.log(isNaN("37.37"));   // false: "37.37" is converted to the number 37.37 which is not NaN
console.log(isNaN("123ABC"));  // true:  parseInt("123ABC") is 123 but Number("123ABC") is NaN
console.log(isNaN(""));        // false: the empty string is converted to 0 which is not NaN
console.log(isNaN(" "));       // false: a string with spaces is converted to 0 which is not NaN

// dates
console.log(isNaN(new Date()));                // false
console.log(isNaN(new Date().toString()));     // true

// This is a false positive and the reason why isNaN is not entirely reliable
console.log(isNaN("blabla"))   // true: "blabla" is converted to a number.
                               // Parsing this as a number fails and returns NaN

var n = 100;
var n_as_string = n + "";    // "100"
var s = 100 + " times";      // "100 times"

// Test toExponential
var num = 18.2345;
num.toExponential();    // "1.82345e+1"
num.toExponential(2);   // "1.82e+1"
num.toExponential(3);   // "1.823e+1"

// Test toFixed
var num = 18.2345;
num.toFixed();      // "18"
num.toFixed(2);     // "18.23"
num.toFixed(3);     // "18.234"

// Test toPrecision
var num = 18.2345;
num.toPrecision();   // "18.2345"
num.toPrecision(1);  // "2e+1"
num.toPrecision(2);  // "18"
num.toPrecision(3);  // "18.2"
num.toPrecision(4);  // "18.23"

// Test toString
var num = 15;
num.toString();     // "15"
num.toString(2);    // "1111"
num.toString(8);    // "17"
num.toString(16);   // "f"

var n = "12" * "2";              // n is the number 24.

var string_value = "100";
var number = string_value - 0;   // 变量number为数字 100
                                 // 注意：只能是减0，不能用‘+ 0’，否则number会为"1000"

parseInt("3 blind mice");    // Returns 3
parseFloat("3.14 meters");   // Returns 3.14
parseInt("12.34");           // Returns 12
parseInt("0xFF");            // Returns 255

parseInt("11", 2);           // Returns 3 (1*2 + 1)
parseInt("ff", 16);          // Returns 255 (15*16 + 15)
parseInt("zz", 36);          // Returns 1295 (35*36 + 35)
parseInt("077", 8);          // Returns 63 (7*8 + 7)
parseInt("077", 10);         // Returns 77 (7*10 + 7)

parseInt("eleven");          // Returns NaN
parseFloat("abc72.47");      // Returns NaN

var msg1="a";
var msg2="b";

console.log("msg1 is " + msg1 + ", msg2 is " + msg2);
console.log(`msg1 is ${msg1}, msg2 is ${msg2}`);            // 和上一行输出相同

var a = 5;
var b = 10;
console.log("Fifteen is " + (a + b) + " and not " + (2 * a + b) + ".");   // 输出 Fifteen is 15 and not 20.
console.log(`Fifteen is ${a + b} and not ${2 * a + b}.`);                 // 和上一行输出相同

throw 'Error2'; // generates an exception with a string value
throw 42;       // generates an exception with the value 42
throw true;     // generates an exception with the value true

function UserException(message) {
   this.message = message;
   this.name = 'UserException';
}
function getMonthName(mo) {
   mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)
   var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
      'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
   if (months[mo] !== undefined) {
      return months[mo];
   } else {
      throw new UserException('InvalidMonthNo');
   }
}

try {
   // statements to try
   var myMonth = 15; // 15 is out of bound to raise the exception
   var monthName = getMonthName(myMonth);
} catch (e) {
   monthName = 'unknown';
   console.log(e.message, e.name); // pass exception object to err handler
}

try...catch
try...finally
try...catch...finally

var empty = {};                          // An object with no properties
var point = { x:0, y:0 };                // Two properties, same as { "x":0, "y":0 };
var point2 = { x:point.x, y:point.y+1 }; // More complex values
var book = {
  "main title": "JavaScript",            // Property names include spaces,
  'sub-title': "The Definitive Guide",   // and hyphens, so use string literals
  "for": "all audiences",                // for is a reserved word, so quote
  author: {                              // The value of this property is
    firstname: "David",                  // itself an object. Note that
    surname: "Flanagan"                  // these property names are unquoted.
  }
};

var o = new Object();       // Create an empty object: same as {}.
var a = new Array();        // Create an empty array: same as [].
var d = new Date();         // Create a Date object representing the current time
var r = new RegExp("js");   // Create a RegExp object for pattern matching.

function Person(first, last, age, eye) {   # 按约定（不是语法要求），构造函数的首字母一般用大写
    this.firstName = first;
    this.lastName = last;
    this.age = age;
    this.eyeColor = eye;
}

var myFather = new Person("John", "Doe", 50, "blue");

var empty = [];                    // An array with no elements
var primes = [2, 3, 5, 7, 11];     // An array with 5 numeric elements
var misc = [ 1.1, true, "a", ];    // 3 elements of various types

var count = [1,,3];    // An array with 3 elements, the middle one undefined.
var undefs = [,,];     // 数组直接量允许有“可选的结尾逗号”，所以这个数组是2个元素（都为undefined），而不是3个元素

var a = new Array();          // 创建一个没有元素的空数组，等同于数组直接量[]

var a = new Array(10);        // 仅是预先分配数组空间，数组中没有存储值，甚至数组的索引属性还未定义。

var a = new Array(5, 4, "test1", "test2");
var a = new Array("abc");

o.m = f;      // 给对象o定义方法m
o.m();        // 调用对象方法（相当于调用函数f）

var o1 = {
    prop: 37,
    f1: function() {
        return this.prop;
    }
};
console.log(o1.f1());         // 输出 37

var o = {prop: 37};

function independent() {
    return this.prop;
}

o.f = independent;

console.log(o.f());           // 输出 37
o.b = {g: independent, prop: 42};
console.log(o.b.g());         // 输出 42

// This is a function constructor:
function myFunction(arg1, arg2) {
    this.firstName = arg1;
    this.lastName  = arg2;
}

// This creates a new object
var x = new myFunction("John","Doe");
console.log(x.firstName);               // 输出 "John"

var o = new Object();
var o = new Object;      // 和同一行等价

f1.call(o);    // f1中，this为o
f1.apply(o);   // 同上

function fun1(a, b) {
    return a + b;
}

var o = new Object;
o = fun1.call(o, 10, 2);       // 12
o = fun1.apply(o, [10, 2]);    // 12

class Cat {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(this.name + ' makes a noise.');
  }
}

class Lion extends Cat {
  speak() {
    super.speak();
    console.log(this.name + ' roars.');
  }
}

var l = new Lion('Fuzzy');
l.speak();

var p = new Promise(
    /* executor */
    function(resolve, reject) {

    // Do an async task and then...

    if(/* good condition */) {
        resolve('Success!');     // 将Promise对象的状态从Pending变为Fulfilled(Resolved)
    }
    else {
        reject('Failure!');      // 将Promise对象的状态从Pending变为Rejected
    }
});

p.then(function(value) {    // 如果Promise实例p的状态是Fulfilled，则会调用这个函数（第一个函数）
  // success
}, function(error) {        // 如果Promise实例p的状态是Rejected，则会调用这个函数（第二个函数，可选的）
  // failure
});

var myPromise = new Promise(function(resolve, reject) {
    console.log("Run promise");

    // 为模拟可能成功或失败，这里随机地调用resolve或者reject
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)    // randomNumber会传给then中指定的第一个回调函数
    } else {
      reject(randomNumber)     // randomNumber会传给then中指定的第二个回调函数
    }
});

console.log("Test");

myPromise.then(function(value) {
    console.log("OK, return " + value)
}, function(value) {
    console.log("FAILURE, return " + value)
});

myPromise.then(function(value) {    // 由于Promise对象状态一旦改变就不会再变化，所以第二次（或更多次）在同一个Promise对象上调用then的输出一定和第一次相同
    console.log("OK, return " + value)
}, function(value) {
    console.log("FAILURE, return " + value)
});

function getMyPromise(value) {
    return new Promise(function(resolve, reject) {
        resolve(value)
    });
}

getMyPromise("aa").then(function(value) {  // 省略了Rejected状态的回调函数
    console.log(value);
    return getMyPromise("bb");    // Resolved状态的回调函数返回了另外一个Promise对象
});

// 上面代码会输出：
// aa

function getMyPromise(value) {
    return new Promise(function(resolve, reject) {
        resolve(value)
    });
}

getMyPromise("aa").then(function(value) {
    console.log(value);
    return getMyPromise("bb");
}).then(function(value) {       // 再次调用 then
    console.log(value);         // 有需要的话，还可以返回Promise，后面再调用then
});

// 上面代码会输出：
// aa
// bb

// 方式1（不推荐）
promise.then(function(value) {   // 同时指定Fulfilled状态和Rejected状态的回调函数
    // success
    console.log(value);
  }, function(err) {
    // fail
    console.log(err);
  });

// 方式2（推荐）
promise.then(function(value) {   // 只指定Fulfilled状态的回调函数
    // success                   // 和方式1的不同之处：在这个函数里抛出的异常，也能被后面的catch处理。
    console.log(value);
  })
  .catch(function(err) {         // 相当于指定Rejected状态的回调函数
    // fail
    console.log(err);
  });

var myPromise = new Promise(function(resolve, reject) {
    console.log("Run promise");

    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
});

myPromise.then(function(value) {
    console.log("OK, return " + value)
}, function(value) {
    console.log("FAILURE, return " + value)
});

var myPromise = new Promise((resolve, reject) => {
    console.log("Run promise");

    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
});

myPromise.then(
    value => console.log("OK, return " + value),
    value => console.log("FAILURE, return " + value)
);

 1: function divide(numerator, denominator) {
 2:   return new Promise((resolve, reject) => {
 3:     if (denominator === 0) {
 4:       reject("Cannot divide by 0");
 5:       // return;  // 需要这个return语句吗？
 6:     }
 7: 
 8:     resolve(numerator / denominator);
 9:   });
10: }
11: 
12: divide(5, 0)
13:   .then((result) => console.log('result: ', result))
14:   .catch((error) => console.log('error: ', error));

 1: function divide(numerator, denominator) {
 2:   return new Promise((resolve, reject) => {
 3:     if (denominator === 0) {
 4:       reject("Cannot divide by 0");
 5:     }
 6: 
 7:     console.log('operation succeeded');
 8:     resolve(numerator / denominator);
 9:   });
10: }
11: 
12: divide(5, 0)
13:   .then((result) => console.log('result: ', result))
14:   .catch((error) => console.log('error: ', error));

 1: function divide(numerator, denominator) {
 2:   return new Promise((resolve, reject) => {
 3:     if (denominator === 0) {
 4:       reject("Cannot divide by 0");
 5:       return;
 6:     }
 7: 
 8:     console.log('operation succeeded');
 9:     resolve(numerator / denominator);
10:   });
11: }

 1: function divide(numerator, denominator) {
 2:   return new Promise((resolve, reject) => {
 3:     if (denominator === 0) {
 4:       return reject("Cannot divide by 0");
 5:     }
 6: 
 7:     console.log('operation succeeded');
 8:     resolve(numerator / denominator);
 9:   });
10: }

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    } else {
      console.log('operation succeeded');
      resolve(numerator / denominator);
    }
  });
}

var a, b, rest;
[a, b] = [10, 20];   // 这是解构，从数组 [10, 20] 中提取值，赋值给变量 a 和 b

console.log(a);      // 10
console.log(b);      // 20

[a, b, ...rest] = [10, 20, 30, 40, 50];  // 最后一个变量前加三点，会把数组剩余元素组成的数组赋值给它

console.log(rest);   // [30,40,50]

let { foo, bar } = { bar: 'bbb', foo: 'aaa' };
console.log(foo);    // aaa
console.log(bar);    // bbb

let { a: newName1, b: newName2 } = o;

let newName1 = o.a;
let newName2 = o.b;

var {p: foo, q: bar} = {p: 42, q: true};  // 对象解构，属性p重命名为了foo，而属性q重命名为了bar

console.log(foo);      // 42
console.log(bar);      // true