终于有人对jQuery下手了，一键移除项目对它的依赖

大家好，我是 零一 。虽然现在很多前端项目都在用Vue、React，但依赖jquery的项目也不少，尤其是年代比较久远的项目，那些还正在维护jquery项目的你，是否想将jquery从你的项目中移除？毕竟这个库那么大，你能用到的代码也就只有15%~30%，而且jquery对各个浏览器的兼容性也做了很大的处理（代码量up up），但其实很多老项目也不会去考虑兼容很边缘的浏览器了，所以其实jquery中兼容处理的代码也没太大必要

在三亚等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站建设、成都网站设计 网站设计制作按需规划网站,公司网站建设,企业网站建设,品牌网站制作,网络营销推广,外贸营销网站建设,三亚网站建设费用合理。

最近新发现了一个有意思的工具，仅上线2周，就有 600+ 的Star，它说能帮助你的项目脱离对jquery的依赖，感觉是个不错的想法，一起来看看吧~

使用方式

这个工具的名字叫 replace-jquery ，据说是能帮你从项目中自动查找所有用到的jquery方法，并生成一套原生js的方法去替代

先来搞一个极简的jquery项目

index.html

main.js

测试一下页面的功能，是OK的

接下来我们用 replace-jquery 工具试着移除一下 main.js 中的jquery代码

先全局下载一下

 
 
 
 
    
  
  
  
  
  1. npm install -g replace-jquery 
    2.

然后在项目目录使用，语法为 replace-jquery 目标js文件 生成的js文件

 
 
 
 
    
  
  
  
  
  1. replace-jquery main.js newMain.js 
    2.

该工具会自动找到你文件中所有用到的jquery方法。此处有一个确认的步骤，你可以选择想要替换哪些方法（默认是全选的）

生成过程

按回车键即可完成替换，并生成新的文件

 
 
 
 
    
  
  
  
  
  1. export class Utils { 
    2.   
  
  
  
  2.     constructor(selector) { 
    3.   
  
  
  
  3.         this.elements = Utils.getSelector(selector); 
    4.   
  
  
  
  4.         this.element = this.get(0); 
    5.   
  
  
  
  5.         return this; 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     on(events, listener) { 
    9.   
  
  
  
  9.         events.split(' ').forEach((eventName) => { 
    10.   
  
  
  
  10.             this.each((el) => { 
    11.   
  
  
  
  11.                 const tNEventName = Utils.setEventName(el, eventName); 
    12.   
  
  
  
  12.                 if (!Array.isArray(Utils.eventListeners[tNEventName])) { 
    13.   
  
  
  
  13.                     Utils.eventListeners[tNEventName] = []; 
    14.   
  
  
  
  14.                 } 
    15.   
  
  
  
  15.                 Utils.eventListeners[tNEventName].push(listener); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.                 // https://github.com/microsoft/TypeScript/issues/28357 
    18.   
  
  
  
  18.                 if (el) { 
    19.   
  
  
  
  19.                     el.addEventListener(eventName.split('.')[0], listener); 
    20.   
  
  
  
  20.                 } 
    21.   
  
  
  
  21.             }); 
    22.   
  
  
  
  22.         }); 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         return this; 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.     remove() { 
    27.   
  
  
  
  27.         this.each((el) => { 
    28.   
  
  
  
  28.             el.parentNode.removeChild(el); 
    29.   
  
  
  
  29.         }); 
    30.   
  
  
  
  30.         return this; 
    31.   
  
  
  
  31.     } 
    32.   
  
  
  
  32.     css(css, value) { 
    33.   
  
  
  
  33.         if (value !== undefined) { 
    34.   
  
  
  
  34.             this.each((el) => { 
    35.   
  
  
  
  35.                 Utils.setCss(el, css, value); 
    36.   
  
  
  
  36.             }); 
    37.   
  
  
  
  37.             return this; 
    38.   
  
  
  
  38.         } 
    39.   
  
  
  
  39.         if (typeof css === 'object') { 
    40.   
  
  
  
  40.             for (const property in css) { 
    41.   
  
  
  
  41.                 if (Object.prototype.hasOwnProperty.call(css, property)) { 
    42.   
  
  
  
  42.                     this.each((el) => { 
    43.   
  
  
  
  43.                         Utils.setCss(el, property, css[property]); 
    44.   
  
  
  
  44.                     }); 
    45.   
  
  
  
  45.                 } 
    46.   
  
  
  
  46.             } 
    47.   
  
  
  
  47.             return this; 
    48.   
  
  
  
  48.         } 
    49.   
  
  
  
  49.         const cssProp = Utils.camelCase(css); 
    50.   
  
  
  
  50.         const property = Utils.styleSupport(cssProp); 
    51.   
  
  
  
  51.         return getComputedStyle(this.element)[property]; 
    52.   
  
  
  
  52.     } 
    53.   
  
  
  
  53.     static getSelector(selector, context) { 
    54.   
  
  
  
  54.         if (selector && typeof selector !== 'string') { 
    55.   
  
  
  
  55.             if (selector.length !== undefined) { 
    56.   
  
  
  
  56.                 return selector; 
    57.   
  
  
  
  57.             } 
    58.   
  
  
  
  58.             return [selector]; 
    59.   
  
  
  
  59.         } 
    60.   
  
  
  
  60.         context = context || document; 
    61.   
  
  
  
  61.  
    62.   
  
  
  
  62.         // For performance reasons, use getElementById 
    63.   
  
  
  
  63.         // eslint-disable-next-line no-control-regex 
    64.   
  
  
  
  64.         const idRegex = /^#(?:[\w-]|\\.|[^\x00-\xa0])*$/; 
    65.   
  
  
  
  65.         if (idRegex.test(selector)) { 
    66.   
  
  
  
  66.             const el = document.getElementById(selector.substring(1)); 
    67.   
  
  
  
  67.             return el ? [el] : []; 
    68.   
  
  
  
  68.         } 
    69.   
  
  
  
  69.         return [].slice.call(context.querySelectorAll(selector) || []); 
    70.   
  
  
  
  70.     } 
    71.   
  
  
  
  71.     get(index) { 
    72.   
  
  
  
  72.         if (index !== undefined) { 
    73.   
  
  
  
  73.             return this.elements[index]; 
    74.   
  
  
  
  74.         } 
    75.   
  
  
  
  75.         return this.elements; 
    76.   
  
  
  
  76.     } 
    77.   
  
  
  
  77.     each(func) { 
    78.   
  
  
  
  78.         if (!this.elements.length) { 
    79.   
  
  
  
  79.             return this; 
    80.   
  
  
  
  80.         } 
    81.   
  
  
  
  81.         this.elements.forEach((el, index) => { 
    82.   
  
  
  
  82.             func.call(el, el, index); 
    83.   
  
  
  
  83.         }); 
    84.   
  
  
  
  84.         return this; 
    85.   
  
  
  
  85.     } 
    86.   
  
  
  
  86.     static setEventName(el, eventName) { 
    87.   
  
  
  
  87.         // Need to verify https://stackoverflow.com/questions/1915341/whats-wrong-with-adding-properties-to-dom-element-objects 
    88.   
  
  
  
  88.         const elementUUId = el.eventEmitterUUID; 
    89.   
  
  
  
  89.         const uuid = elementUUId || Utils.generateUUID(); 
    90.   
  
  
  
  90.         // eslint-disable-next-line no-param-reassign 
    91.   
  
  
  
  91.         el.eventEmitterUUID = uuid; 
    92.   
  
  
  
  92.         return Utils.getEventName(eventName, uuid); 
    93.   
  
  
  
  93.     } 
    94.   
  
  
  
  94.     static setCss(el, prop, value) { 
    95.   
  
  
  
  95.         // prettier-ignore 
    96.   
  
  
  
  96.         let cssProperty = Utils.camelCase(prop); 
    97.   
  
  
  
  97.         cssProperty = Utils.styleSupport(cssProperty); 
    98.   
  
  
  
  98.         el.style[cssProperty] = value; 
    99.   
  
  
  
  99.     } 
    100.   
  
  
  
  100.     static camelCase(text) { 
    101.   
  
  
  
  101.         return text.replace(/-([a-z])/gi, (s, group1) => group1.toUpperCase()); 
    102.   
  
  
  
  102.     } 
    103.   
  
  
  
  103.     static styleSupport(prop) { 
    104.   
  
  
  
  104.         let vendorProp; 
    105.   
  
  
  
  105.         let supportedProp; 
    106.   
  
  
  
  106.         const capProp = prop.charAt(0).toUpperCase() + prop.slice(1); 
    107.   
  
  
  
  107.         const prefixes = ['Moz', 'Webkit', 'O', 'ms']; 
    108.   
  
  
  
  108.         let div = document.createElement('div'); 
    109.   
  
  
  
  109.  
    110.   
  
  
  
  110.         if (prop in div.style) { 
    111.   
  
  
  
  111.             supportedProp = prop; 
    112.   
  
  
  
  112.         } else { 
    113.   
  
  
  
  113.             for (let i = 0; i < prefixes.length; i++) { 
    114.   
  
  
  
  114.                 vendorProp = prefixes[i] + capProp; 
    115.   
  
  
  
  115.                 if (vendorProp in div.style) { 
    116.   
  
  
  
  116.                     supportedProp = vendorProp; 
    117.   
  
  
  
  117.                     break; 
    118.   
  
  
  
  118.                 } 
    119.   
  
  
  
  119.             } 
    120.   
  
  
  
  120.         } 
    121.   
  
  
  
  121.  
    122.   
  
  
  
  122.         div = null; 
    123.   
  
  
  
  123.         return supportedProp; 
    124.   
  
  
  
  124.     } 
    125.   
  
  
  
  125.     static generateUUID() { 
    126.   
  
  
  
  126.         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => { 
    127.   
  
  
  
  127.             // eslint-disable-next-line no-bitwise 
    128.   
  
  
  
  128.             const r = (Math.random() * 16) | 0; 
    129.   
  
  
  
  129.             // eslint-disable-next-line no-bitwise 
    130.   
  
  
  
  130.             const v = c === 'x' ? r : (r & 0x3) | 0x8; 
    131.   
  
  
  
  131.             return v.toString(16); 
    132.   
  
  
  
  132.         }); 
    133.   
  
  
  
  133.     } 
    134.   
  
  
  
  134.     static getEventName(eventName, uuid) { 
    135.   
  
  
  
  135.         return `${eventName}__EVENT_EMITTER__${uuid}`; 
    136.   
  
  
  
  136.     } 
    137.   
  
  
  
  137. } 
    138.   
  
  
  
  138.  
    139.   
  
  
  
  139. Utils.eventListeners = {}; 
    140.   
  
  
  
  140.  
    141.   
  
  
  
  141. export default function $utils(selector) { 
    142.   
  
  
  
  142.     return new Utils(selector); 
    143.   
  
  
  
  143. } 
    144.

简单看了一下，似乎就是把我们用到的jquery方法替换成了简单的原生方法，并封装在 Utils 这个类中，那么我们每次调用 $("xxx") 时，其实就是在调用该类上的方法，那么对这个文件做一些修改

 
 
 
 
    
  
  
  
  
  1. // 此处删除export 
    2.   
  
  
  
  2. class Utils { 
    3.   
  
  
  
  3.  // ...省略一些代码 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. Utils.eventListeners = {}; 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. // 此处删除 export default，并将函数 $utils改成 $ 
    9.   
  
  
  
  9. function $(selector) { 
    10.   
  
  
  
  10.     return new Utils(selector); 
    11.   
  
  
  
  11. } 
    12.

这样就相当于我们在全局模拟jquery定义了一个 $ 方法。此时html文件中的jquery引用就可以删除了，并把我们刚才生成的文件引进来

删除jquery，注入替代品

再去页面中尝试操作dom，可以看到效果跟之前一样，成功！

补充

如果你想用该工具生成jquery所有api的替代文件，即生成一个 super-mini-jquery ，你可以这么做

 
 
 
 
    
  
  
  
  
  1. replace-jquery --build-all super-mini-jquery.js 
    2.

将代码混淆丑化以后大概只有10kb

super-mini-jquery包体大小

 因为这个工具刚发布才2个星期不到，只实现了大部分的jquery代码替换，比如 ajax 暂时是没办法替换的，你如果尝试去替换，工具也会提醒你

无法替换ajax

总的来说，这个工具想法不错，希望后期能支持更多的语法替换！

新闻标题：终于有人对jQuery下手了，一键移除项目对它的依赖
当前路径：http://www.shufengxianlan.com/qtweb/news21/22971.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

电子商务知识

同城分类信息

成都做网站　　 　成都品牌网站设计　　 　成都网络公司　　 　营销型网站　　 　软文推广　　 　平昌保洁　　 　德阳服务器托管　　 　微官网开发　　 　手机网站建设公司　　 　成都企业网站制作　　 　营销网站建设　　 　免备案空间腾讯云　　 　泽君科技　　 　成都网站推广　　 　成都商城网站制作　　 　双流网站建设　　 　成都网站改版　　 　广安园林绿化公司　　 　微商城开发　　 　成都网站推广