https://www.imqianduan.com/javascript/236.html
https://juejin.cn/post/6898962197335490573
策略模式 https://www.cnblogs.com/hollischuang/p/13186766.html

https://blog.csdn.net/qq_34703156/article/details/122863975
https://blog.csdn.net/java_atguigu/article/details/123919921
https://baijiahao.baidu.com/s?id=1713405091858312136&wfr=spider&for=pc
https://www.cnblogs.com/shine-lovely/p/12836773.html
https://www.cnblogs.com/fundebug/p/13_js_utilities_you_need.html
https://gitee.com/zhangyangbin/js-utils
https://github.com/proYang/outils
https://juejin.cn/post/7048963605462515743
异步并发限制 https://zhuanlan.zhihu.com/p/123968952

utils

number
string
date
cache
is判断类型，设备类型

语雀空间
https://xk70b1.yuque.com/dashboard
https://www.yuque.com/yuque/blog/hrwynrqgoexdynw4

collect

https://github.com/ecrmnn/collect.js
https://collect.js.org/installation.html
image.png

  1. yarn add collect.js

mathjs

https://github.com/josdejong/mathjs
https://mathjs.org/
image.png

sugarjs

sugarjs https://sugarjs.com/
image.png

lazy.js

https://github.com/dtao/lazy.js
http://danieltao.com/lazy.js/

  1. 函数调用
  2. // 冗余 
  3. function test1() { console.log('test1'); }; 
  4. function test2() { console.log('test2'); }; 
  5. var test3 = 1; 
  6. if (test3 == 1) { test1(); } 
  7. else { test2(); } 
  8. // 简单 
  9. (test3 === 1? test1:test2)(); 
  11. 多行字符串
  12. // 冗余
  13. const data = 'abc abc abc abc abc abc\n\t'
  14.     + 'test test,test test test test\n\t'
  16. // 简洁
  17. const data = `abc abc abc abc abc abc
  18.          test test,test test test test`
  20. 隐式返回
  21. // 冗余
  22. function getArea(diameter) {
  23.   return Math.PI * diameter
  24. }
  26. // 简洁
  27. getArea = diameter => (
  28.   Math.PI * diameter;
  29. )
  31. 字符串重复多次
  32. // 冗余
  33. let test = ''; 
  34. for(let i = 0; i < 5; i ++) { 
  35.   test += 'test '; 
  36. } 
  38. // 简洁
  39. 'test '.repeat(5);
  42. 幂乘
  43. // 冗余
  44. Math.pow(2,3);
  46. // 简洁而
  47. 2**3 // 8
  49. 获取对象的key, value值
  50. Object.keys()、Object.values()、Object.entries()的用法
  53. 图片懒加载
  54. 可以通过为图片文件添加loading="lazy"的属性来实现:
  55. ![](image.png)
  57. 数组去重
  58. 1.借助Set
  59. const arr = [12,34,565,12,34,1,3,1]
  60. const newArr = Array.from(new Set(arr))
  61. console.log('newArr',newArr);
  62. const numbers = [1,2,3,4,1,2,3,4];
  63. const result = [... new Set(numbers)];
  66. ?.链式合并运算
  67.   // 错误写法，当某一层级值为null或undefined时，会报错
  68.       const userName = list.info.base.userName;
  69.    // 正确写法（我们常用的方式）
  70.   const userName = (list && list.info && list.info.base && 
  71.   list.info.base.userName) || 'userName'// 错误写法，当某一层级值为null或 
  72.   undefined时，会报错
  73.   const userName = list.info.base.userName;
  74.   // 正确写法（我们常用的方式）
  75.   const userName = (list && list.info && list.info.base && 
  76.   list.info.base.userName) || 'userName'
  78.   es2020引入链合并运算符，简化上面的写法
  79.   const userName = list?.info?.base?.userName || 'userName';
  81. ?.运算符这在有时候处理对象时非常有用，看下面案例，person.name返回undefined然后在调用toString这时肯定会报错，
  82.   这时使用?.运算符就不会产生错误，?.运算符是只有在当值不是undefined时才会调用toString方法。
  85. 双位运算符
  86. 双位运算符比Math.floor(),Math.ceil()速度快
  88. `~~7.5                // 7
  89. Math.ceil(7.5)       // 8
  90. Math.floor(7.5)      // 7
  92. ~~-7.5          // -7
  93. Math.floor(-7.5)     // -8
  94. Math.ceil(-7.5)      // -7
  95.   ~~双非运算符
  96. ~~双非运算符可以用于向下取整
  97. console.log(~~4.3) // 4
  100.   ??运算符只有前面的值是undefined or null才会执行，工作中有的情况下使用，我们来看一下。
  101.   let status = undefined;
  102. let text = status ?? "暂无"
  103. console.log(text) // 暂无
  105. ??的意思是 如果?? 左边的值是null 或者是undefined,那么就返回右边的
  106.   const height = 0
  107. console.log(height||100)//100
  108. cosole.log(height ?? 100)//0
  110. 检查数值是不是NAN
  111. Number.isNaN(1+NaN); // true; NaN 数值与非数值运算的结果NaN
  114.  深度 clone
  115. const objectA = {a: 1, b: 2};
  116. const clonedA = JSON.parse(JSON.stringify(objectA));
  118. 字符串转数字
  119. let numberStr = "123";
  120. +numberStr; // 123
  121. numberStr = '123.12';
  122. +numberStr; // 123.12
  124. 数字转字符串
  125. 直接在需要转换的数字后加上空字符串，最快捷的转换，比调用toString快很多
  127. 判断正负值
  128. // Math.sign()
  129. // 判断正负, 还是0; 对非数值,能转化的转化; 不能转的就是NaN
  130. // 返回值: 正 +1; 负 -1; 0; 0; 其他值 NaN
  132. Array.of(传一组数值); 用于将一组值，转换为数组
  133. Array.from(param1, param2)方法用于将两类对象转为真正的数组
  134.    参数1: 一个对象 ==> 伪数组对象和可遍历（iterable）的对象
  135.     参数2: 回调函数 ==> 类似于数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。
  136.     return值: 一个数组;
  137. 示例:
  138.     let arrayLike = {
  139.         '0': 'a',
  140.         '1': 'b',
  141.         '2': 'c',
  142.         length: 3
  143.         // 0: 'a',
  144.         // 1: 'b',
  145.         // 2: 'c',
  146.         // length: 3
  147.     };
  148.     let real_arr = Array.from(arrayLike);
  151. 在两个数组匹配取值的情况，如果嵌套循环，效率低，并且代码看着不美观。利用对象的特性，可以简化复杂度。例如根据id匹配员工工资
  152. 双数组匹配
  153. const employees = [
  154.     {id: 1, name: 'Tom'},
  155.     {id: 2, name: 'Jerry'},
  156.     {id: 3, name: 'Jim'},
  157.     {id: 4, name: 'Kate'}
  158. ];
  159. const salary = [
  160.     {id: 1, salary: 10000},
  161.     {id: 2, salary: 20000},
  162.     {id: 3, salary: 30000},
  163.     {id: 4, salary: 40000}
  164. ];
  165. const salaryObj = {};
  166. salary.map(({id, salary}) => salaryObj[id] = salary);
  167. employees.map(e => e.salary = salaryObj[e.id]);
  170. JavaScript 中只有六个虚值
  171. undefined
  172. null
  173. NaN
  174. 0
  175. "" （空字符串）
  176. false
  177. myArray.filter(Boolean);
  178. 去除当前数组里的false值
  180. # !!
  181. !!0; // false
  182. !!undefined; // false
  183. !!null; // false
  184. !!(()=>{}); // true
  187. 原始的 myArray 会保持不变
  188. myArray
  189.     .map(item => {
  190.         // Do your changes and return the new item
  191.     })
  192.     .filter(Boolean);
  195. 合并多个对象
  196. const user = { 
  197.      name: 'John Ludwig', 
  198.      gender: 'Male' 
  199. };
  200. const college = { 
  201.      primary: 'Mani Primary School', 
  202.      secondary: 'Lass Secondary School' 
  203. };
  204. const skills = { 
  205.     programming: 'Extreme', 
  206.     swimming: 'Average', 
  207.     sleeping: 'Pro' 
  208. };
  209. const summary = {...user, ...college, ...skills};
  212. 数组排序
  213. 默认情况下 sort 方法把数组元素转换为字符串，并对其进行字典排序。在对数字数组进行排序时，这有可能会导致一些问题
  215. [0,10,4,9,123,54,1].sort((a,b) => a-b);
  216. [0, 1, 4, 9, 10, 54, 123]
  218. 阻止用户在你的网页上单击鼠标右键
  219. <body oncontextmenu="return false">
  220.     <div></div>
  221. </body>
  223. 获取数组中的最后一项
  224. 过对 splice 方法的参数传入负整数，来数获取组末尾的元素
  225. let array = [0, 1, 2, 3, 4, 5, 6, 7] 
  226. console.log(array.slice(-1));
  227. [7]
  228. console.log(array.slice(-2));
  229. [6, 7]
  230. console.log(array.slice(-3));
  231. [5, 6, 7]
  233. Promise.all 的主要注意事项是，当一个 Promise 拒绝时，该方法将引发错误。这意味着你的代码不会等到你所有的 promise 都完成
  235. 等到所有 promise 都完成后，无论它们被拒绝还是被解决，都可以使用 Promise.allSettled。此方法在 ES2020 的最终版本得到支持
  236. 即使某些 promise 被拒绝，Promise.allSettled 也会从你所有的 promise 中返回结果
  237. const PromiseArray = [
  238.     Promise.resolve(100),
  239.     Promise.reject(null),
  240.     Promise.resolve("Data release"),
  241.     Promise.reject(new Error('Something went wrong'))];
  243. Promise.allSettled(PromiseArray).then(res =>{
  244. console.log(res);
  245. }).catch(err => console.log(err));
  247. //[
  248. //{status: "fulfilled", value: 100},
  249. //{status: "rejected", reason: null},
  250. //{status: "fulfilled", value: "Data release"},
  251. //{status: "rejected", reason: Error: Something went wrong ...}
  252. //]
  254. try..catch..finally
  255. const getData = async () => {
  256.   try {
  257.     setLoading(true);
  258.     const response = await fetch(
  259.       "https://jsonplaceholder.typicode.com/posts"
  260.     );
  261.     const data = await response.json();
  262.     setData(data);
  263.   } catch (error) {
  264.     console.log(error);
  265.     setToastMessage(error);
  266.   } finally {
  267.     setLoading(false); // 不管是否报错，最后都会执行
  268.   }
  269. };
  271. getData();
  273. 别名结构赋值
  274. const object = { number: 10 };
  275. // Grabbing number
  276. const { number } = object;
  278. // Grabbing number and renaming it as otherNumber
  279. const { number: otherNumber } = object;
  280. console.log(otherNumber); //10
  283. eval 生成正则表达式,动态正则匹配
  284. let str = 'hello world ';
  285. let reg1 = `/hello/g`;
  286. let reg2 = `/world/g`;
  288. eval(reg1).test(str); // true
  289. eval(reg2).test(str); // true

Form表单

String字符串

https://github.com/jprichardson/string.js

文本选中

https://github.com/EvandroLG/selecting

  1. npm install selecting

image.png

音频&视频

图片相关

轮播图

https://github.com/sachinchoolur/lightgallery.js
image.png
https://github.com/fengyuanchen/cropperjs

https://fengyuanchen.github.io/viewerjs/
image.png

图片懒加载

https://github.com/dinbror/blazy/
https://dinbror.dk/blazy/?ref=github
image.png

JS数据可视化

  • d3.js
  • three.js
  • echarts.js

BOM操作

domurl

https://github.com/Mikhus/domurl

  1. npm install domurl

urijs

  1. import URI from 'urijs'

禁止页面另存为：标签加入以下代码

  1. <noscript>
  2.     <iframe src=”*.htm”></iframe>
  3. </noscript>

禁止复制页面内容

  1. <body
  2.     οncοntextmenu=”return false” 禁止鼠标右键菜单
  3.     onselectstart=”return false”  禁止鼠标选取
  4.     οndragstart=”return false” 禁止鼠标拖拽
  5. >
  6. </body>

html encode & decode

https://github.com/mathiasbynens/he

原生JS的重要性

你不需要 lodash

你不需要 Jquery

  2. function loop(array, fn){ 
  3.   for ( var i = 0; i < array.length; i++ ) 
  4.     fn.call( array, array[i], i ); 
  5. } 
  7. // 最小值
  8. function smallest(array){ 
  9.   return Math.min.apply( Math, array ); 
  10. }
  12. // 最大值
  13. function largest(array){ 
  14.   return Math.max.apply( Math, array ); 
  15. }
  17. // sleep
  18. const sleep = ms => new Promise(resolve => setTimeout(() => resolve(), ms))
  20. /**
  21.     * 函数防抖
  22.   * @params callback 回调函数
  23.     * @param wait 延迟执行毫秒数
  24.   * @param immediate true 表立即执行，false 表非立即执行
  25.     */
  26. function debounce(callback, wait, immediate) {
  27.     let timeout
  28.   return function() {
  29.       let _this = this
  30.     let args = arguments // arguments 必须在函数内部是用
  31.     if(timeout) clearTimeout(timeout)
  33.     if(immediate) {
  34.         const callNow = !timeout
  35.       timeout = setTimeout(() => {
  36.           timeout = null
  37.       }, wait)
  38.       if(callNow) func.apply(_this, args)
  39.     }
  40.     else {
  41.         timeout = setTimeout(() => {
  42.           callback.apply(_this, args)
  43.       }, wait)
  44.     }
  45.   }
  46. }
  49. // 函数节流
  50. // Returns a function, that, when invoked, will only be triggered at most once
  51. // during a given window of time. Normally, the throttled function will run
  52. // as much as it can, without ever going more than once per `wait` duration;
  53. // but if you'd like to disable the execution on the leading edge, pass
  54. // `{leading: false}`. To disable execution on the trailing edge, ditto.
  55. function throttle(func, wait, options) {
  56.   var context, args, result;
  57.   var timeout = null;
  58.   var previous = 0;
  59.   if (!options) options = {};
  60.   var later = function() {
  61.     previous = options.leading === false ? 0 : Date.now();
  62.     timeout = null;
  63.     result = func.apply(context, args);
  64.     if (!timeout) context = args = null;
  65.   };
  67.   return function() {
  68.     var now = Date.now();
  69.     if (!previous && options.leading === false) previous = now;
  70.     var remaining = wait - (now - previous);
  71.     context = this;
  72.     args = arguments;
  73.     if (remaining <= 0 || remaining > wait) {
  74.       if (timeout) {
  75.         clearTimeout(timeout);
  76.         timeout = null;
  77.       }
  78.       previous = now;
  79.       result = func.apply(context, args);
  80.       if (!timeout) context = args = null;
  81.     } else if (!timeout && options.trailing !== false) {
  82.       timeout = setTimeout(later, remaining);
  83.     }
  84.     return result;
  85.   };
  86. };
  91. // 数组去重的20中思路
  93. // setTimeout实现 setInterval
  94. function _setInterval(){
  95.     let timer = setTimeout(() =>{
  96.       _setInterval()
  97.     clearTimeout(timer)
  98.   }, 1000)
  99. }
  101. function myInterval(callback, time){
  102.     function inner() {
  103.       callback()
  104.     setTimeout(inner, time)
  105.   }
  106.   inner()
  107. }
  110. // 闭包
  111. (function(){
  112.     const utils = window._utils_ = function() {}
  113. })();
  115. const utils = (function(){
  116.     function utils() {}
  117. })()
  120. Object.prototype.keys = function(){ 
  121.   var keys = []; 
  122.   for ( var i in this ) 
  123.     keys.push( i ); 
  124.   return keys; 
  125. }
  127. Function.prototype.bind = function(object){ 
  128.   var fn = this; 
  129.   return function(){ 
  130.     return fn.apply(object, arguments); 
  131.   }; 
  132. }; 
  134. // 生成26个字母
  135. Array.from({length: 26}, (_, i) => String.fromCharCode(65+i))

本地字典

dict.js

  1. // Badge 状态
  2. export const STATUS = {
  3.   0: { label: '在线', value: 'green' }, // 绿
  4.   1: { label: '故障', value: 'orange'}, // 橙
  5.   2: { label: '预警', value: 'yellow' }, // 黄
  6.   3: { label: '离线', value: 'default' }, // 灰
  7. }
  9. export const TIMESTAMP = {
  10.   'h1': () => datenow() - oneHour,
  11.   'h6': () => datenow() - oneHour * 6,
  12.   'h12':() =>  datenow() - oneHour * 12,
  13.   'day1':() =>  datenow() - oneDay,
  14.   'day3':() =>  datenow() - oneDay * 3,
  15.   'day7':() =>  datenow() - oneDay * 7,
  16. }
  2. // JSON转字符串
  3. export function JsonEncode(obj) {
  4.   return JSON.stringify(obj);
  5. }
  7. // 字符串转JSON
  8. export function JsonDecode(str) {
  9.   let value = '';
  10.   try {
  11.     value = JSON.parse(str);
  12.   }
  13.   catch(e) {
  14.     // unquote 转义字符也会导致解析失败
  15.     const newString = str.replace(/&quot;/g, '\"');
  16.     value = JSON.parse(newString);
  17.   }
  19.   return value;
  20. }
  22. // 转义 url
  23. export function DecodeUri(string) {
  24.   const { decodeURIComponent, escape } = window;
  25.   return decodeURIComponent(escape(string));
  26. }
  28. // 字符串转JSON
  29. export function EncodeUri(string) {
  30.   const { encodeURIComponent, unescape } = window;
  31.   return unescape(encodeURIComponent(string));
  32. }
  34. // 获取 URL参数
  35. export function getParams() {
  36.   const query = window.location.search.substr(1);
  37.   const queryArray = query.split('&');
  39.   return queryArray.reduce((prev, next) => {
  40.     const [key, value] = next.split('=');
  41.     prev[key] = value;
  42.     return prev;
  43.   }, {});
  44. }
  46. // 获取 URL参数，正则
  47. export function getParams() {
  48.   const REG = /(([\w\-]+){1}(\=([^\&\n\r\t]*){1})?)/g;
  49.   const query = REG.exec(window.location.search.substr(1));
  50. }
  53. export function getUrl() {
  54.   return window.location.href;
  55. }
  57. export function isFile(url) {
  58.   return url.includes('file://')
  59. }
  61. export function isHttp() {
  62.   return url.includes('http://')
  63. }
  65. export function isHttps() {
  66.   return url.includes('https://')
  67. }
  69. export function isLocalhost(url) {
  70.   const reg = /^(https?\:\/\/)(localhost|127\.0\.0\.1)(\:[\d]+)?(\/(.)*)?$/;
  71.   return reg.test(url);
  72. }
  76. // Number
  77. export function isFloat(value) {
  78.   return value % 1 !== 0;
  79. }
  83. // type类型
  84. export function isDate(value) {
  85.   return Object.prototype.toString.call(value) === '[object Date]';
  86. }
  88. export function isFunction(value) {
  89.   return typeof (value) === 'function';
  90. }
  92. export function isArray(value) {
  93.   if (Array.isArray) {
  94.     return Array.isArray(value);
  95.   }
  96.   return (Object.prototype.toString.call(value) === '[object Array]');
  97. }
  99. export function isObject(value) {
  100.   return Object.prototype.toString.call(value) === '[object Object]';
  101. }
  103. export function isBoolean() {
  104.   return typeof (val) === 'boolean'
  105. }
  107. export function isError(value) {
  108.   return value instanceof Error;
  109. }
  111. export function isNumber(value) {
  112.   return typeof (value) === 'number' && !isNaN(value) && isFinite(value)
  113. }
  115. export function isNull() {
  116.   // undefined, null
  117.   return value == null;
  118. }
  120. export function isRegExp(value) {
  121.   return value instanceof RegExp;
  122. }
  124. export function isString(value) {
  125.   return typeof (value) === 'string';
  126. }
  128. export function isJSON(value) {
  129.   if (!isString(value)) return false;
  131.   try {
  132.     const values = JSON.parse(value);
  133.     return values !== null && typeof (values) === 'object';
  134.   } catch (e) {
  135.     return false;
  136.   }
  137. }
  139. export function isBase64() {
  140.   if (!isString(value) || value.trim() === '') return false;
  142.   try {
  143.     return btoa(atob(value)) == value;
  144.   } catch (e) {
  145.     return false;
  146.   }
  147. }
  148. export function isUndefined(value) {
  149.   return typeof (value) === 'undefined';
  150. }
  152. export function isNaN(value) {
  153.   return isNaN(value);
  154. }
  155. export function isBase64() {
  157. }
  158. export function isDate() { }
  159. export function isDate() { }
  160. export function isDate() { }
  161. export function isDate() { }
  164. export function isEqual(value, value2) {
  165.   if (Object.is(value, value2)) return true;
  167.   return JSON.stringify(value) === JSON.stringify(value2);
  168. }
  172. // String
  173. export function trimAll(value) {
  174.   return value.replace(/^[\s]+|[\s]+$/gm, '');
  175. }
  177. export function trimLeft(value) {
  178.   return value.replace(/^[\s]+/gm, '');
  179. }
  181. export function trimRight(value) {
  182.   return value.replace(/[\s]+$/gm, '');
  183. }
  186. export function decodeBase64(string) {
  187.   let value = '';
  188.   const input = string.replace(/[^A-Za-z0-9\+\/\=]/g, '');
  190.   try {
  191.     value = window.atob(input);
  192.   } catch (e) {
  193.     const chars = {
  194.       'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9, 'K': 10, 'L': 11, 'M': 12,
  195.       'N': 13, 'O': 14, 'P': 15, 'Q': 16, 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24, 'Z': 25,
  196.       'a': 26, 'b': 27, 'c': 28, 'd': 29, 'e': 30, 'f': 31, 'g': 32, 'h': 33, 'i': 34, 'j': 35, 'k': 36, 'l': 37, 'm': 38,
  197.       'n': 39, 'o': 40, 'p': 41, 'q': 42, 'r': 43, 's': 44, 't': 45, 'u': 46, 'v': 47, 'w': 48, 'x': 49, 'y': 50, 'z': 51,
  198.       '0': 52, '1': 53, '2': 54, '3': 55, '4': 56, '5': 57, '6': 58, '7': 59, '8': 60, '9': 61, '+': 62, '/': 63, '=': 64
  199.     };
  200.     let chr1, chr2, chr3;
  201.     let enc1, enc2, enc3, enc4;
  203.     let i = 0;
  204.     let j = input.length;
  205.     while (i < j) {
  206.       enc1 = chars[input.charAt(i++)];
  207.       enc2 = chars[input.charAt(i++)];
  208.       enc3 = chars[input.charAt(i++)];
  209.       enc4 = chars[input.charAt(i++)];
  211.       chr1 = ((enc1 << 2) | (enc2 >> 4));
  212.       chr2 = (((enc2 & 15) << 4) | (enc3 >> 2));
  213.       chr3 = (((enc3 & 3) << 6) | enc4);
  215.       value += String.fromCharCode(chr1);
  217.       if (enc3 !== 64) {
  218.         value += String.fromCharCode(chr2);
  219.       }
  220.       if (enc4 !== 64) {
  221.         value += String.fromCharCode(chr3);
  222.       }
  223.     }
  224.   }
  226.   return decodeURIComponent(value);
  227. }
  229. export function encodeBase64(string) {
  230.   // const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  231.   const input = encodeURIComponent(string);
  232.   let value = '';
  234.   try {
  235.     value = window.btoa(input);
  236.   } catch (e) {
  237.     const chars = [
  238.       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  239.       'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  240.       'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
  241.       'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
  242.       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='
  243.     ];
  244.     let chr1, chr2, chr3;
  245.     let enc1, enc2, enc3, enc4;
  247.     let i = 0;
  248.     let j = input.length;
  250.     while (i < j) {
  251.       chr1 = input.charCodeAt(i++);
  252.       chr2 = input.charCodeAt(i++);
  253.       chr3 = input.charCodeAt(i++);
  255.       enc1 = (chr1 >> 2);
  256.       enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
  257.       enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
  258.       enc4 = (chr3 & 63);
  260.       if (isNaN(chr2)) {
  261.         enc3 = enc4 = 64;
  262.       } else if (isNaN(chr3)) {
  263.         enc4 = 64;
  264.       }
  265.       value += (chars[enc1] + chars[enc2] + chars[enc3] + chars[enc4]);
  266.     }
  267.   }
  269.   return value;
  270. }
  273. export function noop() {
  274.   return true;
  275. }
  277. export function yymmdd(date, separator = '-') {
  278.   var d = (date || new Date());
  279.   var year = d.getFullYear();
  280.   var month = d.getMonth() + 1; // getMonth() 从 0开始
  281.   var day = d.getDate();
  282.   return `${year}${separator}${padStart(month)}${separator}${padStart(day)}`
  283. }
  285. export function padStart(value, length = 2) {
  286.   return String(value).padStart(length, 0);
  287. }
  289. export function normalize() {
  290.   return {
  291.     milliseconds: (ms % 1000),
  292.     seconds: (Math.floor(ms / 1000) % 60),
  293.     minutes: (Math.floor(ms / 1000 / 60) % 60),
  294.     hours: (Math.floor(ms / 1000 / 60 / 60) % 24),
  295.     days: (Math.floor(ms / 1000 / 60 / 60 / 24))
  296.   }
  297. }