Array.prototype.quick_sort = function() {
	var len = this.length;
	if (len <= 1) {
                return this.slice(0);
        }
	var left = [];
	var right = [];
	var mid = [this[0]];
	for (var i = 1; i < len; i++) {
                if (this[i] < mid[0]) {
                    left.push(this[i]);
                } else {
                    right.push(this[i]);
                }	
        }
	return left.quick_sort().concat(mid.concat(right.quick_sort()));
};

function Foo() {
    getName = function () { alert (1); };
    return this;
}
Foo.getName = function () { alert (2);};
Foo.prototype.getName = function () { alert (3);};
var getName = function () { alert (4);};
function getName() { alert (5);}
 
//请写出以下输出结果：
Foo.getName();
getName();
Foo().getName();
getName();
new Foo.getName();
new Foo().getName();
new new Foo().getName();

const a = [1, 2, 3, 4, 5];
// Implement this
a.multiply();
console.log(a); // [1, 2, 3, 4, 5, 1, 4, 9, 16, 25]

Array.prototype.multiply = function () {
  return this.concat(this.map(_ => Math.pow(_, 2)))
}

// false
0.2 + 0.1 === 0.3

// GET LIST OF ALL THE STUDENTS
GET /api/students
Response:
[{
    "id": 1,
    "name": "John",
    "classroomId": 75
}]
// GET COURSES FOR GIVEN A STUDENT
GET /api/courses?filter=studentId eq 1
Response:
[{
   "id": "history",
   "studentId": 1
}, {
   "id": "algebra",
   "studentId": 1
},]
// GET EVALUATION FOR EACH COURSE
GET /api/evaluation/history?filter=studentId eq 1
Response:
{
    "id": 200,
    "score": 50,
    "totalScore": 100
}

const a = {
    key1: Symbol(),
    key2: 10
}
// What will happen?
console.log(JSON.stringify(a));

function makeAPIRequest(url, timeout = 2000, headers) {
   // Some code to fetch data
}

const arr = [1, 2, 3, 4, NaN]

// before
if (arr.indexOf(3) >= 0) {
  console.log('true')
}

// after
if (arr.includes(3)) {
  console.log('true')
}

arr.includes(NaN) // return true
arr.indexOf(NaN) // -1

// before
Math.pow(7, 2) // 49

// after
7**2 // 49

const cars = { BMW: 3, Polo: 2, Golf: 1 }

// before
const vals = Object.keys(cars).map(_ => cars[_])
console.log(vals) // [3, 2, 1]

// after
const vals = Object.values(cars)
console.log(vals) // [3, 2, 1]

const cars = { BMW: 3, Polo: 2, Golf: 1 }

// before
Object.keys(cars).forEach(key => {
  console.log(`key: ${key}, value: ${cars[key]}`)
})
// after
for (let [value, key] of Object.entries(cars)) {
  console.log(`key: ${key}, value: ${value}`)
}

const cars = { 'BMW': 3, 'Polo': 2, 'Golf': 1 }

// before
const map1 = new Map()
Object.keys(cars).forEach(key => {
  map1.set(key, cars[key])
})
console.log(map1) // Map { 'BMW' => 3, 'Polo' => 2, 'Golf' => 1 }

// after
const map = new Map(Object.entries(cars))

console.log(map) //  Map { 'BMW' => 3, 'Polo' => 2, 'Golf' => 1 }

// before
let reg = /(\d{4})-(\d{2})-(\d){2}/u;
let result = reg.exec('2018-07-37');
console.log(result)
// ["2018-07-37", "2018", "07", "7", index: 0, input: "2018-07-37", groups: undefined]

// after
let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d){2}/u;
let result = reg.exec('2018-07-37');
console.log(result)
// ["2018-07-37", "2018", "07", "7", index: 0, input: "2018-07-37", groups: {year: "2018", month: "07", day: "7"}]
console.log(result.groups.year) // 2018

let sameWords = /(?<fruit>apple|orange)===\k<fruit>/u;

sameWords.test('apple===apple'); // true
sameWords.test('orange===orange'); // true
sameWords.test('apple===orange'); // false

let reg = /(?<firstName>[A-Za-z]+) (?<lastName>[A-Za-z]+$)/u;

'Raja Rao'.replace(reg, '$<lastName>, $<firstName>'); // 'Rao, Raja'

         /**
         * 二分查找法（有序数组）
         * 
         * 时间复杂度: O(log N).
         *
         * @param {Array} array .
         * @param {Number} value.
         * @returns {Number} Index of the element or -1 if not found.
         */

         function binarySearch(array, value) {
            var middle = Math.floor(array.length / 2);
            var left = 0;
            var right = array.length;
            while (right >= left) {
              var middleValue = array[middle];
              if (middleValue === value) {
                  return middle;
              } else if (middleValue > value) {
                  right = middle - 1;
              } else {
                  left = middle + 1;
              } 
              middle = Math.floor((left + right) / 2);
            }
            return -1;
        }

function getType(obj) {
  let type = typeof obj;
  if (type !== 'object') {
    return type;
  }

  return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1');
}

> getType()
< "undefined"
> getType([])
< "Array"
> getType({})
<"Object"
> getType(1)
< "number"
> getType('')
< "string"
> getType(window)
< "Window"
> getType(document)
< "HTMLDocument"
> getType(/^a/)
< "RegExp"
> getType(() => {})
< "function"

$ npm install puppeteer --save

const puppeteer = require('puppeteer');
(async () => {
    const browser = await puppeteer.launch({
        headless: false,
    });
    const page = await browser.newPage();

    const URL = '<your target url>';
    // 可以设置一些常量
    // ...

    try {
        await page.goto(URL);
        await page.setDefaultNavigationTimeout(50000); // 设置跳转超时时间
        await page.waitFor(2000);
        // 开始爬取
        const result = await page.evaluate(() => {
            let a = document.querySelector('<your selector path>');

            return a;
        })
    } catch (err) {
        console.log('ERR:', err);
    } finally {
        browser.close();
    }
})()

$ npm install mongoose --save

const mongoose = require('mongoose');

const Schema = new mongoose.Schema({
    // �你需要的数据格式

});

module.exports = mongoose.model('DATA', Schema);

const DB_URL = '<your db url>';
if (mongoose.connection.readyState == 0) {
    mongoose.connect(DB_URL);

    //On connection
    mongoose.connection.once('open', () => {
      console.log('connected to database: ' + DB_URL);
    })

    //Error connection
    mongoose.connection.on('error', (err) => {
      console.log('database error' + err);
    })
}

try {
    let newData = new DATA(obj);
    console.log('mongoose:', newData);
    newData.save( (err, newData) => {
      if (err) throw err;
      console.log('Saved successfully');
    });
  } catch (err) {
    console.log(err);
  }

try {
        DATA.find({
            title: { $regex: arg, $options: 'i'} // 模糊查询，不区分大小写
        }, (err, datas) => {
            if (err) throw err;
            console.log(datas);
            res.send(datas);
        });
    } catch (err) {
        console.log(err);
    }

<div class="auth-block">
  <h1 style="text-align: center">登录</h1>
    <form class="form-horizontal" (submit)="onLoginSubmit()">
      <div class="form-group">
        <div class="col-sm-offset-4 col-sm-4">
          <input class="form-control" [(ngModel)]="username" name="username" placeholder="用户名">
        </div>
      </div>
      <div class="form-group">
        <div class="col-sm-offset-4 col-sm-4">
          <input type="password" class="form-control" [(ngModel)]="password" name="password" placeholder="密码">
        </div>
      </div>
      <div class="form-group">
        <div class="col-sm-offset-4 col-sm-2">
          <input type="checkbox">
          <span>记住密码</span>
        </div>
        <div class="col-sm-2">
          <a [routerLink]="['/retrieve']" style="float: right">
            <span>忘记密码？</span>
          </a>
        </div>
      </div>
      <div class="form-group">
        <div class="col-sm-offset-4 col-sm-4">
          <button type="submit" class="btn btn-primary" style="width: 100%">登录</button>
        </div>
      </div>
      <div class="form-group">
        <div class="col-sm-offset-4 col-sm-4">
          <a [routerLink]="['/register']">
            <span>还没有账号？快速注册</span>
          </a>
        </div>
      </div>
    </form>
  </div>

parentElement{
        position:relative;
    }

 childElement{
        position: absolute;
        top: 50%;
        transform: translateY(-50%);

 }

parentElement{
        height:xxx;
    }

    childElement {
      position: relative;
      top: 50%;
      transform: translateY(-50%);
    }

parentElement{
    display:flex;/*Flex布局*/
    display: -webkit-flex; /* Safari */
    align-items:center;/*指定垂直居中*/
}

var _ = require('lodash');

class Dijkstra {
  solve(graph, start, end) {

    // track costs of each node
    const costs = graph[start];

    // set end to infinite on 1st pass
    costs[end] = Infinity;

    // remember path from
    // which each node was visited
    const paths = {};

    // add path for the start nodes neighbors
    _.forEach(graph[start], (dist, city) => {
      // e.g. city SJ was visited from city SF
      paths[city] = start;
    });

    // track nodes that have already been visited nodes
    const visitedNodes = [];

    // get current nodes cheapest neighbor
    let currentCheapestNode = this.getNextLowestCostUnvisitedNode(costs, visitedNodes);

    // while node exists
    while (currentCheapestNode) {

      // get cost of reaching current cheapest node
      let costToReachCurrentNode = costs[currentCheapestNode];

      // access neighbors of current cheapest node
      let neighbors = graph[currentCheapestNode];

      // loop over neighbors
      _.forEach(neighbors, (dist, neighbor) => {

        // generate new cost to reach each neighbor
        let newCost = costToReachCurrentNode + dist;

        // if not already added
        // or if it is lowest cost amongst the neighbors
        if (!costs[neighbor] || costs[neighbor] > newCost) {

          // add cost to list of costs
          costs[neighbor] = newCost;

          // add to paths
          paths[neighbor] = currentCheapestNode;

        }

      });

      // mark as visited
      visitedNodes.push(currentCheapestNode);

      // get cheapest node for next node
      currentCheapestNode = this.getNextLowestCostUnvisitedNode(costs, visitedNodes);
    }

    // generate response
    let finalPath = [];

    // recursively go to the start
    let previousNode = paths[end];

    while (previousNode) {
      finalPath.unshift(previousNode);
      previousNode = paths[previousNode];
    }

    // add end node at the end
    finalPath.push(end);

    // return response
    return {
      distance: costs[end],
      path: finalPath
    };
  }

  getNextLowestCostUnvisitedNode(costs, visitedNodes) {
    //extract the costs of all non visited nodes
    costs = _.omit(costs, visitedNodes);

    // return the node with minimum cost
    return _.minBy(_.keys(costs), (node) => {
      return costs[node];
    });
  }
}

const graph = {
   'SF': { 'SB': 326, 'MT': 118, 'SJ': 49 },
   'SJ': { 'MT': 72, 'FR': 151, 'BK': 241 },
   'MT': { 'SB': 235, 'LA': 320 },
   'SB': { 'LA': 95 },
   'LA': { 'SD': 120 },
   'SD': { 'PX': 355 },
   'FR': { 'LV': 391 },
   'BK': { 'LA': 112, 'SD': 232, 'PX': 483, 'LV': 286 },
   'LV': { 'PX': 297 },
   'PX': {}
};

console.log(new Dijkstra().solve(graph, 'SF', 'PX'));
// { distance: 773, path: [ 'SF', 'SJ', 'BK', 'PX' ] } 

document.getElementById('#xxx').style = 'display: none';

document.getElementById('#xxx').style.display = 'none';

class Dog {
  name: string;
  constructor(name: string) {
    this.name = name;
  }

  bark() {
    console.log('Woof! Woof!');
  }
}

const dog = new Dog('Q');

dog.bark(); // => 'Woof! Woof!'

class Animal {
  type = 'Animal';
  say(name: string) {
    console.log(`I'm ${name}!`);
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof! Woof!');
  }
}

const dog = new Dog();
dog.bark(); // => 'Woof! Woof!'
dog.say('Q'); // => I'm Q!
dog.type; // => Animal

class Animal {
  weight: number;
  type = 'Animal';
  constructor(weight: number) {
    this.weight = weight;
  }

  say(name: string) {
    console.log(`I'm ${name}!`);
  }
}

class Dog extends Animal {
  name: string;
  constructor(name: string) {
    super(20);
    this.name = name;
  }

  bark() {
    console.log('Woof! Woof!');
  }
}

class Son {
  public firstName: string;
  private lastName: string = 'Stark';
  constructor(firstName: string) {
    this.firstName = firstName;
    this.lastName; // ok
  }
}

const son = new Son('Tony');
console.log(son.firstName); //  => "Tony"
son.firstName = 'Jack';
console.log(son.firstName); //  => "Jack"
console.log(son.lastName); // ts(2341) Property 'lastName' is private and only accessible within class 'Son'.

class Son {
  public firstName: string;
  protected lastName: string = 'Stark';
  constructor(firstName: string) {
    this.firstName = firstName;
    this.lastName; // ok
  }
}

class GrandSon extends Son {
  constructor(firstName: string) {
    super(firstName);
  }

  public getMyLastName() {
    return this.lastName;
  }
}

const grandSon = new GrandSon('Tony');
console.log(grandSon.getMyLastName()); // => "Stark"
grandSon.lastName; // ts(2445) Property 'lastName' is protected and only accessible within class 'Son' and its subclasses.

class Son {
  public readonly firstName: string;
  constructor(firstName: string) {
    this.firstName = firstName;
  }
}

const son = new Son('Tony');
son.firstName = 'Jack'; // ts(2540) Cannot assign to 'firstName' because it is a read-only property.

class Son {
  public firstName: string;
  protected lastName: string = 'Stark';
  constructor(firstName: string) {
    this.firstName = firstName;
  }
}

class GrandSon extends Son {
  constructor(firstName: string) {
    super(firstName);
  }

  get myLastName() {
    return this.lastName;
  }

  set myLastName(name: string) {
    if (this.firstName === 'Tony') {
      this.lastName = name;
    } else {
      console.error('Unable to change myLastName');
    }
  }
}

const grandSon = new GrandSon('Tony');
console.log(grandSon.myLastName); // => "Stark"
grandSon.myLastName = 'Rogers';
console.log(grandSon.myLastName); // => "Rogers"
const grandSon1 = new GrandSon('Tony1');
grandSon1.myLastName = 'Rogers'; // => "Unable to change myLastName"

class MyArray {
  static displayName = 'MyArray';
  static isArray(obj: unknown) {
    return Object.prototype.toString.call(obj).slice(8, -1) === 'Array';
  }
}

console.log(MyArray.displayName); // => "MyArray"
console.log(MyArray.isArray([])); // => true
console.log(MyArray.isArray({})); // => false

abstract class Adder {
  abstract x: number;
  abstract y: number;
  abstract add(): number;
  displayName = 'Adder';
  addTwice(): number {
    return (this.x + this.y) * 2;
  }
}

class NumAdder extends Adder {
  x: number;
  y: number;
  constructor(x: number, y: number) {
    super();
    this.x = x;
    this.y = y;
  }

  add(): number {
    return this.x + this.y;
  }
}

const numAdder = new NumAdder(1, 2);
console.log(numAdder.displayName); // => "Adder"
console.log(numAdder.add()); // => 3
console.log(numAdder.addTwice()); // => 6

interface IAdder {
  x: number;
  y: number;
  add: () => number;
}

class NumAdder implements IAdder {
  x: number;
  y: number;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }

  add() {
    return this.x + this.y;
  }

  addTwice() {
    return (this.x + this.y) * 2;
  }
}

class A {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

const a1: A = {}; // ts(2741) Property 'name' is missing in type '{}' but required in type 'A'.
const a2: A = { name: 'a2' }; // ok

EXIF.getData(file, function() {  
  let Orientation = EXIF.getTag(this, 'Orientation');
});

if(Orientation && Orientation != 1){
  switch(Orientation){
   case 6:     // 旋转90度
      canvas.width = imgHeight;    
      canvas.height = imgWidth;    
      ctx.rotate(Math.PI / 2);
      // (0,-imgHeight) 从旋转原理图那里获得的起始点
      ctx.drawImage(this, 0, -imgHeight, imgWidth, imgHeight);
      break;
   case 3:     // 旋转180度
      ctx.rotate(Math.PI);    
      ctx.drawImage(this, -imgWidth, -imgHeight, imgWidth, imgHeight);
      break;
   case 8:     // 旋转-90度
      canvas.width = imgHeight;    
      canvas.height = imgWidth;    
      ctx.rotate(3 * Math.PI / 2);    
      ctx.drawImage(this, -imgWidth, 0, imgWidth, imgHeight);
      break;
   default:
      ctx.drawImage(this, 0, 0, imgWidth, imgHeight);
      break;
  }
}else{
    ctx.drawImage(this, 0, 0, imgWidth, imgHeight);
}

/** 图片压缩
 * @param {Number} orient iphone & android 拍照图片方向
 * @param {Object} fileObj 图片对象
 * @param {function} cb 回调函数
 */
export function compress (orient, fileObj, cb) {
  try {
    // 压缩图片需要的一些元素和对象
    let img = new Image();

    // 缩放图片需要的canvas
    let canvas = document.createElement('canvas');
    let context = canvas.getContext('2d');
    img.src = URL.createObjectURL(fileObj);
    // base64地址图片加载完毕后
    img.onload = function () {
      // 图片原始尺寸
      let originWidth = this.width;
      let originHeight = this.height;

      if (originWidth > originHeight && originWidth > 750) {
        originWidth = 750;
        originHeight = Math.ceil(750 * this.height / this.width);
      } else if (originWidth < originHeight && originHeight > 1334) {
        originWidth = Math.ceil(1334 * this.width / this.height);
        originHeight = 1334;
      }
      let targetWidth = originWidth;
      let targetHeight = originHeight;
      // canvas对图片进行缩放
      canvas.width = targetWidth;
      canvas.height = targetHeight;
      // 清除画布
      context.clearRect(0, 0, targetWidth, targetHeight);
      if (orient && orient !== 1) {
        switch (orient) {
          case 6:
            canvas.width = targetHeight;
            canvas.height = targetWidth;
            context.rotate(Math.PI / 2);
            context.drawImage(img, 0, -targetHeight, targetWidth, targetHeight);
            break;
          case 3:
            context.rotate(Math.PI);
            context.drawImage(img, -targetWidth, -targetHeight, targetWidth, targetHeight);
            break;
          case 8:
            canvas.width = targetHeight;
            canvas.height = targetWidth;
            context.rotate(3 * Math.PI / 2);
            context.drawImage(img, -targetWidth, 0, targetWidth, targetHeight);
            break;
          default:
            context.drawImage(img, 0, 0, targetWidth, targetHeight);
            break;
        }
      } else {
        context.drawImage(img, 0, 0, targetWidth, targetHeight);
      }
      // 图片压缩
      // context.drawImage(img, 0, 0, targetWidth, targetHeight);
      // canvas转为blob并上传
      canvas.toBlob(function (blob) {
        cb(blob);
        console.log('压缩成功 toblob ', URL.createObjectURL(blob));
      }, fileObj.type || 'image/png');
    };
  } catch (e) {
    console.log('压缩失败：', e)
  }
}

import { compress } from './compress.js'

handlePictureCardPreview(file) {
        compress(file.raw, function(val) {
          console.log('success.....', URL.createObjectURL(val))
          let formdata = new FormData();
          formdata.append('file', val);
          // 图片ajax上传
          let xhr = new XMLHttpRequest();
          // 文件上传成功
          xhr.onreadystatechange = function() {
            if (xhr.status == 200) {
              // xhr.responseText就是返回的数据
              console.log('response data: ', xhr.responseText)
            }
          };
          // 开始上传
          xhr.open("POST", "xxxxxx", true);
          xhr.send(formdata);
       })
},
beforeAvatarUpload(file) {
        const isJPG = file.type === 'image/png' || file.type === 'image/gif' || file.type === 'image/jpg' || file.type === 'image/jpeg';
        const isLt10M = file.size / 1024 / 1024 < 10;
        if (!isJPG) {
          this.$message.error('上传头像图片只能是 JPG,gif,png,jpeg 格式!');
        }
        if (!isLt10M) {
          this.$message.error('上传头像图片大小不能超过 10MB!');
        }
        return false;
},

let a = 'Hello World!';
function first() {
  console.log('Inside first function');
  second();
  console.log('Again inside first function');
}
function second() {
  console.log('Inside second function');
}
first();
console.log('Inside Global Execution Context');

ExecutionContext = {
  ThisBinding = <this value>,
  LexicalEnvironment = { ... },
  VariableEnvironment = { ... },
}

let foo = {
  baz: function() {
  console.log(this);
  }
}
foo.baz();    // 'this' refers to 'foo', because 'baz' was called 
             // with 'foo' object reference
let bar = foo.baz;
bar();       // 'this' refers to the global window object, because
             // no object reference was given

GlobalExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // Identifier bindings go here
    }
    outer: <null>
  }
}
FunctionExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // Identifier bindings go here
    }
    outer: <Global or outer function environment reference>
  }
}

let a = 20;
const b = 30;
var c;
function multiply(e, f) {
 var g = 20;
 return e * f * g;
}
c = multiply(20, 30);

GlobalExectionContext = {
  ThisBinding: <Global Object>,
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // Identifier bindings go here
      a: < uninitialized >,
      b: < uninitialized >,
      multiply: < func >
    }
    outer: <null>
  },
  VariableEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // Identifier bindings go here
      c: undefined,
    }
    outer: <null>
  }
}
FunctionExectionContext = {
 
  ThisBinding: <Global Object>,
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // Identifier bindings go here
      Arguments: {0: 20, 1: 30, length: 2},
    },
    outer: <GlobalLexicalEnvironment>
  },
VariableEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // Identifier bindings go here
      g: undefined
    },
    outer: <GlobalLexicalEnvironment>
  }
}

/**
*   base64 base64
*   filename 转换后的文件名
*/
base64ToFile = (base64, filename )=> {
  let arr = base64.split(',')
  let mime = arr[0].match(/难过.*?);/)[1]
  let suffix = mime.split('/')[1] // 图片后缀
  let bstr = atob(arr[1])
  let n = bstr.length
  let u8arr = new Uint8Array(n)
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n)
  }
  return new File([u8arr], `${filename}.${suffix}`, { type: mime })
}

base64ToBlob = base64 => {
  let arr = base64.split(','),
    mime = arr[0].match(/:(.*?);/)[1],
    bstr = atob(arr[1]),
    n = bstr.length,
    u8arr = new Uint8Array(n);
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n);
  }
  return new Blob([u8arr], { type: mime });
};

blobToFile = (blob, fileName) => {
  blob.lastModifiedDate = new Date();
  blob.name = fileName;
  return blob;
};

/**
 * file 图片文件
 * 返回图片的Base64数据
 */
fileToBase64 = file => {
  let reader = new FileReader();
  reader.readAsDataURL(file);
  reader.onload = function (e) {
    return e.target.result
  };
}

    (function () {
      var viewportTag = null;
      var metaTags = document.getElementsByTagName('meta');
      for (var i = 0; i < metaTags.length; i++) {
          if (metaTags[i].getAttribute('name') === "viewport") {
              viewportTag = metaTags[i];
              break;
          }
      }
      if (!viewportTag) {
          viewportTag = document.createElement("meta");
          viewportTag.setAttribute('name', 'viewport');
      }
      
      var viewportTagContent = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=0';
      
      // Detect if iOS device
      if (/(iPhone|iPod|iPad)/i.test(window.navigator.userAgent)) {
        // Get iOS major version
        var iosVersion = parseInt((window.navigator.userAgent).match(/OS (\d+)_(\d+)_?(\d+)? like Mac OS X/i)[1]);
        // Detect if device is running >iOS 11
        // iOS 11's UIWebView and WKWebView changes the viewport behaviour to render viewport without the status bar. Need to override with "viewport-fit: cover" to include the status bar.
        if (iosVersion >= 11) {
          viewportTagContent += ', viewport-fit=cover';
        }
      }
      
      // Update viewport tag attribute
      viewportTag.setAttribute('content', viewportTagContent);
    })()

firstLoop: 
for (let i = 0; i < 3; i++) { 
   for (let j = 0; j < 3; j++) {
      if (i === j) {
         continue firstLoop; // 继续 firstLoop 循环
         // break firstLoop; // 中止 firstLoop 循环
      }
      console.log(`i = ${i}, j = ${j}`);
   }
}
// 输出
i = 1, j = 0
i = 2, j = 0
i = 2, j = 1
 
for (let i = 0; i < 3; i++) { 
   for (let j = 0; j < 3; j++) {
      if (i === j) {
         continue 
      }
      console.log(`i = ${i}, j = ${j}`);
   }
}
// 输出
i = 0, j = 1
i = 0, j = 2
i = 1, j = 0
i = 1, j = 2
i = 2, j = 0
i = 2, j = 1

let a = 'global';
  function outer() {
    let b = 'outer';
    function inner() {
      let c = 'inner'
      console.log(c);   // prints 'inner'
      console.log(b);   // prints 'outer'
      console.log(a);   // prints 'global'
    }
    console.log(a);     // prints 'global'
    console.log(b);     // prints 'outer'
    inner();
  }
outer();
console.log(a);         // prints 'global'

Global {
  outer {
    inner
  }
}

function person() {
  let name = 'Peter';
  
  return function displayName() {
    console.log(name);
  };
}
let peter = person();
peter(); // prints 'Peter'

function getCounter() {
  let counter = 0;
  return function() {
    return counter++;
  }
}
let count = getCounter();
console.log(count());  // 0
console.log(count());  // 1
console.log(count());  // 2

lexicalEnvironment = {
  environmentRecord: {
    <identifier> : <value>,
    <identifier> : <value>
  }
  outer: < Reference to the parent lexical environment>
}

let a = 'Hello World!';
function first() {
  let b = 25;  
  console.log('Inside first function');
}
first();
console.log('Inside global execution context');

globalLexicalEnvironment = {
  environmentRecord: {
      a     : 'Hello World!',
      first : < reference to function object >
  }
  outer: null
}

functionLexicalEnvironment = {
  environmentRecord: {
      b    : 25,
  }
  outer: <globalLexicalEnvironment>
}

function person() {
  let name = 'Peter';
  
  return function displayName() {
    console.log(name);
  };
}
let peter = person();
peter(); // prints 'Peter'

personLexicalEnvironment = {
  environmentRecord: {
    name : 'Peter',
    displayName: < displayName function reference>
  }
  outer: <globalLexicalEnvironment>
}

displayNameLexicalEnvironment = {
  environmentRecord: {
    
  }
  outer: <personLexicalEnvironment>
}

function getCounter() {
  let counter = 0;
  return function() {
    return counter++;
  }
}
let count = getCounter();
console.log(count());  // 0
console.log(count());  // 1
console.log(count());  // 2

getCounterLexicalEnvironment = {
  environmentRecord: {
    counter: 0,
    <anonymous function> : < reference to function>
  }
  outer: <globalLexicalEnvironment>
}

countLexicalEnvironment = {
  environmentRecord: {
  
  }
  outer: <getCountLexicalEnvironment>
}

getCounterLexicalEnvironment = {
  environmentRecord: {
    counter: 1,
    <anonymous function> : < reference to function>
  }
  outer: <globalLexicalEnvironment>
}