JavaScript中的50+个实用工具函数小结

JavaScript可以做很多出色的事情,本篇文章给大家整理50+个实用工具函数,可以帮助你提高工作效率并可以帮助调试代码

1、isStatic: 检测数据是不是除了symbol外的原始数据。

function isStatic(value) {
    return (
        typeof value === 'string' ||
        typeof value === 'number' ||
        typeof value === 'boolean' ||
        typeof value === 'undefined' ||
        value === null
    )
}

2、isPrimitive:检测数据是不是原始数据

function isPrimitive(value) {
    return isStatic(value) || typeof value === 'symbol'
}

3、isObject:判断数据是不是引用类型的数据(例如:array,function,object,regexe,new Number(),new String())

function isObject(value) {
    let type = typeof value;
    return value != null && (type == 'object' || type == 'function');
}

4、isObjectLike:检查value是否是类对象。如果一个值是类对象,那么它不应该是null,而且typeof后的结果是“object”。

function isObjectLike(value) {
    return value != null && typeof value == 'object';
}

5、getRawType:获取数据类型,返回结果为Number、String、Object、Array等

function getRawType(value) {
    return Object.prototype.toString.call(value).slice(8, -1)
}
// getoRawType([]) ⇒ Array

6、isPlainObject:判断数据是不是Object类型的数据

function isPlainObject(obj) {
    return Object.prototype.toString.call(obj) === '[object Object]'
}

7、isArray:判断数据是不是数组类型的数据(Array.isArray的兼容写法)

function isArray(arr) {
    return Object.prototype.toString.call(arr) === '[object Array]'
}

// 将isArray挂载到Array上
Array.isArray = Array.isArray || isArray;

8、isRegExp:判断数据是不是正则对象

function isRegExp(value) {
    return Object.prototype.toString.call(value) === '[object RegExp]'
}

9、isDate:判断数据是不是时间对象

function isDate(value) {
    return Object.prototype.toString.call(value) === '[object Date]'
}

10、isNative:判断value是不是浏览器内置函数

内置函数toString后的主体代码块为[native code] ,而非内置函数则为相关代码,所以非内置函数可以进行拷贝(toString后掐头去尾再由Function转)

function isNative(value) {
    return typeof value === 'function' && /native code/.test(value.toString())
}

11、isFunction:检查value是不是函数

function isFunction(value) {
    return Object.prototype.toString.call(value) === '[object Function]'
}

12、isLength:检查value是否为有效的类数组长度

function isLength(value) {
    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= Number.MAX_SAFE_INTEGER;
}

13、isArrayLike:检查value是否是类数组

如果一个值被认为是类数组,那么它不是一个函数,并且value.length是个整数,大于等于0,小于或等于Number.MAX_SAFE_INTEGER。这里字符串也被当作类数组。

function isArrayLike(value) {
    return value != null && isLength(value.length) && !isFunction(value);
}

14、isEmpty:检查value是否为空

如果是null,直接返回true;如果是类数组,判断数据长度;如果是Object对象,判断是否具有属性;如果是其他数据,直接返回false(也可以改为返回true)

function isEmpty(value) {
    if (value == null) {
        return true;
    }
    if (isArrayLike(value)) {
        return !value.length;
    } else if (isPlainObject(value)) {
        for (let key in value) {
            if (hasOwnProperty.call(value, key)) {
                return false;
            }
        }
    }
    return false;
}

15、cached:记忆函数:缓存函数的运算结果

function cached(fn) {
    let cache = Object.create(null);
    return function cachedFn(str) {
        let hit = cache[str];
        return hit || (cache[str] = fn(str))
    }
}

16、camelize:横线转驼峰命名

let camelizeRE = /-(\w)/g;
function camelize(str) {
    return str.replace(camelizeRE, function(_, c) {
        return c ? c.toUpperCase() : '';
    })
}
//ab-cd-ef ==> abCdEf
//使用记忆函数
let _camelize = cached(camelize)

17、hyphenate:驼峰命名转横线命名:拆分字符串,使用-相连,并且转换为小写

let hyphenateRE = /\B([A-Z])/g;
function hyphenate(str){
    return str.replace(hyphenateRE, '-$1').toLowerCase()
}
//abCd ==> ab-cd
//使用记忆函数
let _hyphenate = cached(hyphenate);

18、capitalize:字符串首位大写

function capitalize(str) {
    return str.charAt(0).toUpperCase() + str.slice(1)
}
// abc ==> Abc
//使用记忆函数
let _capitalize = cached(capitalize)

19、extend:将属性混合到目标对象中

function extend(to, _form) {
    for(let key in _form) {
        to[key] = _form[key];
    }
    return to
}

20、Object.assign:对象属性复制,浅拷贝

Object.assign = Object.assign || function() {
    if (arguments.length == 0) throw new TypeError('Cannot convert undefined or null to object');
    let target = arguments[0],
        args = Array.prototype.slice.call(arguments, 1),
        key;
    args.forEach(function(item) {
        for (key in item) {
            item.hasOwnProperty(key) && (target[key] = item[key])
        }
    })
    return target
}

使用Object.assign可以钱克隆一个对象:

let clone = Object.assign({}, target);

简单的深克隆可以使用JSON.parse()和JSON.stringify(),这两个api是解析json数据的,所以只能解析除symbol外的原始类型及数组和对象。

let clone = JSON.parse( JSON.stringify(target) )

21、clone:克隆数据,可深度克隆

这里列出了原始类型,时间、正则、错误、数组、对象的克隆规则,其他的可自行补充

function clone(value, deep) {
    if (isPrimitive(value)) {
        return value
    }
    if (isArrayLike(value)) {  //是类数组
        value = Array.prototype.slice.call(vall)
        return value.map(item => deep ? clone(item, deep) : item)
    } else if (isPlainObject(value)) {  //是对象
        let target = {}, key;
        for (key in value) {
            value.hasOwnProperty(key) && ( target[key] = deep ? clone(value[key], value[key] ))
        }
    }
    let type = getRawType(value);
    switch(type) {
        case 'Date':
        case 'RegExp':
        case 'Error': value = new window[type](value); break;
    }
    return value
}

22、识别各种浏览器及平台

//运行环境是浏览器
let inBrowser = typeof window !== 'undefined';
//运行环境是微信
let inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
let weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
//浏览器 UA 判断
let UA = inBrowser && window.navigator.userAgent.toLowerCase();
let isIE = UA && /msie|trident/.test(UA);
let isIE9 = UA && UA.indexOf('msie 9.0') > 0;
let isEdge = UA && UA.indexOf('edge/') > 0;
let isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
let isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
let isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;

23、getExplorerInfo:获取浏览器信息

function getExplorerInfo() {
    let t = navigator.userAgent.toLowerCase();
    return 0 <= t.indexOf("msie") ? { //ie < 11
        type: "IE",
        version: Number(t.match(/msie ([\d]+)/)[1])
    } : !!t.match(/trident\/.+?rv:(([\d.]+))/) ? { // ie 11
        type: "IE",
        version: 11
    } : 0 <= t.indexOf("edge") ? {
        type: "Edge",
        version: Number(t.match(/edge\/([\d]+)/)[1])
    } : 0 <= t.indexOf("firefox") ? {
        type: "Firefox",
        version: Number(t.match(/firefox\/([\d]+)/)[1])
    } : 0 <= t.indexOf("chrome") ? {
        type: "Chrome",
        version: Number(t.match(/chrome\/([\d]+)/)[1])
    } : 0 <= t.indexOf("opera") ? {
        type: "Opera",
        version: Number(t.match(/opera.([\d]+)/)[1])
    } : 0 <= t.indexOf("Safari") ? {
        type: "Safari",
        version: Number(t.match(/version\/([\d]+)/)[1])
    } : {
        type: t,
        version: -1
    }
}

24、isPCBroswer:检测是否为PC端浏览器模式

function isPCBroswer() {
    let e = navigator.userAgent.toLowerCase()
        , t = "ipad" == e.match(/ipad/i)
        , i = "iphone" == e.match(/iphone/i)
        , r = "midp" == e.match(/midp/i)
        , n = "rv:1.2.3.4" == e.match(/rv:1.2.3.4/i)
        , a = "ucweb" == e.match(/ucweb/i)
        , o = "android" == e.match(/android/i)
        , s = "windows ce" == e.match(/windows ce/i)
        , l = "windows mobile" == e.match(/windows mobile/i);
    return !(t || i || r || n || a || o || s || l)
}

25、unique: 数组去重,返回一个新数组

function unique(arr){
    if(!isArrayLink(arr)){ //不是类数组对象
        return arr
    }
    let result = []
    let objarr = []
    let obj = Object.create(null)

    arr.forEach(item => {
        if(isStatic(item)){//是除了symbol外的原始数据
            let key = item + '_' + getRawType(item);
            if(!obj[key]){
                obj[key] = true
                result.push(item)
            }
        }else{//引用类型及symbol
            if(!objarr.includes(item)){
                objarr.push(item)
                result.push(item)
            }
        }
    })

    return resulte
}

26、Set简单实现

window.Set = window.Set || (function () {
    function Set(arr) {
        this.items = arr ? unique(arr) : [];
        this.size = this.items.length; // Array的大小
    }
    Set.prototype = {
        add: function (value) {
            // 添加元素,若元素已存在,则跳过,返回 Set 结构本身。
            if (!this.has(value)) {
                this.items.push(value);
                this.size++;
            }
            return this;
        },
        clear: function () {
            //清除所有成员,没有返回值。
            this.items = []
            this.size = 0
        },
        delete: function (value) {
            //删除某个值,返回一个布尔值,表示删除是否成功。
            return this.items.some((v, i) => {
                if(v === value){
                    this.items.splice(i,1)
                    return true
                }
                return false
            })
        },
        has: function (value) {
            //返回一个布尔值,表示该值是否为Set的成员。
            return this.items.some(v => v === value)
        },
        values: function () {
            return this.items
        },
    }

    return Set;
}());

27、repeat:生成一个重复的字符串,有n个str组成,可修改为填充为数组等

function repeat(str, n) {
    let res = '';
    while(n) {
        if(n % 2 === 1) {
            res += str;
        }
        if(n > 1) {
            str += str;
        }
        n >>= 1;
    }
    return res
};
//repeat('123',3) ==> 123123123

28、dateFormater:格式化时间

function dateFormater(formater, t){
    let date = t ? new Date(t) : new Date(),
        Y = date.getFullYear() + '',
        M = date.getMonth() + 1,
        D = date.getDate(),
        H = date.getHours(),
        m = date.getMinutes(),
        s = date.getSeconds();
    return formater.replace(/YYYY|yyyy/g,Y)
        .replace(/YY|yy/g,Y.substr(2,2))
        .replace(/MM/g,(M<10?'0':'') + M)
        .replace(/DD/g,(D<10?'0':'') + D)
        .replace(/HH|hh/g,(H<10?'0':'') + H)
        .replace(/mm/g,(m<10?'0':'') + m)
        .replace(/ss/g,(s<10?'0':'') + s)
}
// dateFormater('YYYY-MM-DD HH:mm', t) ==> 2019-06-26 18:30
// dateFormater('YYYYMMDDHHmm', t) ==> 201906261830

29、dateStrForma:将指定字符串由一种时间格式转化为另一种。From的格式应对应str的位置

function dateStrForma(str, from, to){
    //'20190626' 'YYYYMMDD' 'YYYY年MM月DD日'
    str += ''
    let Y = ''
    if(~(Y = from.indexOf('YYYY'))){
        Y = str.substr(Y, 4)
        to = to.replace(/YYYY|yyyy/g,Y)
    }else if(~(Y = from.indexOf('YY'))){
        Y = str.substr(Y, 2)
        to = to.replace(/YY|yy/g,Y)
    }

    let k,i
    ['M','D','H','h','m','s'].forEach(s =>{
        i = from.indexOf(s+s)
        k = ~i ? str.substr(i, 2) : ''
        to = to.replace(s+s, k)
    })
    return to
}
// dateStrForma('20190626', 'YYYYMMDD', 'YYYY年MM月DD日') ==> 2019年06月26日
// dateStrForma('121220190626', '----YYYYMMDD', 'YYYY年MM月DD日') ==> 2019年06月26日
// dateStrForma('2019年06月26日', 'YYYY年MM月DD日', 'YYYYMMDD') ==> 20190626

// 一般的也可以使用正则来实现
//'2019年06月26日'.replace(/(\d{4})年(\d{2})月(\d{2})日/, '$1-$2-$3') ==> 2019-06-26

30、getPropByPath:根据字符串路径获取对象属性:‘obj[0].count'

function getPropByPath(obj, path, strict) {
      let tempObj = obj;
      path = path.replace(/\[(\w+)\]/g, '.$1'); //将[0]转化为.0
      path = path.replace(/^\./, ''); //去除开头的.

      let keyArr = path.split('.'); //根据.切割
      let i = 0;
      for (let len = keyArr.length; i < len - 1; ++i) {
        if (!tempObj && !strict) break;
        let key = keyArr[i];
        if (key in tempObj) {
            tempObj = tempObj[key];
        } else {
            if (strict) {//开启严格模式,没找到对应key值,抛出错误
                throw new Error('please transfer a valid prop path to form item!');
            }
            break;
        }
      }
      return {
        o: tempObj, //原始数据
        k: keyArr[i], //key值
        v: tempObj ? tempObj[keyArr[i]] : null // key值对应的值
      };
};

31、GetUrlParam:获取Url参数,返回一个对象

function GetUrlParam(){
    let url = document.location.toString();
    let arrObj = url.split("?");
    let params = Object.create(null)
    if (arrObj.length > 1){
        arrObj = arrObj[1].split("&");
        arrObj.forEach(item=>{
            item = item.split("=");
            params[item[0]] = item[1]
        })
    }
    return params;
}
// ?a=1&b=2&c=3 ==> {a: "1", b: "2", c: "3"}

32、downloadFile:base64数据导出文件,文件下载

function downloadFile(filename, data) {
    let DownloadLink = document.createElement('a');
    if (DownloadLink) {
        document.body.appendChild(DownloadLink);
        DownloadLink.style = 'display: none';
        DownloadLink.download = filename;
        DownloadLink.href = data;
        if (document.createEvent) {
            let DownloadEvt = document.createEvent('MouseEvents');
            DownloadEvt.initEvent('click', true, false);
            DownloadLink.dispatchEvent(DownloadEvt);
        } else if (document.createEventObject) {
            DownloadLink.fireEvent('onclick');
        } else if (typeof DownloadLink.onclick == 'function') {
            DownloadLink.onclick();
        }
        document.body.removeChild(DownloadLink);
    }
}

33、toFullScreen:全屏

function toFullScreen() {
    let elem = document.body;
    elem.webkitRequestFullScreen
    ? elem.webkitRequestFullScreen()
    : elem.mozRequestFullScreen
    ? elem.mozRequestFullScreen()
    : elem.msRequestFullscreen
    ? elem.msRequestFullscreen()
    : elem.requestFullScreen
    ? elem.requestFullScreen()
    : alert("浏览器不支持全屏");
}

34、exitFullscreen:退出全屏

function exitFullscreen() {
    let elem = parent.document;
    elem.webkitCancelFullScreen
    ? elem.webkitCancelFullScreen()
    : elem.mozCancelFullScreen
    ? elem.mozCancelFullScreen()
    : elem.cancelFullScreen
    ? elem.cancelFullScreen()
    : elem.msExitFullscreen
    ? elem.msExitFullscreen()
    : elem.exitFullscreen
    ? elem.exitFullscreen()
    : alert("切换失败,可尝试Esc退出");
}

35、requestAnimationFrame:window动画

window.requestAnimationFrame = window.requestAnimationFrame ||
    window.webkitRequestAnimationFrame ||
    window.mozRequestAnimationFrame ||
    window.msRequestAnimationFrame ||
    window.oRequestAnimationFrame ||
    function (callback) {
        //为了使setTimteout的尽可能的接近每秒60帧的效果
        window.setTimeout(callback, 1000 / 60);
    }
window.cancelAnimationFrame = window.cancelAnimationFrame ||
    window.webkitCancelAnimationFrame ||
    window.mozCancelAnimationFrame ||
    window.msCancelAnimationFrame ||
    window.oCancelAnimationFrame ||
    function (id) {
        //为了使setTimteout的尽可能的接近每秒60帧的效果
        window.clearTimeout(id);
    }

36、_isNaN:检查数据是否是非数字值

function _isNaN(v){
    return !(typeof v === 'string' || typeof v === 'number') || isNaN(v)
}

37、max:求取数组中非NaN数据中的最大值

function max(arr){
    arr = arr.filter(item => !_isNaN(item))
    return arr.length ? Math.max.apply(null, arr) : undefined
}
//max([1, 2, '11', null, 'fdf', []]) ==> 11

38、min:求取数组中非NaN数据中的最小值

function min(arr){
    arr = arr.filter(item => !_isNaN(item))
    return arr.length ? Math.min.apply(null, arr) : undefined
}
//min([1, 2, '11', null, 'fdf', []]) ==> 1

39、random:返回一个lower-upper直接的随机数。(lower、upper无论正负与大小,但必须是非NaN的数据)

function random(lower, upper) {
    lower = +lower || 0
    upper = +upper || 0
    return Math.random() * (upper - lower) + lower;
}
//random(0, 0.5) ==> 0.3567039135734613
//random(2, 1) ===> 1.6718418553475423
//random(-2, -1) ==> -1.4474325452361945

40、Object.keys:返回一个由一个给定对象的自身可枚举属性组成的数组

Object.keys = Object.keys || function keys(object) {
    if (object === null || object === undefined) {
        throw new TypeError('Cannot convert undefined or null to object');
    }
    let result = [];
    if (isArrayLike(object) || isPlainObject(object)) {
        for (let key in object) {
            object.hasOwnProperty(key) && (result.push(key))
        }
    }
    return result;
}

41、Object.values:返回一个给定对象自身的所有可枚举属性值的数组

Object.values = Object.values || function values(object) {
    if (object === null || object === undefined) {
        throw new TypeError('Cannot convert undefined or null to object');
    }
    let result = [];
    if (isArrayLike(object) || isPlainObject(object)) {
        for (let key in object) {
            object.hasOwnProperty(key) && (result.push(object[key]))
        }
    }
    return result;
}

42、arr.fill:使用value值填充array,从start位置开始,到end位置结束(但不包含end位置),返回原数组

Array.prototype.fill = Array.prototype.fill || function fill(value, start, end) {
    let ctx = this
    let length = ctx.length;

    start = parseInt(start)
    if(isNaN(start)){
        start = 0
    }else if (start < 0) {
        start = -start > length ? 0 : (length + start);
      }

      end = parseInt(end)
      if(isNaN(end) || end > length){
          end = length
      }else if (end < 0) {
        end += length;
    }

    while (start < end) {
        ctx[start++] = value;
    }
    return ctx;
}
//Array(3).fill(2) ===> [2, 2, 2]

43、arr.includes:用来判断一个数组是否包含一个指定的值,如果是返回true,否则返回false,可指定开始查询的位置

Array.prototype.includes = Array.prototype.includes || function includes(value, start) {
    let ctx = this;
    let length = ctx.length;
    start = parseInt(start)
    if(isNaN(start)) {
        start = 0
    } else if (start < 0) {
        start = -start > length ? 0 : (length + start);
    }
    let index = ctx.indexOf(value);
    return index >= start;
}

44、返回数组中通过测试(函数fn内判断)的第一个元素的值

Array.prototype.find = Array.prototype.find || function find(fn, ctx) {
    ctx = ctx || this;
    let result;
    ctx.some((value, index, arr), thisValue) => {
        return fn(value, index, arr) ? (result = value, true) : false
    })
    return result
}

45、arr.findIndex:返回数组中通过测试(函数fn内判断)的第一个元素的下标

Array.prototype.findIndex = Array.prototype.findIndex || function findIndex(fn, ctx){
    ctx = ctx || this

    let result;
    ctx.some((value, index, arr), thisValue) => {
        return fn(value, index, arr) ? (result = index, true) : false
    })

    return result
}

46、performance.timing:利用performance.timing进行性能分析

window.onload = function() {
    setTimeout(function() {
        let t = performance.timing;
        console.log('DNS查询耗时 :' + (t.domainLookupEnd - t.domainLookupStart).toFixed(0))
        console.log('TCP链接耗时 :' + (t.connectEnd - t.connectStart).toFixed(0))
        console.log('request请求耗时 :' + (t.responseEnd - t.responseStart).toFixed(0))
        console.log('解析dom树耗时 :' + (t.domComplete - t.domInteractive).toFixed(0))
        console.log('白屏时间 :' + (t.responseStart - t.navigationStart).toFixed(0))
        console.log('domready时间 :' + (t.domContentLoadedEventEnd - t.navigationStart).toFixed(0))
        console.log('onload时间 :' + (t.loadEventEnd - t.navigationStart).toFixed(0))
        if (t = performance.memory) {
            console.log('js内存使用占比:' +  (t.usedJSHeapSize / t.totalJSHeapSize * 100).toFixed(2) + '%')
        }
    })
}

47、禁止某些键盘事件

document.addEventListener('keydown', function(event) {
    return !(
        112 == event.keyCode ||        //禁止F1
        123 == event.keyCode ||        //禁止F12
        event.ctrlKey && 82 == event.keyCode ||        //禁止ctrl+R
        event.ctrlKey && 18 == event.keyCode ||        //禁止ctrl+N
        event.shiftKey && 121 == event.keyCode ||          //禁止shift+F10
        event.altKey && 115 == event.keyCode ||        //禁止alt+F4
        "A" == event.srcElement.tagName && event.shiftKey        //禁止shift+点击a标签
    ) || (event.returnValue = false)
});

48、禁止右键、选择、复制

['contextmenu', 'selectstart', 'copy'].forEach(function(ev) {
    document.addEventListener(ev, function(event) {
        return event.returnValue = false;
    })
});

49、numAdd - -计算数字相加

function numAdd(num1, num2) {
    let baseNum, baseNum1, baseNum2;
    try {
        baseNum1 = num1.toString().split(".")[1].length;
    } catch (e) {
        baseNum1 = 0;
    }
    try {
        baseNum2 = num2.toString().split(".")[1].length;
    } catch (e) {
        baseNum2 = 0;
    }
    baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
    return (num1 * baseNum + num2 * baseNum) / baseNum;
};

50、numSub - - 计算数字相减

function numSub(num1, num2) {
    let baseNum, baseNum1, baseNum2;
    let precision;// 精度
    try {
        baseNum1 = num1.toString().split(".")[1].length;
    } catch (e) {
        baseNum1 = 0;
    }
    try {
        baseNum2 = num2.toString().split(".")[1].length;
    } catch (e) {
        baseNum2 = 0;
    }
    baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
    precision = (baseNum1 >= baseNum2) ? baseNum1 : baseNum2;
    return ((num1 * baseNum - num2 * baseNum) / baseNum).toFixed(precision);
};

51、numMulti - - 计算数字相乘

function numMulti(num1, num2) {
    let baseNum = 0;
    try {
        baseNum += num1.toString().split(".")[1].length;
    } catch (e) {
    }
    try {
        baseNum += num2.toString().split(".")[1].length;
    } catch (e) {
    }
    return Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum);
};

52、numDiv - - 计算数字相除

function numDiv(num1, num2) {
    let baseNum1 = 0, baseNum2 = 0;
    let baseNum3, baseNum4;
    try {
        baseNum1 = num1.toString().split(".")[1].length;
    } catch (e) {
        baseNum1 = 0;
    }
    try {
        baseNum2 = num2.toString().split(".")[1].length;
    } catch (e) {
        baseNum2 = 0;
    }
    with (Math) {
        baseNum3 = Number(num1.toString().replace(".", ""));
        baseNum4 = Number(num2.toString().replace(".", ""));
        return (baseNum3 / baseNum4) * pow(10, baseNum2 - baseNum1);
    }
};

到此这篇关于JavaScript中的50+个实用工具函数小结的文章就介绍到这了,更多相关JavaScript 实用工具函数内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 如何让你的JavaScript函数更加优雅详解

    目录 对象参数使用解构 命名回调函数 让条件句具有描述性 用 Map 或 Object替换 switch 语句 使用 Object.assign 设置默认属性 删除重复代码,合并相似函数:删除弃用代码 提炼函数 总结 准备写一个js技巧系列,主要就是总结js各种实用的小窍门.小妙招.本文主要是研究如何让我们的函数更清晰明了. 对象参数使用解构 如果希望函数接收很多参数(如果超过两个),那么就应该使用对象.在此基础上,可以使用解构语法提取需要的参数. 普通写法 const greet = (obj

  • 关于JavaScript回调函数的深入理解

    前言 JavaScript回调函数是成为一名成功的 JavaScript 开发人员必须要了解的一个重要概念.但是我相信,在阅读本文之后,你将能够克服以前使用回调方法遇到的所有障碍. 在开始之前,首先要确保我们对函数的理解是扎实的. 快速回顾:JavaScript 函数 什么是函数? 函数是在其中有一组代码的逻辑构件,用来执行特定任务.实际上为了易于调试和维护,函数允许以更有组织的方式去编写代码.函数还允许代码重用. 你只需定义一次函数,然后在需要时去调用它,而不必一次又一次地编写相同的代码. 声

  • js中函数的length是多少

    目录 前言 为什么 到底是多少? 形参个数 默认参数 剩余参数 总结 前言 我今天给大家讲讲function的length,到底是怎么算的.希望大家能从中学到东西,并且可以巩固一下基础. 为什么 为什么我会想到这个知识点呢?因为昨晚,在一个群里,有一位同学在讨论一道字节跳动的面试题 123['toString'].length + 123 = ? 说实话这道题,我一开始也没答出来.其实我是知道,面试官想考Number原型上的toString方法,但是我卡在了toString函数的length是多

  • javascript函数式编程基础

    目录 一.引言 二.什么是函数式编程 三.纯函数(函数式编程的基石,无副作用的函数) 四.函数柯里化 五.函数组合 六.声明式和命令式代码 七.Point Free 八.示例应用 九.总结 一.引言 函数式编程的历史已经很悠久了,但是最近几年却频繁的出现在大众的视野,很多不支持函数式编程的语言也在积极加入闭包,匿名函数等非常典型的函数式编程特性.大量的前端框架也标榜自己使用了函数式编程的特性,好像一旦跟函数式编程沾边,就很高大上一样,而且还有一些专门针对函数式编程的框架和库,比如:RxJS.cy

  • 一篇文章教你JS函数继承

    目录 一. 前言: 二.原型链继承: 三.借用构造函数继承(对象伪装): 四.组合继承: 五.寄生组合继承: 六.class继承: 七.总结: 一. 前言: Hello,大家最近过得好吗,

  • JavaScript sleep睡眠函数的使用

    目录 1.sleep函数 2. setTimeout 3.Promise 4. async await 5. 1s后输出1 2s后输出2 3s后输出3 参考文章: 1.sleep函数 JavaScript是单线程运行的,没有内置的sleep函数,现在模拟实现sleep延迟执行的效果. 使用睡眠函数实现红绿灯代码,红灯2秒,黄灯1秒,绿灯3秒,循环改变颜色. 2. setTimeout 直接使用setTimeout实现sleep()的方法,兼容性最好,但是使用了回调函数的实现方式,代码的可读性和维

  • JavaScript中子函数访问外部变量的3种解决方法

    前言 我们在写web页面时,肯定会经常遇到下面这种情况: <body> <div class="btns-wrapper"></div> <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.3.1/jquery.min.js"></script> <script> var wrapper = $('.btns-wrapper'); fo

  • JavaScript基础系列之函数和方法详解

    目录 一.函数和方法的区别 二.如何写好一个函数 2.1 命名准确 2.1.1 函数命名 2.1.2 参数命名 2.2 函数注释 2.2.1 参数注释 2.3  函数参数 2.3.1 参数默认值 2.3.2 对象参数 2.3.3 参数数量 2.3.4 参数类型防御 2.4 函数的返回 2.4.1 幂等函数 2.4.2 纯函数 2.4.3 return null 函数和方法的区别 总结 一.函数和方法的区别 函数(function):函数是带有名称和参数的 JavaScript 代码段,可以一次定

  • php中对内置函数json_encode和json_decode的异常处理

    在php中,json_encode和json_decode是很常用的函数,具体用法可以查看相关文档,这里主要说一下错误处理. 平时我们在使用这两个方法的时候可能没怎么注意错误处理,有时候如果传入的参数格式不正确就会导致报错了.下面是错误处理的方式: json_last_error - 返回最后发生的错误,如果有,返回 JSON 编码解码时最后发生的错误. int json_last_error ( void ) 常量 含义 可用性 JSON_ERROR_NONE 没有错误发生 JSON_ERRO

  • JavaScript中的50+个实用工具函数小结

    JavaScript可以做很多出色的事情,本篇文章给大家整理50+个实用工具函数,可以帮助你提高工作效率并可以帮助调试代码 1.isStatic: 检测数据是不是除了symbol外的原始数据. function isStatic(value) { return ( typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'undefined'

  • JavaScript中判断变量是数组、函数或是对象类型的方法

    数组 ECMAScript5中Array.isArray是原生的判断数组的方法,IE9及以上支持.考虑到兼容性,在没有此方法的浏览器中,可以使用 Object.prototype.toString.call(obj) === '[object Array]'替代. 复制代码 代码如下: var isArray = Array.isArray || function(obj) {     return Object.prototype.toString.call(obj) === '[object

  • javascript中对Date类型的常用操作小结

    javascript中对Date类型的常用操作小结 /** 3. * 日期时间脚本库方法列表: 4. * (1)Date.isValiDate:日期合法性验证 5. * (2)Date.isValiTime:时间合法性验证 6. * (3)Date.isValiDateTime:日期和时间合法性验证 7. * (4)Date.prototype.isLeapYear:判断是否闰年 8. * (5)Date.prototype.format:日期格式化 9. * (6)Date.stringToD

  • JavaScript中find()和 filter()方法的区别小结

    目录 前言 JavaScript find() 方法 JavaScript filter() 方法 find() 和 filter() 的区别与共点 直接上代码 总结 前言 JavaScript 在 ES6 上有很多数组方法,每种方法都有独特的用途和好处. 在开发应用程序时,大多使用数组方法来获取特定的值列表并获取单个或多个匹配项. 在列出这两种方法的区别之前,我们先来一一了解这些方法. JavaScript find() 方法 ES6 find() 方法返回通过测试函数的第一个元素的值.如果没

  • javascript中的绑定与解绑函数应用示例

    Mozilla中: addEventListener的使用方式: target.addEventListener(type, listener, useCapture); target: 文档节点.document.window 或 XMLHttpRequest. type: 字符串,事件名称,不含"on",比如"click"."mouseover"."keydown"等. listener :实现了 EventListene

  • PHP常用工具函数小结【移除XSS攻击、UTF8与GBK编码转换等】

    本文实例总结了PHP常用工具函数.分享给大家供大家参考,具体如下: 移除XSS攻击脚本 function RemoveXSS($val) { // remove all non-printable characters. CR(0a) and LF(0b) and TAB(9) are allowed // this prevents some character re-spacing such as <java\0script> // note that you have to handle

  • javascript中关于类型判断的一些疑惑小结

    前言 类型判断是我们在日常工作中经常会遇到的一个功能,本文将给大家详细介绍关于javascript类型判断的相关内容,下面话不多说了,来一起看看详细的介绍吧 Javascript中数据类型分为两种: 简单数据类型:Undefined, NULL, Boolean, Number, String 复杂数据类型:Object 接下来我们就来看看怎么做数据类型判别吧? 首先来看看 typeof Type Result Undefined "undefined" Null "obje

  • 在javaScript中检测数据类型的几种方式小结

    在用javaScript编程的过程中,我们经常会遇到这样一个问题,就是需要检测一个数据或变量的类型,那么在javaScript中给我们提供了哪些方法呢?网上流传的代码比比皆是,但是发现其中有些是有误的,索性我自己动手把每种方法用了一遍,今天我专门整理了下,以便以后查阅. 一.typeof  检测 typeof 是一个一元运算符,语法:typeof(运算数),运算数可以是任意类型.它的返回值是一个字符串,该字符串说明运算数的类型. // var arr = { name:"john"};

  • javascript中Date format(js日期格式化)方法小结

    本文实例总结了javascript中日期格式化的方法.分享给大家供大家参考,具体如下: 方法一: // 对Date的扩展,将 Date 转化为指定格式的String // 月(M).日(d).小时(h).分(m).秒(s).季度(q) 可以用 1-2 个占位符, // 年(y)可以用 1-4 个占位符,毫秒(S)只能用 1 个占位符(是 1-3 位的数字) // 例子: // (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") ==> 200

  • PHP几个实用自定义函数小结

    本文实例总结了PHP几个实用自定义函数.分享给大家供大家参考,具体如下: 最近在看代码,发现以下是几个比较实用的函数. 1.取客户端IP function getOnlineIp() { $strOnlineIp = ""; if(getenv('HTTP_CLIENT_IP') && strcasecmp(getenv('HTTP_CLIENT_IP'), 'unknown')) { $onlineip = getenv('HTTP_CLIENT_IP'); } el

随机推荐