let script = document.createElement('script'); script.src = 'gibberish.js';
script.async = false; document.head.appendChild(script);

<script type="text/javascript">
//<![CDATA[
function compare(a, b) { if (a < b) {
console.log("A is less than B");
} else if (a > b) { console.log("A is greater than B");
} else { console.log("A is equal yo B");
} }
//]]>
</script>

"use strict";//进入严格模式

// preferred
if (test) { console.log(test); }

var message = "hi";
message = 100; // legal, but not recommended

function test() {
var message = "hi"; // local variable
}
test();
console.log(message); // error!

function test() {
message = "hi"; // global variable
}
test();
console.log(message); // "hi"

function foo() { console.log(age); var age = 26;
}
foo(); // undefined

function foo() {
var age;
console.log(age);
age = 26; }
foo(); // undefined

if (true) {
  var name = 'Matt'; 
  console.log(name);// Matt 
} console.log(name);// Matt

if (true) {
  let age = 26; console.log(age);//26
} console.log(age);// ReferenceError: age is not defined

var name; var name;
let age;
let age; // SyntaxError; identifier 'age' has already been declared

// name is hoisted 
console.log(name); // undefined
var name = 'Matt';

// age is not hoisted
console.log(age);//ReferenceError: age is not defined
let age = 26;

var name = 'Matt'; console.log(window.name); // 'Matt'
let age = 26;
console.log(window.age); // undefined

if (typeof name !== 'undefined') {
  let name;
}
name = 'Matt';
// 'name' is restricted to the if {} block scope,
// so this assignment will act as a global assignment name = 'Matt';

const age = 26;
age = 36; // TypeError: assignment to a constant

let message;
console.log(message == undefined); // true
console.log(typeof age); // "undefined"

if (message) { //undefined is falsy
// This block will not execute
}

let car = null;
console.log(typeof car); // "object"

console.log(null == undefined); // true

let intNum = 55; // integer

let octalNum1 = 070; // octal for 56

let hexNum1 = 0xA; // hexadecimal for 10

var a = 0.1,
    b = 0.2;
if (a + b == 0.3) { // avoid! console.log("You got 0.3.");
}// 0.1+0.2 = 0.30000000000000004

var minNumber = Number.MIN_VALUE;
var maxNumber = Number.MAX_VALUE;

console.log(isFinite(minNumber+maxNumber)); // false

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

let num1 = parseInt("1234blue");// 1234

let num = parseInt("0xAF", 16); 
let num1 = parseInt("AF", 16); // 175 十六进制转为十进制
let num2 = parseInt("AF"); // NaN

let firstName = "John";
let lastName = 'Jacob';
let lastName = `Jingleheimerschmidt`

let lang = "Java";
lang = lang + "Script";//没效率，需要将原字符删除

let num = 10; 
console.log(num.toString());		// "10"
console.log(num.toString(2));		// "1010"
console.log(num.toString(8));		// "12" 
console.log(num.toString(10));	// "10" 
console.log(num.toString(16));	// "a"

let myMultiLineString = 'first line\nsecond line'; 
let myMultiLineTemplateLiteral = `first line second line`;
console.log(myMultiLineString === myMultiLinetemplateLiteral); // true

let value = 5;
let exponent = 'second';// Formerly, interpolation was accomplished as follows: 
let interpolatedString = value + ' to the ' + exponent + ' power is ' + (value * value);

// The same thing accomplished with template literals: 
let interpolatedTemplateLiteral = `${ value } to the ${ exponent } power is ${ value * value }`;

let a = 6; let b = 9;
function simpleTag(strings, ...expressions) {
  console.log(strings);
  for(const expression of expressions) {
    console.log(expression); }
  return 'foobar'; 
}
let taggedResult = simpleTag`${ a } + ${ b } = ${a + b}; `
//[""," + "," = ",""]
// 6
// 9
// 15

let mySymbol = new Symbol(); // TypeError: Symbol is not a constructor

let fooGlobalSymbol = Symbol.for('foo');
console.log(typeof fooGlobalSymbol); // "object"

let globalSymbol = Symbol.for('foo');
console.log(localSymbol === globalSymbol); // false

let o = new Object();

let oldValue = 64; // equal to binary 1000000
let newValue = oldValue >>> 5; // equal to binary 10 which is decimal 2

let oldValue = -64; // equal to binary 11111111111111111111111111000000
let newValue = oldValue >>> 5; // equal to decimal 134217726

console.log(Math.pow(3, 2); // 9
console.log(3 ** 2); // 9

let result = "Brick" < "alphabet"; // true

let result = "23" < 3; // false

let result1 = NaN < 3; // false
let result2 = NaN >= 3; // false

variable = boolean_expression ? true_value : false_value;

let num = (5, 1, 4, 8, 0); // num becomes 0

var obj = {a:1, b:2, c:3};
    
for (var prop in obj) {
  console.log("obj." + prop + " = " + obj[prop]);
}

// Output:
// "obj.a = 1"
// "obj.b = 2"
// "obj.c = 3"

const array1 = ['a', 'b', 'c'];

for (const element of array1) {
  console.log(element);
}

// expected output: "a"
// expected output: "b"
// expected output: "c"

let person = new Object();
person.name = "Nicholas"; 
console.log(person.name); // "Nicholas"


let name = "Nicholas";
name.age = 27;
console.log(name.age); // undefined

function addTen(num) {
  num += 10;
  return num;
}
let count = 20;
let result = addTen(count); 
console.log(count); // 20 - no change 
console.log(result); // 30

function setName(obj) { obj.name = "Nicholas";
}
let person = new Object(); setName(person); console.log(person.name); // "Nicholas"

let arr = [1, 2, 3, 4];
arr = null; // [1,2,3,4]这时没有被引用, 会被自动回收

// May 5, 2005 at 5:55:55 PM GMT
let allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));

let person = new Object();	//use new()
person.name = "Nicholas";
person.age = 29;

let person = { 							//use object literal notation
  name: "Nicholas", 				//"name":"Nicholas" is the same
  age: 29
};

let person = {}; // same as new Object()
person.name = "Nicholas"; 
person.age = 29;

/*the first way*/
let colors = new Array();
let colors = new Array(20);	// creates an array with an initial length value of 20
let colors = new Array("red", "blue", "green"); // creates an array with three string values

/*the second way []*/
let colors = ["red", "blue", "green"]; // Creates an array with three strings
let names = []; // Creates an empty array

alert(Array.from("Matt")); // ["M", "a", "t", "t"]

alert(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] convert the list of arguments into an array.

const options = [,,,,,]; // Creates an array with 5 items alert(options.length); // 5
alert(options); // [,,,,,]

let colors = ["red", "blue", "green"]; // creates an array with three strings
colors.length = 2; alert(colors[2]); // undefined

if (Array.isArray(value)){
// do something on the array
}

const a = ["foo", "bar", "baz", "qux"];
// Because these methods return iterators, you can funnel their contents // into array instances using Array.from()
const aKeys = Array.from(a.keys());
const aValues = Array.from(a.values());
const aEntries = Array.from(a.entries());
alert(aKeys); // [0, 1, 2, 3]
alert(aValues); // ["foo", "bar", "baz", "qux"]
alert(aEntries); // [[0, "foo"], [1, "bar"], [2, "baz"], [3, "qux"]]

const zeroes = [0, 0, 0, 0, 0];

// Fill the entire array with 5 
zeroes.fill(5);
alert(zeroes); // [5, 5, 5, 5, 5] 
zeroes.fill(0); // reset

// Fill all indices >=3 with 6 zeroes.fill(6, 3);
alert(zeroes); // [0, 0, 0, 6, 6] 
zeroes.fill(0); // reset

// Fill all indices >= 1 and < 3 with 7 
zeroes.fill(7, 1, 3);
alert(zeroes); // [0, 7, 7, 0, 0]; 
zeroes.fill(0); // reset

// Fill all indices >=1 and < 4 with 8 // (-4 + zeroes.length = 1)
// (-1 + zeroes.length = 4) 
zeroes.fill(8, -4, -1);
alert(zeroes); // [0, 8, 8, 8, 0];

let ints,
    reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
reset();
// Copy the contents of ints beginning at index 0 and ending at index 3 to values // beginning at index 4.
ints.copyWithin(4, 0, 3);
alert(ints); // [0, 1, 2, 3, 0, 1, 2, 7, 8, 9]
reset();

let colors = ["red", "blue", "green"]; // creates an array with three strings
alert(colors.toString()); // red,blue,green alert(colors.valueOf()); // red,blue,green alert(colors); // red,blue,green

let values = [0, 1, 5, 10, 15]; 
values.sort((a, b) => a < b ? a > b ? -1 : 0); 
alert(values); // 15,10,5,1,0

let colors = ["red", "green", "blue"];
let colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors); // ["red", "green","blue"]
alert(colors2); // ["red", "green", "blue", "yellow", "black", "brown"]

let colors = ["red", "green", "blue"];
colors[Symbol.isConcatSpreadable] = false;
let colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"],]

let colors = ["red", "green", "blue", "yellow", "purple"]; let colors2 = colors.slice(1);
let colors3 = colors.slice(1, 4);
alert(colors2); // green,blue,yellow,purple 
alert(colors3); // green,blue,yellow

let colors = ["red", "green", "blue"];
let removed = colors.splice(0,1); // remove the first item
alert(colors); // green,blue 
alert(removed); // red - one item array


removed = colors.splice(1, 0, "yellow", "orange"); // insert two items at position 1
alert(colors); // green,yellow,orange,blue
alert(removed);// empty array

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
alert(numbers.indexOf(4)); // 3 
alert(numbers.indexOf(4, 4)); // 5 从位置4查找4
alert(numbers.lastIndexOf(4)); // 5 
alert(numbers.includes(4)); // true

const people = [ {
name: "Matt",
age: 27 },
{
name: "Nicholas", age: 29
} ];
alert(people.find((element, index, array) => element.age < 28)); // {name: "Matt", age: 27}
alert(people.findIndex((element, index, array) => element.age < 28)); // 0

const buf1 = new ArrayBuffer(16); 
const buf2 = buf1.slice(4, 12); 
alert(buf2.byteLength); // 8

const buf = new ArrayBuffer(16);
// DataView default to use the entire ArrayBuffer 
const fullDataView = new DataView(buf); alert(fullDataView.byteOffset); // 0 
alert(fullDataView.byteLength); // 16 
alert(fullDataView.buffer === buf); // true

// Constructor takes an optional byte offset and byte length
// byteOffset=0 begins the view at the start of the buffer
// byteLength=8 restricts the view to the first 8 bytes 
const firstHalfDataView = new DataView(buf, 0, 8); alert(firstHalfDataView.byteOffset); // 0 
alert(firstHalfDataView.byteLength); // 8 
alert(firstHalfDataView.buffer === buf); // true

// DataView will use the remainder of the buffer unless specified
// byteOffset=8 begins the view at the 9th byte of the buffer
// byteLength default is the remainder of the buffer 
const secondHalfDataView = new DataView(buf, 8); alert(secondHalfDataView.byteOffset); // 8 
alert(secondHalfDataView.byteLength); // 8 
alert(secondHalfDataView.buffer === buf); // true

// Allocate two bytes of memory and declare a DataView 
const buf = new ArrayBuffer(2);
const view = new DataView(buf);
// Demonstrate that the entire buffer is indeed all zeroes 
// Check the first and second byte
alert(view.getInt8(0)); // 0
alert(view.getInt8(1)); // 0
// Check the entire buffer 
alert(view.getInt16(0)); // 0

// Set the entire buffer to ones
// 255 in binary is 11111111 (2^8 – 1) 
view.setUint8(0, 255);

// Allocate two bytes of memory and declare a DataView 
const buf = new ArrayBuffer(2);
const view = new DataView(buf);

// Fill the buffer so that the first bit and last bit are 1 
view.setUint8(0, 0x80); // Sets leftmost bit to 1 
view.setUint8(1, 0x01); // Sets rightmost bit to 1

// Buffer contents (spaced for readability): 
// 0x8 0x0 0x0 0x1
// 1000 0000 0000 0001

// Read a big-endian Uint16
// 0x80 is the high byte, 0x01 is the low byte 
// 0x8001 = 2^15 + 2^0 = 32768 + 1 = 32769 
alert(view.getUint16(0)); // 32769

// Read a little-endian Uint16
// 0x01 is the high byte, 0x80 is the low byte 
// 0x0180 = 2^8 + 2^7 = 256 + 128 = 384 
alert(view.getUint16(0, true)); // 384

const buf = new ArrayBuffer(6); 
const view = new DataView(buf);

// Attempt to get a value past the end of the buffer
view.getInt32(8); // RangeError

const m = new Map();

// Initialize map with nested arrays 
const m1 = new Map([
  ["key1", "val1"], 
  ["key2", "val2"], 
  ["key3", "val3"]
]);
alert(m1.size); // 3

const m = new Map();
alert(m.has("firstName")); // false  
alert(m.get("firstName ")); // undefined 
alert(m.size); // 0

m.delete("firstName"); // deletes only this key/value pair

const m = new Map();
const functionKey = function() {}; 
const symbolKey = Symbol();
const objectKey = new Object();
m.set(functionKey, "functionValue"); 
m.set(symbolKey, "symbolValue"); 
m.set(objectKey, "objectValue");

const m = new Map([ 
  ["key1", "val1"], 
  ["key2", "val2"], 
  ["key3", "val3"]
]);
alert(m.entries === m[Symbol.iterator]); // true

for (let pair of m.entries()) { 
  alert(pair);
}
// [key1,val1] 
// [key2,val2] 
// [key3,val3]

for (let pair of m[Symbol.iterator]()) { 
  alert(pair);
}
// [key1,val1] 
// [key2,val2] 
// [key3,val3]

const s = new Set();
alert(s.has("Matt"));		// false
alert(s.size);					// 0

s.add("Matt") 
  .add("Frisbie");

s.delete("Matt");

let person = new Object(); 
person.name = "Nicholas"; 
person.age = 29;
person.job = "Software Engineer";
person.sayName = function() { 
  console.log(this.name);
};

let person = {
name: "Nicholas",
age: 29,
job: "Software Engineer", sayName() {
console.log(this.name); }
};

let person = {}; Object.defineProperty(person, "name", {
writable: false,
value: "Nicholas" });
console.log(person.name); // "Nicholas" 
person.name = "Greg"; 
console.log(person.name); // "Nicholas"

// Define object with pseudo-private member 'year_' 
// and public member 'edition'
let book = {
  year_: 2017,
  edition: 1 };
	Object.defineProperty(book, "year", { 
    get() {
			return this.year_; 
    },
    set(newValue) {
      if (newValue > 2017) {
				this.year_ = newValue;
				this.edition += newValue - 2017; 
      }
    } 
  });
book.year = 2018;
console.log(book.edition); // 2

let book = {}; 
Object.defineProperties(book, {
  year_: { 
    value: 2017
  },
  edition: { 
    value: 1
  },
  year: { 
    get() {
      return this.year_; 
    },
    set(newValue) {
      if (newValue > 2017) {
        this.year_ = newValue;
        this.edition += newValue - 2017; }
    } 
  }
});

let dest, src, result;
/**
* Simple copy */
dest = {};
src = { id: 'src' };
result = Object.assign(dest, src);
// Object.assign mutates the destination object 
// and also returns that object after exiting.
console.log(dest === result);	// true
console.log(dest !== src);		// true
console.log(result);					// { id: src}
console.log(dest);						// { id: src}

console.log(Object.is(true, 1)); // false
console.log(Object.is({}, {})); // false
console.log(Object.is("2", 2));// false

// Correct 0, -0, +0 equivalence/nonequivalence:
console.log(Object.is(+0, -0)); // false
console.log(Object.is(+0, 0)); // true
console.log(Object.is(-0, 0));// false

// Correct NaN equivalence: 
console.log(Object.is(NaN, NaN)); // true

let name = 'Matt';
let person = { name};
console.log(person); // { name: 'Matt' }

const nameKey = 'name'; 
const ageKey = 'age'; 
const jobKey = 'job'; 
let uniqueToken = 0;
function getUniqueKey(key) {
  return '${key}_${uniqueToken++}';
}
let person = {
  [getUniqueKey(nameKey)]: 'Matt', 
  [getUniqueKey(ageKey)]: 27, 
  [getUniqueKey(jobKey)]: 'Software engineer'
};
console.log(person); // { name_0: 'Matt', age_1: 27, job_2: 'Software engineer' }

let person = {
  sayName: function(name){
    console.log(`My name is ${name}`);
  }
}

let person = {
  sayName(name) {
    console.log(`My name is ${name}`); 
  }
};

const methodKey = 'sayName';
let person = {
  [methodKey](name) {
    console.log('My name is ${name}'); }
}
person.sayName('Matt'); // My name is Matt

// Without object destructuring 
let person = {
  name: 'Matt',
  age: 27 };
let personName = person.name, personAge = person.age;
console.log(personName); // Matt
console.log(personAge); // 27


// With object destructuring 
let person = {
  name: 'Matt',
  age: 27 };
let { name: personName, age: personAge } = person;
console.log(personName); // Matt 
console.log(personAge); // 27

let person = { 
  name: 'Matt', age: 27,
  job: {
    title: 'Software engineer' }
};
let personCopy = {};
({name: personCopy.name, age: personCopy.age, job: personCopy.job
} = person);

// Because an object reference was assigned into personCopy, changing a property 
// inside the person.job object will be propagated to personCopy: 
person.job.title = 'Hacker'

console.log(person);
// { name: 'Matt', age: 27, job: { title: 'Hacker' } }

let person = { 
  name: 'Matt', age: 27
};
let personName, personBar, personAge;
try {
// person.foo is undefined, so this will throw an error
({name: personName, foo: { bar: personBar }, age: personAge} = person);
} catch(e) {}

console.log(personName, personBar, personAge);
// Matt, undefined, undefined

let person = { name: 'Matt', age: 27};

function printPerson(foo, {name, age}, bar) {
  console.log(arguments);
  console.log(name, age);
}
function printPerson2(foo, {name: personName, age: personAge}, bar) { 
  console.log(arguments);
  console.log(personName, personAge);
}

printPerson('1st', person, '2nd');
// ['1st', { name: 'Matt', age: 27 }, '2nd'] // 'Matt', 27

printPerson2('1st', person, '2nd');
// ['1st', { name: 'Matt', age: 27 }, '2nd'] // 'Matt', 27

function createPerson(name, age, job) { 
  let o = new Object();
  o.name = name;
	o.age = age;
	o.job = job;
	o.sayName = function() {
	console.log(this.name); 
  };
	return o; 
}

let person1 = createPerson("Nicholas", 29, "Software Engineer"); let person2 = createPerson("Greg", 27, "Doctor");

function Person(name, age, job){ 
  this.name = name;
	this.age = age;
	this.job = job;
	this.sayName = function() { 
    console.log(this.name);
}; }
let person1 = new Person("Nicholas", 29, "Software Engineer"); 
let person2 = new Person("Greg", 27, "Doctor");
person1.sayName(); // Nicholas 
person2.sayName(); // Greg

// use as a constructor
let person = new Person("Nicholas", 29, "Software Engineer"); person.sayName(); // "Nicholas"

// call as a function
Person("Greg", 27, "Doctor"); // adds to window 
window.sayName();// "Greg"

// call in the scope of another object let o = new Object();
Person.call(o, "Kristen", 25, "Nurse"); o.sayName(); // "Kristen"

function Person(name, age, job){ this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = sayName;
}
function sayName() { 
  console.log(this.name);
}
let person1 = new Person("Nicholas", 29, "Software Engineer"); 
let person2 = new Person("Greg", 27, "Doctor");
person1.sayName(); // Nicholas 
person2.sayName(); // Greg

let Person = function() {};
Person.prototype.name = "Nicholas"; 
Person.prototype.age = 29; 
Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function() {
  console.log(this.name); };
let person1 = new Person(); 
person1.sayName(); // "Nicholas"

let person2 = new Person();
person2.sayName(); // "Nicholas"

console.log(person1.sayName == person2.sayName); // true

'constructor' in obj; // true
'__proto__' in obj; // true
'hasOwnProperty' in obj; // true

obj.hasOwnProperty('constructor'); // false
obj.hasOwnProperty('__proto__'); // false
obj.hasOwnProperty('hasOwnProperty'); // false

function SuperType() { 
  this.property = true;
}
SuperType.prototype.getSuperValue = function() { 
  return this.property;
};
function SubType() { 
  this.subproperty = false;
}
// inherit from SuperType 
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function () { 
  return this.subproperty;
};
let instance = new SubType();
console.log(instance.getSuperValue()); // true

console.log(instance instanceof Object); // true 
console.log(instance instanceof SuperType); // true 
console.log(instance instanceof SubType); // true

console.log(Object.prototype.isPrototypeOf(instance)); // true 
console.log(SuperType.prototype.isPrototypeOf(instance)); // true 
console.log(SubType.prototype.isPrototypeOf(instance)); // true

function SuperType() { 
  this.property = true;
}
SuperType.prototype.getSuperValue = function() { 
  return this.property;
};
function SubType() { 
  this.subproperty = false;
}

// inherit from SuperType 
SubType.prototype = new SuperType();

// new method
SubType.prototype.getSubValue = function () {
  return this.subproperty; 
};

// override existing method 
SubType.prototype.getSuperValue = 
function () {
  return false; 
};

let instance = new SubType(); console.log(instance.getSuperValue()); // false

function SuperType() {
  this.colors = ["red", "blue","green"];
}
function SubType() {
	// inherit from SuperType
	SuperType.call(this);
}

let instance1 = new SubType(); 
instance1.colors.push("black");
console.log(instance1.colors);	// "red,blue,green,black"

let instance2 = new SubType();
console.log(instance2.colors);	// "red,blue,green"

function SuperType(name){ 
  this.name = name;
}
function SubType() {
	// inherit from SuperType passing in an argument 
  SuperType.call(this, "Nicholas");
	
  // instance property
	this.age = 29; 
}

let instance = new SubType();
console.log(instance.name); // "Nicholas"; 
console.log(instance.age); // 29

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {

    Parent.call(this, name);
    
    this.age = age;

}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

var child1 = new Child('kevin', '18');

child1.colors.push('black');

console.log(child1.name); // kevin
console.log(child1.age); // 18
console.log(child1.colors); // ["red", "blue", "green", "black"]

var child2 = new Child('daisy', '20');

console.log(child2.name); // daisy
console.log(child2.age); // 20
console.log(child2.colors); // ["red", "blue", "green"]

function object(o) { 
  function F() {} F.prototype = o; 
  return new F();
}

let person = {
  name: "Nicholas",
  friends: ["Shelby", "Court", "Van"]
};
let anotherPerson = object(person);
anotherPerson.name = "Greg"; 
anotherPerson.friends.push("Rob");

let yetAnotherPerson = object(person); 
yetAnotherPerson.name = "Linda"; yetAnotherPerson.friends.push("Barbie");

console.log(person.friends); // "Shelby,Court,Van,Rob,Barbie"

function createObj (o) {
    var clone = Object.create(o);
    clone.sayName = function () {
        console.log('hi');
    }
    return clone;
}

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}

Child.prototype = new Parent();

var child1 = new Child('kevin', '18');

console.log(child1)

Child.prototype = new Parent();

var child1 = new Child('kevin', '18');

Parent.call(this, name);

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}

// 关键的三步
var F = function () {};

F.prototype = Parent.prototype;

Child.prototype = new F();


var child1 = new Child('kevin', '18');

console.log(child1);

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

function prototype(child, parent) {
    var prototype = object(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}

// 当我们使用的时候：
prototype(Child, Parent);

// class declaration 
class Person {}
// class expression 
const Animal = class {};

console.log(FunctionExpression); // undefined 
var FunctionExpression = function() {};
console.log(FunctionExpression); // function() {}

console.log(FunctionDeclaration); // FunctionDeclaration() {}
function FunctionDeclaration() {} console.log(FunctionDeclaration); // FunctionDeclaration() {}

console.log(ClassExpression); 		// undefined
var ClassExpression = class {}; 
console.log(ClassExpression);			// class {}

console.log(ClassDeclaration); 		// ReferenceError: ClassDeclaration is not defined
class ClassDeclaration {} 
console.log(ClassDeclaration);		// class ClassDeclaration {}

// Valid empty class definition 
class Foo {}

// Valid class definition with constructor 
class Bar {
  constructor() {} 
}

// Valid class definition with getter 
class Baz {
  get myBaz() {}
}

// Valid class definition with static method 
class Qux {
  static myQux() {} 
}

class Animal {}
class Person { 
  constructor() {
  console.log('person ctor'); }
}
class Vegetable { 
  constructor() {
    this.color = 'orange'; 
  }
}

let a = new Animal();
let p = new Person(); // person ctor

let v = new Vegetable(); 
console.log(v.color); // orange

class Person {}
console.log(Person); // class Person {} 
console.log(typeof Person); // function

class Person{}
console.log(Person.prototype); // { constructor: f() } 
console.log(Person === Person.prototype.constructor); // true

class Person {}
let p1 = new Person();
console.log(p1.constructor === Person); // true 
console.log(p1 instanceof Person); // true 
console.log(p1 instanceof Person.constructor); // false

let p2 = new Person.constructor(); 
console.log(p2.constructor === Person); // false
console.log(p2 instanceof Person); // false 
console.log(p2 instanceof Person.constructor); // true

class Person { 
  constructor() {
// For this example, define a string with object wrapper // as to check object equality between instances below 
    this.name = new String('Jack');
    this.sayName = () => console.log(this.name);
    this.nicknames = ['Jake', 'J-Dog'] }
}
let p1 = new Person(), 
    p2 = new Person();

p1.sayName(); // Jack 
p2.sayName(); // Jack

console.log(p1.name === p2.name); 
console.log(p1.sayName === p2.sayName); 
console.log(p1.nicknames === p2.nicknames); // false

p1.name = p1.nicknames[0]; 
p2.name = p2.nicknames[1];

p1.sayName(); // Jake 
p2.sayName(); // J-Dog

class Person { 
  name: 'Jake'
}
// Uncaught SyntaxError: Unexpected token :

class Person {
  set name(newName) { 
    this.name_ = newName;
  }
  get name() {
    return this.name_;
  }
}
let p = new Person();
p.name = 'Jake'; 
console.log(p.name); // Jake

class Person { 
  constructor() {
// Everything added to 'this' will exist on each individual instance
    this.locate = () => console.log('instance', this); }
// Defined on the class prototype object locate() {
  console.log('prototype', this); }
// Defined on the class
  static locate() { 
    console.log('class', this);
  }
}

let p = new Person();

p.locate(); // instance, Person {} 
Person.prototype.locate(); // prototype, {constructor: ... } 
Person.locate(); // class, class Person {}

class Person { 
  sayName() {
    console.log('${Person.greeting} ${this.name}'); 
  }
}
// Define data member on class 
Person.greeting = 'My name is';

// Define data member on prototype 
Person.prototype.name = 'Jake';

let p = new Person(); 
p.sayName(); // My name is Jake

class Person { 
  constructor() {
    this.nicknames = ['Jack', 'Jake', 'J-Dog']; 
  }
    *[Symbol.iterator]() {
      yield *this.nicknames.entries();
  }
}
let p = new Person();
for (let [idx, nickname] of p) {console.log(nickname); }
// Jack // Jake // J-Dog

class Vehicle {}

// Inherit from class
class Bus extends Vehicle {}

let b = new Bus();
console.log(b instanceof Bus); // true 
console.log(b instanceof Vehicle); // true

function Person() {}

// Inherit from function constructor 
class Engineer extends Person {}

let e = new Engineer();
console.log(e instanceof Engineer); // true 
console.log(e instanceof Person); // true

class Vehicle { 
  constructor() {
    this.hasEngine = true; }
}

class Bus extends Vehicle { 
  constructor() {
// Cannot reference 'this' before super(), will throw ReferenceError 
    super(); // same as super.constructor()
    console.log(this instanceof Vehicle); // true
    console.log(this); // Bus { hasEngine: true } 
  }
}

new Bus();

// Abstract base class 
class Vehicle {
  constructor() { 
    console.log(new.target);
  	if (new.target === Vehicle) {
    	throw new Error('Vehicle cannot be directly instantiated'); 
    }
	} 
}

// Derived class
class Bus extends Vehicle {}

new Bus(); // class Bus {}
new Vehicle(); // class Vehicle {}
// Error: Vehicle cannot be directly instantiated

class SuperArray extends Array { 
  shuffle() {
// Fisher-Yates shuffle
    for (let i = this.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [this[i], this[j]] = [this[j], this[i]]; }
  } 
}

let a= new SuperArray(1, 2, 3, 4, 5);

console.log(a instanceof Array); // true 
console.log(a instanceof SuperArray); // true

console.log(a); // [1, 2, 3, 4, 5] 
a.shuffle();
console.log(a); // [3, 1, 4, 5, 2]