const obj = {  name: 'obj',  getName: function() {    return function() {      return this.name;    }  }}
const fn = obj.getName();fn();

const obj = {  name: 'obj',  getName: function() {    return () => {       return this.name;    }  }}

function createCounter() {  let count = 0;  return function() {    return count++;   }} 
const counter1 = createCounter();const counter2 = createCounter();counter1(); // 1counter1(); // 2 counter2(); // 1

class MyPromise {  constructor(executor) {    this._state = "pending";    this._value = undefined;    this._reason = undefined;    this._onFulfilledCallbacks = [];    this._onRejectedCallbacks = [];
    executor(this.resolve.bind(this), this.reject.bind(this));  }  resolve(value) {    if (this._state !== "pending") {      return;    }    this._state = "fulfilled";    this._value = value;    setTimeout(() => {      for (const callback of this._onFulfilledCallbacks) {        callback(value);      }    });  }  reject(reason) {    if (this._state !== "pending") {      return;    }    this._state = "rejected";    this._reason = reason;    setTimeout(() => {      for (const callback of this._onRejectedCallbacks) {        callback(reason);      }    });  }  then(onFulfilled, onRejected) {    return new MyPromise((resolve, reject) => {      if (this._state === "pending") {        this._onFulfilledCallbacks.push((value) => {          setTimeout(() => {            try {              const result = onFulfilled(value);              resolve(result);            } catch (error) {              reject(error);            }          });        });        this._onRejectedCallbacks.push((reason) => {          setTimeout(() => {            try {              const result = onRejected(reason);              resolve(result);            } catch (error) {              reject(error);            }          });        });      } else {        setTimeout(() => {          try {            if (this._state === "fulfilled") {              const result = onFulfilled(this._value);              resolve(result);            } else {              const result = onRejected(this._reason);              resolve(result);            }          } catch (error) {            reject(error);          }        });      }    });  }  catch(onRejected) {    return this.then(null, onRejected);  }  isFulfilled() {    return this._state === "fulfilled";  }  isRejected() {    return this._state === "rejected";  }}

class Person {  constructor(name) {    this.name = name;  }
  sayHi() {    console.log(`Hello ${this.name}`)  }}
class People extends Person {  constructor(name) {    super(name);  }  method() {    console.log('people method')  }}const people = new People('John')people.sayHi() // Hello Johnpeople.method() // people method

ajax('/api/users', {  method: 'GET'  }).then(data => {  console.log(data)})

function ajax(url, options) {  return new Promise((resolve, reject) => {    const xhr = new XMLHttpRequest();    const method = options.method || 'GET';    const headers = options.headers || {};    const body = options.body || null;    const timeout = options.timeout || 0;
    xhr.open(method, url);    xhr.onload = () => {      if (xhr.status >= 200 && xhr.status < 300) {        resolve(xhr.response);      } else {        reject(new Error(xhr.statusText));      }    };    xhr.onerror = () => reject(xhr.error);    xhr.ontimeout = () => reject(new Error('Request timeout'));    xhr.timeout = timeout;    for (const [header, value] of Object.entries(headers)) {      xhr.setRequestHeader(header, value);    }    xhr.send(body);  });}

jsonp('/api/data', {  params: {    name: 'jsonp'  }  })

function jsonp(url, options) {  return new Promise((resolve, reject) => {    const script = document.createElement('script');    const callbackName = `jsonpCallback_${Date.now()}_${Math.floor(Math.random() * 10000)}`;    const timer = setTimeout(() => {      cleanup();      reject(new Error('JSONP request timeout'));    }, options.timeout || 5000);    function cleanup() {      delete window[callbackName];      clearTimeout(timer);      script.remove();    }    window[callbackName] = function(data) {      cleanup();      resolve(data);    };    options.params = options.params || {};    options.params['callback'] = callbackName;    const paramsArr = Object.keys(options.params).map(key => {      return `${encodeURIComponent(key)}=${encodeURIComponent(options.params[key])}`;    });    script.src = `${url}?${paramsArr.join('&')}`;    script.onerror = () => {      cleanup();      reject(new Error('JSONP request error'));    };    document.body.appendChild(script);  });}

function deepClone(source, clonedMap) {  clonedMap = clonedMap || new Map();
  if (source === null || typeof source !== 'object') {    return source;  }  if (clonedMap.has(source)) {    return clonedMap.get(source);  }  var result;  var type = getType(source);  if (type === 'object' || type === 'array') {    result = type === 'array' ? [] : {};    clonedMap.set(source, result);    for (var key in source) {      if (source.hasOwnProperty(key)) {        result[key] = deepClone(source[key], clonedMap);      }    }  } else {    result = source;  }  return result;}function getType(source) {  return Object.prototype.toString    .call(source)    .replace(/^\[object (.+)\]$/, '$1')    .toLowerCase();}const obj = {  a: 1,  b: {    c: 2  }}const clone = deepClone(obj)

function add() {     // When executing for the first time, define an array specifically to store all parameters     var _args = [].slice.call(arguments);
     // Declare a function internally, use the characteristics of closure to save _args and collect all parameter values     var adder = function () {         var _adder = function() {             // [].push.apply(_args, [].slice.call(arguments));             _args.push(...arguments);             return _adder;         };         //Using the characteristics of implicit conversion, implicit conversion is performed when it is finally executed, and the final value is calculated and returned.         _adder.toString = function () {             return _args.reduce(function (a, b) {                 return a + b;             });         }         return _adder;     }     // return adder.apply(null, _args);     return adder(..._args);}var a = add(1)(2)(3)(4); // f 10var b = add(1, 2, 3, 4); // f 10var c = add(1, 2)(3, 4); // f 10var d = add(1, 2, 3)(4); // f 10// You can use the characteristics of implicit conversion to participate in calculationsconsole.log(a + 10); // 20console.log(b + 20); // 30console.log(c + 30); // 40console.log(d + 40); // 50// You can also continue to pass in parameters, and the result will be calculated using implicit conversion again.console.log(a(10) + 100); // 120console.log(b(10) + 100); // 120console.log(c(10) + 100); // 120console.log(d(10) + 100); // 120//In fact, the add method in Shangli is the curried function of the following function, but we do not use the general formula to convert, but encapsulate it ourselves.function add(...args) {     return args.reduce((a, b) => a + b);}

myAll([  myPromise1,   myPromise2]).then(([res1, res2]) => {  //...})

function myAll(promises) {  return new Promise((resolve, reject) => {    const result = new Array(promises.length);    let count = 0;    promises.forEach((p, index) => {      p.then(res => {        result[index] = res;        count++;        if (count === promises.length) {          resolve(result);        }      })      .catch(reject);    });  });}

function instanceof(left, right) {  if (arguments.length !== 2) {    throw new Error("instanceof requires exactly two arguments.");  }  if (left === null) {    return false;  }  if (typeof left !== "object") {    return false;  }  let proto = Object.getPrototypeOf(left);  while (proto !== null) {    if (right.prototype === proto) {      return true;    }    proto = Object.getPrototypeOf(proto);  }  return false;}

function debounce(fn, delay = 500) {   let timer;
   return function(...args) {     clearTimeout(timer);     timer = setTimeout(() => {       fn.apply(this, args);     }, delay);     // Return to clear function     return () => {       clearTimeout(timer);     }   }}// useconst debouncedFn = debounce(fn, 1000);const cancel = debouncedFn();// clearcancel();