单例设计模式 return{}：

    • 这种模式只能支持 浏览器script导入进来
    • 不支持CommonJS模块规范，不支持webpack环境


    1. (function(){
    2.     const css=function css(){};
    3.     const offset=function offset(){}
    4.     const throttle=function throttle(){}
    6.     // 支持各种环境
    7.     // 暴露API
    8.     let utils={
    9.         css,
    10.         offset,
    11.         throttle
    12.     };
    13.     // 浏览器
    14.     if(typeof window!=="undefined") window.util=window._=utils;
    15.     // 支持 CommonJs规范
    16.     if(typeof module==="object"&&typeof module.exports==="object") module.exports=utils;
    17. })();
    1. (function () {
    2.     var getProto = Object.getPrototypeOf;
    3.     var class2type = {};
    4.     var toString = class2type.toString;
    5.     var hasOwn = class2type.hasOwnProperty;
    6.     var fnToString = hasOwn.toString;
    7.     var ObjectFunctionString = fnToString.call(Object);
    9.     // 检测是否是一个函数
    10.     var isFunction = function isFunction(obj) {
    11.         return typeof obj === "function" && typeof obj.nodeType !== "number" &&
    12.             typeof obj.item !== "function";
    13.     };
    15.     // 检测是否是一个window对象
    16.     var isWindow = function isWindow(obj) {
    17.         return obj != null && obj === obj.window;
    18.     };
    20.     // 标准的检测数据类型的办法
    21.     var toType = function toType(obj) {
    22.         if (obj == null) return obj + "";
    23.         var reg = /^\[object ([a-zA-Z0-9]+)\]$/i;
    24.         return typeof obj === "object" || typeof obj === "function" ?
    25.             reg.exec(toString.call(obj))[1].toLowerCase() :
    26.             typeof obj;
    27.     };
    29.     // 检测是否为数组或者类数组
    30.     var isArrayLike = function isArrayLike(obj) {
    31.         var length = !!obj && "length" in obj && obj.length,
    32.             type = toType(obj);
    33.         if (isFunction(obj) || isWindow(obj)) return false;
    34.         return type === "array" || length === 0 ||
    35.             typeof length === "number" && length > 0 && (length - 1) in obj;
    36.     };
    38.     // 检测是否为纯粹的对象「直属类是Object || Object.create(null)」
    39.     var isPlainObject = function isPlainObject(obj) {
    40.         var proto, Ctor;
    41.         if (!obj || toString.call(obj) !== "[object Object]") return false;
    42.         proto = getProto(obj);
    43.         if (!proto) return true;
    44.         Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
    45.         return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
    46.     };
    48.     // 检测是否是空对象
    49.     var isEmptyObject = function isEmptyObject(obj) {
    50.         var keys = Object.keys(obj);
    51.         if (typeof Symbol !== "undefined") keys = keys.concat(Object.getOwnPropertySymbols(obj));
    52.         return keys.length === 0;
    53.     };
    55.     // 检测是否是数字
    56.     var isNumeric = function isNumeric(obj) {
    57.         var type = toType(obj);
    58.         return (type === "number" || type === "string") && !isNaN(obj);
    59.     };
    61.     /*
    62.      * 获取元素样式 
    63.      */
    64.     const getCss = function getCss(element, attr) {
    65.         let value = window.getComputedStyle(element)[attr],
    66.             reg = /^\d+(px|rem|em)?$/i;
    67.         if (reg.test(value)) {
    68.             value = parseFloat(value);
    69.         }
    70.         return value;
    71.     };
    73.     /*
    74.      * 设置元素样式 
    75.      */
    76.     const setCss = function setCss(element, attr, value) {
    77.         if (attr === "opacity") {
    78.             element['style']['opacity'] = value;
    79.             element['style']['filter'] = `alpha(opacity=${value*100})`;
    80.             return;
    81.         }
    82.         let reg = /^(width|height|margin|padding)?(top|left|bottom|right)?$/i;
    83.         if (reg.test(attr)) {
    84.             if (!isNaN(value)) {
    85.                 value += 'px';
    86.             }
    87.         }
    88.         element['style'][attr] = value;
    89.     };
    91.     /* 
    92.      * 批量设置元素样式 
    93.      */
    94.     const setGroupCss = function setGroupCss(element, options) {
    95.         for (let key in options) {
    96.             if (!options.hasOwnProperty(key)) break;
    97.             setCss(element, key, options[key]);
    98.         }
    99.     };
    101.     /* 
    102.      * 样式的综合处理 
    103.      */
    104.     const css = function css(element) {
    105.         let len = arguments.length,
    106.             attr = arguments[1],
    107.             value = arguments[2];
    108.         if (len >= 3) {
    109.             setCss(element, attr, value);
    110.             return;
    111.         }
    112.         if (attr !== null && typeof attr === "object") {
    113.             setGroupCss(element, attr);
    114.             return;
    115.         }
    116.         return getCss(element, attr);
    117.     };
    119.     /*
    120.      * 获取元素距离BODY的偏移量 
    121.      */
    122.     const offset = function offset(element) {
    123.         let parent = element.offsetParent,
    124.             top = element.offsetTop,
    125.             left = element.offsetLeft;
    126.         while (parent) {
    127.             if (!/MSIE 8/.test(navigator.userAgent)) {
    128.                 left += parent.clientLeft;
    129.                 top += parent.clientTop;
    130.             }
    131.             left += parent.offsetLeft;
    132.             top += parent.offsetTop;
    133.             parent = parent.offsetParent;
    134.         }
    135.         return {
    136.             top,
    137.             left
    138.         };
    139.     };
    141.     /*
    142.      * 函数防抖处理
    143.      */
    144.     const debounce = function debounce(func, wait, immediate) {
    145.         if (typeof func !== "function") throw new TypeError('func must be an function');
    146.         if (typeof wait === "boolean") {
    147.             immediate = wait;
    148.             wait = 300;
    149.         }
    150.         if (typeof wait !== "number") wait = 300;
    151.         if (typeof immediate !== "boolean") immediate = false;
    152.         let timer;
    153.         return function proxy(...params) {
    154.             let runNow = !timer && immediate,
    155.                 self = this,
    156.                 result;
    157.             if (timer) {
    158.                 clearTimeout(timer);
    159.                 timer = null;
    160.             }
    161.             timer = setTimeout(() => {
    162.                 if (timer) {
    163.                     clearTimeout(timer);
    164.                     timer = null;
    165.                 }
    166.                 if (!immediate) result = func.call(self, ...params);
    167.             }, wait);
    168.             if (runNow) result = func.call(self, ...params);
    169.             return result;
    170.         };
    171.     };
    173.     /*
    174.      * 函数节流处理 
    175.      */
    176.     const throttle = function throttle(func, wait) {
    177.         if (typeof func !== "function") throw new TypeError('func must be an function');
    178.         if (typeof wait !== "number") wait = 300;
    179.         let timer,
    180.             previous = 0;
    181.         return function proxy(...params) {
    182.             let now = +new Date(),
    183.                 remaining = wait - (now - previous),
    184.                 self = this,
    185.                 result;
    186.             if (remaining <= 0) {
    187.                 if (timer) {
    188.                     clearTimeout(timer);
    189.                     timer = null;
    190.                 }
    191.                 result = func.call(self, ...params);
    192.                 previous = now;
    193.             } else if (!timer) {
    194.                 timer = setTimeout(() => {
    195.                     if (timer) {
    196.                         clearTimeout(timer);
    197.                         timer = null;
    198.                     }
    199.                     result = func.call(self, ...params);
    200.                     previous = +new Date();
    201.                 }, remaining);
    202.             }
    203.             return result;
    204.         };
    205.     };
    207.     /* 暴露API */
    208.     let utils = {
    209.         debounce,
    210.         throttle,
    211.         offset,
    212.         css,
    213.         toType,
    214.         isFunction,
    215.         isWindow,
    216.         isPlainObject,
    217.         isArrayLike,
    218.         isEmptyObject,
    219.         isNumeric
    220.     };
    221.     let _$ = window.$;
    222.     utils.noConflict = function noConflict() {
    223.         if (window.$ === utils) window.$ = _$;
    224.         return utils;
    225.     };
    226.     // 浏览器
    227.     if(typeof window!=="undefined") window.util=window._=utils;
    228.     // 支持 CommonJs规范
    229.     if(typeof module==="object"&&typeof module.exports==="object") module.exports=utils;
    230. })();