JavaScript Snippets ​

Date.prototype.format = function (format) {
    let o = {
        "M+": this.getMonth() + 1, //month
        "d+": this.getDate(), //day
        "h+": this.getHours(), //hour
        "m+": this.getMinutes(), //minute
        "s+": this.getSeconds(), //second
        "q+": Math.floor((this.getMonth() + 3) / 3), //quarter
        "S": this.getMilliseconds() //millisecond
    }
    if (/(y+)/.test(format))
        format = format.replace(RegExp.$1, (this.getFullYear() + "")
            .substr(4 - RegExp.$1.length));
    for (let k in o)
        if (new RegExp("(" + k + ")").test(format))
            format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] :
                ("00" + o[k]).substr(("" + o[k]).length));
    return format;
}

function toParams(param) {
  let result = '';
  for (let name in param) {
    if (typeof param[name] != 'function') {
      if (param[name] === null) {
        result += '&' + name + '=';
      } else {
        result += '&' + name + '=' + encodeURI(param[name]);
      }
    }
  }
  return result.substring(1);
}

function isUrl(path) {
  // 开始符 ^
  // 协议部分http(s)://        表示为((https|http|ftp|rtsp|mms)?:\/\/)
  // 域名部分                  表示为(([A-Za-z0-9]+-[A-Za-z0-9]+|[A-Za-z0-9]+)\.)+
  // 顶级域名com cn等为2-6位   表示为([a-zA-Z]{2,6})
  // 端口部分                  表示为(:\d+)?, ?表示0次或1次
  // 请求路径如/login          表示为 (\/.*)?
  // 问号传参及哈希值如?age=1   表示为 (\?.*)?和(#.*)?
  // 结束符 $
  const reg = /^((https|http|ftp|rtsp|mms)?:\/\/)(([A-Za-z0-9]+-[A-Za-z0-9]+|[A-Za-z0-9]+)\.)+([A-Za-z]{2,6})(:\d+)?(\/.*)?(\?.*)?(#.*)?$/
  return reg.test(path)
}

function isNum(str){
    return Blooean(new RegExp(/^[0-9]*$/).test(str));
}

function returnFloat(value) {
        let value = Math.round(parseFloat(value) * 100) / 100;
        let decimal = value.toString().split(".");
        if (decimal.length == 1) return value.toString() + ".00";
        if (decimal.length > 1) {
            if (decimal[1].length < 2) value = value.toString() + "0";
            return value;
        }
    }

Array.prototype._map = function(Fn) {
    if (typeof Fn !== 'function') return
    const array = this
    const newArray = new Array(array.length)
    for (let i=0; i<array.length; i++) {
        // map
        let result = Fn.call(arguments[1], array[i], i, array)
        newArray[i] = result
        // filter
        result && newArray.push(array[i])
    }
    return newArray

     // join 参数为 s = ','
    let str = ''
    for (let i=0; i<array.length; i++) {
         // forEach
         Fn.call(arguments[1], array[i], i, array);

        // every 
        if (!Fn.call(arguments[1], array[i], i, array)) return false

        // some 可优化为使用break打断循环
        if (Fn.call(arguments[1], array[i], i, array)) return true

        // find
        if (Fn.call(arguments[1], array[i], i, array)) return array[i]

        // findIndex
        if (Fn.call(arguments[1], array[i], i, array)) return i

        // join
        str = i === array.length - 1 ?  str + array[i] :  str + array[i] + s
    }
     // every
    return true
     // some
    return false
    // join
    return str
}

Array.prototype._reduce = function (callback, initValue) {
    // 判断是否是数组调用
    if (!Array.isArray(this)) throw new TypeError('not a array')
    // 数组为空 且无初始值
    if (this.length === 0 && !initValue) throw new TypeError('Reduce of empty array with no initial value')

    let arr = this, res = null
    // 若有初始值则赋值，无则取数组第一个值
    initValue ? res = initValue : res = arr[0]

    for (let i = initValue ? 0 : 1; i < arr.length; i++) {
        res = callback(res, arr[i], i, arr) // 覆盖上次计算结果
    }
    return res
}

arrayMinOrMax(arrs) {
    let extreme = arrs[0];
    for (let i = 1, ilen = arrs.length; i < ilen; i += 1) {
        // 最小
        if (arrs[i] < extreme | ) {
            extreme = arrs[i];
        }
        // 最大
        if (arrs[i] > extreme) {
            extreme = arrs[i];
        }
    }
    return extreme;
}

// 创建返回的结果数组
// 通过字符串参数创建等长的"被使用"数组用于递归过程中记录字符顺序
// 创建回溯函数，通过该函数内部递归调用
// 在回溯函数中，当临时数组的长度等于字符串参数长度时可以返回本次循环结果
// 进入字符串参数长度的循环体中，将该次字符保存在临时数组中
// 将该次字符的"被使用"数组位修改为true，表示该字符在本次之前的递归过程中已被记录使用，跳过即可
// 递归调用回溯函数
// 退栈时设置该字符"被使用"数组为false，删除临时数组最后一位
// 返回结果

const _permute = string => {
    const result = []
    const used = Array.from({length: string.length}, () => false)
    const _backTrack = (candidate, memo = []) => {
        if(memo.length === string.length) {
            result.push(memo.slice().join(''))
            return
        }
        for(let i=0 ; i<candidate.length ; i++) {
            if(used[i]) continue
            memo.push(candidate[i])
            used[i] = true
            _backTrack(candidate, memo)
            used[i] = false
            memo.pop()
        }
    }
    _backTrack(string)
    return result
}

Function.prototype.mu_call = function (context, ...args | args) {
    //obj不存在指向window
    if (!context || context === null) context = window

    // 创造唯一的key值  作为我们构造的context内部方法名
    let fn = Symbol();
    //this指向调用call的函数
    context[fn] = this;
    // 执行函数并返回结果 相当于把自身作为传入的context的方法进行调用了
    // args 数组为 apply  ...args 为 call
    return context[fn](...args);
};

// 创建一个新this用来保存旧的this对象
// 返回一个匿名函数，该匿名函数返回通过apply修改了指针指向的函数运算结果

Function.prototype._bind = function(){
    // 将参数解析为数组
    const args = Array.prototype.slice.call(arguments)
    // 获取this
    const t = args.shift()
    const self = this // 当前函数
    // 返回一个函数
    return function() {
        // 执行原函数，并返回结果
        return self.apply(t, args)
    }
}

function bind(fn, obj) {
    let arg = [].slice.call(arguments, 2)
    return function() {
        let args = arg.concat([].slice.call(arguments))
        return fn.apply(obj, args)
    }
}


Function.prototype.mu_bind = function (context, ...args) {
    if (!context || context === null) {
      context = window;
    }
    // 创造唯一的key值  作为我们构造的context内部方法名
    let fn = Symbol();
    context[fn] = this;
    let _this = this;
    //  bind情况要复杂一点
    const result = function (...innerArgs) {
      // 第一种情况 :若是将 bind 绑定之后的函数当作构造函数，通过 new 操作符使用，则不绑定传入的 this，而是将 this 指向实例化出来的对象
      // 此时由于new操作符作用  this指向result实例对象  而result又继承自传入的_this 根据原型链知识可得出以下结论
      // this.__proto__ === result.prototype   //this instanceof result =>true
      // this.__proto__.__proto__ === result.prototype.__proto__ === _this.prototype; //this instanceof _this =>true
      if (this instanceof _this === true) {
        // 此时this指向指向result的实例  这时候不需要改变this指向
        this[fn] = _this;
        this[fn](...[...args, ...innerArgs]); //这里使用es6的方法让bind支持参数合并
        delete this[fn];
      } else {
        // 如果只是作为普通函数调用  那就很简单了 直接改变this指向为传入的context
        context[fn](...[...args, ...innerArgs]);
        delete context[fn];
      }
    };
    // 如果绑定的是构造函数 那么需要继承构造函数原型属性和方法
    // 实现继承的方式: 使用Object.create
    result.prototype = Object.create(this.prototype);
    return result;
};

// 传入参数左侧为实例L, 右侧为构造函数R
const _instanceof = (L, R) => {
    // 处理边界：检测实例类型是否为原始类型
    const baseTypes = ['string','number','boolean','symbol','undefined','null'];
    if(baseTypes.includes(Object.prototype.toString.call(L).slice(8,-1).toLowerCase())) return false;

    // 分别取传入参数的原型
    let Lp = L.__proto__;  // Object.getPrototypeOf(L)
    let Rp = R.prototype; // 函数才拥有prototype属性

    // 判断原型
    while(true){
        if(Lp === null) return false;
        if(Lp === Rp) return true;
        Lp = Lp.__proto__;
    }
}

// 创建一个临时函数
// 将该临时函数的原型指向对象参数
// 返回该临时对象的实例

const _objectCreate = proto => {
    if(typeof proto !== 'object' || proto === null) return
    const fn = function() {}
    fn.prototype = proto
    return new fn()
}
function create() {
    let obj = new Object()
    let Con = [].shift.call(arguments)
    obj.__proto__ = Con.prototype
    let result = Con.apply(obj, arguments)
    return typeof result === 'object' ? result : obj
}

// 创建一个新对象
// 获取函数参数
// 将新对象的原型对象和函数参数的原型连接起来
// 将新对象和参数传给构造器执行
// 如果构造器返回的不是对象，那么就返回第一个新对象

function _new(fn,...arg){
    // 首先创建空对象
    const obj = {};
    // 将空对象的原型proto指向构造函数的原型prototype
    Object.setPrototypeOf(obj, fn.prototype)
    // 将this指向新创建的对象，并且执行构造函数
    const result = fn.apply(obj,arg);
    // 执行结果有返回值并且是一个对象，返回执行的结果，否侧返回新创建的对象
    return result instanceof Object ? result : obj;
}

// 进入对象参数的遍历体中
// 判断当前对象参数是否为普通对象或数组
// 如果是普通对象或数组，则递归调用该函数，函数参数为当前遍历项
// 如果不是，则直接设置该参数的可写性为false
// 最后通过Object.seal函数封闭该对象，阻止添加新属性并将所有现有属性标记为不可配置

const _objectFreeze = object => {
    for(prop in object) {
        const type = Object.prototype.toString.call(object[prop])
        if(type === '[object Object]' || type === '[object Array]') {
            _objectFreeze(object[prop])
        } else {
            Object.defineProperty(object, prop, {
                writable: false
            })
        }
    }
    Object.seal(object)
}

toSort(propertyName) {
      return (a, b) => {
        // return a[propertyName] - b[propertyName]    // 升序
        return b[propertyName] - a[propertyName]; // 降序
      };
    }

Object.keys(object).length === 0 

JSON.stringify(data) === '{}'

const isEmpty = obj => Reflect.ownKeys(obj).length === 0 && obj.constructor === Object;
isEmpty({}) // true
isEmpty({a:"not empty"}) //false

// 如果对象参数的数据类型不为"object"或为"null"，则直接返回该参数
// 如果是"object"，就获取该参数的构造函数名，通过正则表达式判断该对象是否为函数、正则、日期、ES6新对象等，如果返回true，则直接返回该参数
// 当以上条件判断之后函数依然没有结束时，此时通过数组的原型方法判断该参数为普通对象或数组并创建相应数据类型的新变量
// 进入遍历体，将对象参数的每一项赋值给新变量
// 最终返回该新变量

const _shallowClone = target => {
    if(typeof target === 'object' && target !== null) return target 

    const constructor = target.constructor
    if(/^(Function|RegExp|Date|Map|Set)$/i.test(constructor.name)) return new constructor(target)
    const cloneTarget = Array.isArray(target) ? [] : {}
    for(prop in target) {
        if(target.hasOwnProperty(prop)) {
            cloneTarget[prop] = target[prop]
        }
    }
    return cloneTarget
}

// 首先判断对象参数是否为“null”，是则返回“null”
// 判断对象参数数据类型是否为“object”，不是则返回该参数
// 获取到对象参数的构造函数名，判断是否为函数、正则、日期、ES6新对象其中之一，如果是则直接返回通过该参数对象对应的构造函数生成的新实例对象
// 当以上条件判断之后函数依然没有结束时继续进行以下操作
// 在Map对象中获取当前参数对象，如果能获取到，则说明这里为循环引用并返回Map对象中该参数对象的值
// 如果在Map对象中没有获取到对应的值，则保存该参数对象到Map中，作为标记
// 根据该参数的数据类型是否为数组创建新对象
// 遍历该对象参数，将每一项递归调用该函数本身的返回值赋给新对象

const _completeDeepClone = (target, map = new Map()) => {
     if(typeof target === 'object' && target !== null) return target 
    const constructor = target.constructor
    if(/^(Function|RegExp|Date|Map|Set)$/i.test(constructor.name)) return new constructor(target)
    if(map.get(target)) return map.get(target)
    map.set(target, true)
    const cloneTarget = Array.isArray(target) ? [] : {}
    for(prop in target) {
        if(target.hasOwnProperty(prop)) {
            cloneTarget[prop] = _completeDeepClone(target[prop], map)
        }
    }
    return cloneTarget
}

function cloneRegExp(regExp) {
    // `/\w*$/`正则表达式获取正则表达式的标识符(flags)
    const flags = /\w*$/.exec(regExp)[0];
    // RegExp.prototype.source 获取正则表达式的源字符串
    // 创建一个新的正则表达式对象
    const clonedRegEx = new RegExp(regExp.source, flags);
    // 原始正则表达式的`lastIndex`值赋值给新的正则表达式对象
    clonedRegEx.lastIndex = regExp.lastIndex;
    return clonedRegEx;
}

function cloneRegExp(regExp) {
  return new RegExp(regExp.source);
}

// 在"Human"构造函数的原型上添加"getName"函数
// 在”Chinese“构造函数中通过call函数借助”Human“的构造器来获得通用属性
// Object.create函数返回一个对象，该对象的__proto__属性为对象参数的原型。此时将”Chinese“构造函数的原型和通过Object.create返回的实例对象联系起来
// 最后修复"Chinese"构造函数的原型链，即自身的"constructor"属性需要指向自身
// 在”Chinese“构造函数的原型上添加”getAge“函数

function Human(name) {
    this.name = name
    this.kingdom = 'animal'
    this.color = ['yellow', 'white', 'brown', 'black']
}
Human.prototype.getName = function() {
    return this.name
}
function Chinese(name,age) {
    Human.call(this,name)
    this.age = age
    this.color = 'yellow'
}
Chinese.prototype = Object.create(Human.prototype)
Chinese.prototype.constructor = Chinese
Chinese.prototype.getAge = function() {
    return this.age
}

document.querySelector('ul')
  .onclick = e => {
    e = e || window.event;
    e.target.nodeName.toLowerCase() == 'li'
      ? e.target.innerText += '.'
      : ''
  }

/**
 * 防抖函数
 * @param {Function} fn - 需要防抖的函数
 * @param {Number} delay - 防抖延迟时间
 * @returns {Function} 防抖后的函数
 */
function debounce(fn, delay) {
  let timerId; // 声明一个定时器id
  return function (...args) { // 返回一个函数
    if (timerId) { // 如果定时器存在，则清除定时器
      clearTimeout(timerId);
    }
    timerId = setTimeout(() => { // 设置定时器，指定延迟时间之后执行原函数
      fn.apply(this, args);
    }, delay || 250);
  };
}

function uncurry(fn) {
  return function (...args) {
    return args.reduce((acc, cur) => acc(cur), fn);
  };
}

function add(x) {
  return function (y) {
    return x + y;
  };
}

const addUncurried = uncurry(add);
console.log(addUncurried(1, 2)); // 3

function getQueryString(name) {
      let reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
      let r = window.location.search.substr(1).match(reg);
      if (r != null) return unescape(r[2]);
      return null;
    }

function getQueryString(name){
  let query = window.location.search.substring(1);
  let lets = query.split("&");
  for (let i=0;i<lets.length;i++) {
    let pair = lets[i].split("=");
    if(pair[0] == name){return pair[1];}
  }
  return(false);
}

setInterval(() => {
    window.scrollBy({
        top: 1,
        left: 0,
        behavior: "smooth"
    });
}, 30);

/**
 * @description: 格式化数字 每隔3位添加一个逗号
 * @param { Number } value
 * @param { Boolean } int 是否返回整数 默认false
 * @return { String }
 */
function numFormat(value, int) {
  if (!value) return "0.00";

  let intPart = Number(value) - (Number(value) % 1); 
  let intPartFormat = intPart.toString().replace(/(\d)(?=(?:\d{3})+$)/g, "$1,"); 

  let floatPart = ".00"; 
  let value2Array = value.toString().split(".");

  //=2表示数据有小数位
  if (value2Array.length == 2) {
    floatPart = value2Array[1].toString(); //拿到小数部分
  } else {
    if (int) return intPartFormat;
    return intPartFormat + floatPart;
  }
}