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

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

1'use strict'; //进入严格模式

1// preferred
2if (test) {
3  console.log(test);
4}

1var message = 'hi';
2message = 100; // legal, but not recommended

1function test() {
2  var message = 'hi'; // local variable
3}
4test();
5console.log(message); // error!
6
7function test() {
8  message = 'hi'; // global variable
9}
10test();
11console.log(message); // "hi"

1function foo() {
2  console.log(age);
3  var age = 26;
4}
5foo(); // undefined

1function foo() {
2  var age;
3  console.log(age);
4  age = 26;
5}
6foo(); // undefined

1if (true) {
2  var name = 'Matt';
3  console.log(name); // Matt
4}
5console.log(name); // Matt
6
7if (true) {
8  let age = 26;
9  console.log(age); //26
10}
11console.log(age); // ReferenceError: age is not defined

1var name;
2var name;
3let age;
4let age; // SyntaxError; identifier 'age' has already been declared

1// name is hoisted
2console.log(name); // undefined
3var name = 'Matt';
4
5// age is not hoisted
6console.log(age); //ReferenceError: age is not defined
7let age = 26;

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

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

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

1let message;
2console.log(message == undefined); // true
3console.log(typeof age); // "undefined"
4
5if (message) {
6  //undefined is falsy
7  // This block will not execute
8}

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

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

1let intNum = 55; // integer
2
3let octalNum1 = 070; // octal for 56
4
5let hexNum1 = 0xa; // hexadecimal for 10

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

1var minNumber = Number.MIN_VALUE;
2var maxNumber = Number.MAX_VALUE;
3
4console.log(isFinite(minNumber + maxNumber)); // false

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

1let num1 = parseInt('1234blue'); // 1234
2
3let num = parseInt('0xAF', 16);
4let num1 = parseInt('AF', 16); // 175 十六进制转为十进制
5let num2 = parseInt('AF'); // NaN

1let firstName = 'John';
2let lastName = 'Jacob';
3let lastName = `Jingleheimerschmidt`;

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

1let num = 10;
2console.log(num.toString()); // "10"
3console.log(num.toString(2)); // "1010"
4console.log(num.toString(8)); // "12"
5console.log(num.toString(10)); // "10"
6console.log(num.toString(16)); // "a"

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

1let value = 5;
2let exponent = 'second'; // Formerly, interpolation was accomplished as follows:
3let interpolatedString = value + ' to the ' + exponent + ' power is ' + value * value;
4
5// The same thing accomplished with template literals:
6let interpolatedTemplateLiteral = `${value} to the ${exponent} power is ${value * value}`;

1let a = 6;
2let b = 9;
3function simpleTag(strings, ...expressions) {
4  console.log(strings);
5  for (const expression of expressions) {
6    console.log(expression);
7  }
8  return 'foobar';
9}
10let taggedResult = simpleTag`${a} + ${b} = ${a + b}; `;
11//[""," + "," = ",""]
12// 6
13// 9
14// 15

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

1let fooGlobalSymbol = Symbol.for('foo');
2console.log(typeof fooGlobalSymbol); // "object"
3
4let globalSymbol = Symbol.for('foo');
5console.log(localSymbol === globalSymbol); // false

1let o = new Object();

1let oldValue = 64; // equal to binary 1000000
2let newValue = oldValue >>> 5; // equal to binary 10 which is decimal 2
3
4let oldValue = -64; // equal to binary 11111111111111111111111111000000
5let newValue = oldValue >>> 5; // equal to decimal 134217726

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

1let result = 'Brick' < 'alphabet'; // true
2
3let result = '23' < 3; // false
4
5let result1 = NaN < 3; // false
6let result2 = NaN >= 3; // false

1variable = boolean_expression ? true_value : false_value;

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

1var obj = { a: 1, b: 2, c: 3 };
2
3for (var prop in obj) {
4  console.log('obj.' + prop + ' = ' + obj[prop]);
5}
6
7// Output:
8// "obj.a = 1"
9// "obj.b = 2"
10// "obj.c = 3"

1const array1 = ['a', 'b', 'c'];
2
3for (const element of array1) {
4  console.log(element);
5}
6
7// expected output: "a"
8// expected output: "b"
9// expected output: "c"

1let person = new Object();
2person.name = 'Nicholas';
3console.log(person.name); // "Nicholas"
4
5let name = 'Nicholas';
6name.age = 27;
7console.log(name.age); // undefined

1function addTen(num) {
2  num += 10;
3  return num;
4}
5let count = 20;
6let result = addTen(count);
7console.log(count); // 20 - no change
8console.log(result); // 30
9
10function setName(obj) {
11  obj.name = 'Nicholas';
12}
13let person = new Object();
14setName(person);
15console.log(person.name); // "Nicholas"

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

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

1let person = new Object(); //use new()
2person.name = 'Nicholas';
3person.age = 29;
4
5let person = {
6  //use object literal notation
7  name: 'Nicholas', //"name":"Nicholas" is the same
8  age: 29,
9};
10
11let person = {}; // same as new Object()
12person.name = 'Nicholas';
13person.age = 29;

1/*the first way*/
2let colors = new Array();
3let colors = new Array(20); // creates an array with an initial length value of 20
4let colors = new Array('red', 'blue', 'green'); // creates an array with three string values
5
6/*the second way []*/
7let colors = ['red', 'blue', 'green']; // Creates an array with three strings
8let names = []; // Creates an empty array

1alert(Array.from('Matt')); // ["M", "a", "t", "t"]
2
3alert(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] convert the list of arguments into an array.

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

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

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

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

1const zeroes = [0, 0, 0, 0, 0];
2
3// Fill the entire array with 5
4zeroes.fill(5);
5alert(zeroes); // [5, 5, 5, 5, 5]
6zeroes.fill(0); // reset
7
8// Fill all indices >=3 with 6 zeroes.fill(6, 3);
9alert(zeroes); // [0, 0, 0, 6, 6]
10zeroes.fill(0); // reset
11
12// Fill all indices >= 1 and < 3 with 7
13zeroes.fill(7, 1, 3);
14alert(zeroes); // [0, 7, 7, 0, 0];
15zeroes.fill(0); // reset
16
17// Fill all indices >=1 and < 4 with 8 // (-4 + zeroes.length = 1)
18// (-1 + zeroes.length = 4)
19zeroes.fill(8, -4, -1);
20alert(zeroes); // [0, 8, 8, 8, 0];

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

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

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

1let colors = ['red', 'green', 'blue'];
2let colors2 = colors.concat('yellow', ['black', 'brown']);
3alert(colors); // ["red", "green","blue"]
4alert(colors2); // ["red", "green", "blue", "yellow", "black", "brown"]
5
6let colors = ['red', 'green', 'blue'];
7colors[Symbol.isConcatSpreadable] = false;
8let colors2 = colors.concat('yellow', ['black', 'brown']);
9alert(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"],]

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

1let colors = ['red', 'green', 'blue'];
2let removed = colors.splice(0, 1); // remove the first item
3alert(colors); // green,blue
4alert(removed); // red - one item array
5
6removed = colors.splice(1, 0, 'yellow', 'orange'); // insert two items at position 1
7alert(colors); // green,yellow,orange,blue
8alert(removed); // empty array

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

1const people = [
2  {
3    name: 'Matt',
4    age: 27,
5  },
6  {
7    name: 'Nicholas',
8    age: 29,
9  },
10];
11alert(people.find((element, index, array) => element.age < 28)); // {name: "Matt", age: 27}
12alert(people.findIndex((element, index, array) => element.age < 28)); // 0

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

1const buf = new ArrayBuffer(16);
2// DataView default to use the entire ArrayBuffer
3const fullDataView = new DataView(buf);
4alert(fullDataView.byteOffset); // 0
5alert(fullDataView.byteLength); // 16
6alert(fullDataView.buffer === buf); // true
7
8// Constructor takes an optional byte offset and byte length
9// byteOffset=0 begins the view at the start of the buffer
10// byteLength=8 restricts the view to the first 8 bytes
11const firstHalfDataView = new DataView(buf, 0, 8);
12alert(firstHalfDataView.byteOffset); // 0
13alert(firstHalfDataView.byteLength); // 8
14alert(firstHalfDataView.buffer === buf); // true
15
16// DataView will use the remainder of the buffer unless specified
17// byteOffset=8 begins the view at the 9th byte of the buffer
18// byteLength default is the remainder of the buffer
19const secondHalfDataView = new DataView(buf, 8);
20alert(secondHalfDataView.byteOffset); // 8
21alert(secondHalfDataView.byteLength); // 8
22alert(secondHalfDataView.buffer === buf); // true

1// Allocate two bytes of memory and declare a DataView
2const buf = new ArrayBuffer(2);
3const view = new DataView(buf);
4// Demonstrate that the entire buffer is indeed all zeroes
5// Check the first and second byte
6alert(view.getInt8(0)); // 0
7alert(view.getInt8(1)); // 0
8// Check the entire buffer
9alert(view.getInt16(0)); // 0
10
11// Set the entire buffer to ones
12// 255 in binary is 11111111 (2^8 – 1)
13view.setUint8(0, 255);

1// Allocate two bytes of memory and declare a DataView
2const buf = new ArrayBuffer(2);
3const view = new DataView(buf);
4
5// Fill the buffer so that the first bit and last bit are 1
6view.setUint8(0, 0x80); // Sets leftmost bit to 1
7view.setUint8(1, 0x01); // Sets rightmost bit to 1
8
9// Buffer contents (spaced for readability):
10// 0x8 0x0 0x0 0x1
11// 1000 0000 0000 0001
12
13// Read a big-endian Uint16
14// 0x80 is the high byte, 0x01 is the low byte
15// 0x8001 = 2^15 + 2^0 = 32768 + 1 = 32769
16alert(view.getUint16(0)); // 32769
17
18// Read a little-endian Uint16
19// 0x01 is the high byte, 0x80 is the low byte
20// 0x0180 = 2^8 + 2^7 = 256 + 128 = 384
21alert(view.getUint16(0, true)); // 384

1const buf = new ArrayBuffer(6);
2const view = new DataView(buf);
3
4// Attempt to get a value past the end of the buffer
5view.getInt32(8); // RangeError

1const m = new Map();
2
3// Initialize map with nested arrays
4const m1 = new Map([
5  ['key1', 'val1'],
6  ['key2', 'val2'],
7  ['key3', 'val3'],
8]);
9alert(m1.size); // 3

1const m = new Map();
2alert(m.has('firstName')); // false
3alert(m.get('firstName ')); // undefined
4alert(m.size); // 0
5
6m.delete('firstName'); // deletes only this key/value pair

1const m = new Map();
2const functionKey = function () {};
3const symbolKey = Symbol();
4const objectKey = new Object();
5m.set(functionKey, 'functionValue');
6m.set(symbolKey, 'symbolValue');
7m.set(objectKey, 'objectValue');

1const m = new Map([
2  ['key1', 'val1'],
3  ['key2', 'val2'],
4  ['key3', 'val3'],
5]);
6alert(m.entries === m[Symbol.iterator]); // true
7
8for (let pair of m.entries()) {
9  alert(pair);
10}
11// [key1,val1]
12// [key2,val2]
13// [key3,val3]
14
15for (let pair of m[Symbol.iterator]()) {
16  alert(pair);
17}
18// [key1,val1]
19// [key2,val2]
20// [key3,val3]

1const s = new Set();
2alert(s.has('Matt')); // false
3alert(s.size); // 0
4
5s.add('Matt').add('Frisbie');
6
7s.delete('Matt');

1let person = new Object();
2person.name = 'Nicholas';
3person.age = 29;
4person.job = 'Software Engineer';
5person.sayName = function () {
6  console.log(this.name);
7};
8
9let person = {
10  name: 'Nicholas',
11  age: 29,
12  job: 'Software Engineer',
13  sayName() {
14    console.log(this.name);
15  },
16};

1let person = {};
2Object.defineProperty(person, 'name', {
3  writable: false,
4  value: 'Nicholas',
5});
6console.log(person.name); // "Nicholas"
7person.name = 'Greg';
8console.log(person.name); // "Nicholas"

1// Define object with pseudo-private member 'year_'
2// and public member 'edition'
3let book = {
4  year_: 2017,
5  edition: 1,
6};
7Object.defineProperty(book, 'year', {
8  get() {
9    return this.year_;
10  },
11  set(newValue) {
12    if (newValue > 2017) {
13      this.year_ = newValue;
14      this.edition += newValue - 2017;
15    }
16  },
17});
18book.year = 2018;
19console.log(book.edition); // 2