精华内容
下载资源
问答
  • R语言常用函数总结大全

    万次阅读 多人点赞 2017-03-12 09:01:58
    今天把R常用函数大体汇总了一下,其中包括一般数学函数,统计函数,概率函数,字符处理函数,以及一些其他函数; 1.数学函数 函数 作用 abs() 绝对值 sqrt() ...

    今天把R常用函数大体汇总了一下,其中包括一般数学函数,统计函数,概率函数,字符处理函数,以及一些其他函数;

     

    1.      数学函数

    函数

    作用

    abs()

    绝对值

    sqrt()

    平方根

    ceiling(x)

    不小于x的最小整数

    floor(x)

    不大于x的最大整数

    round(x, digits=n)

    将x舍入为指定位的小数

    signif(x, digits=n)

    将X舍入为指定的有效数字位数

     

     

    2.      统计函数

    函数

    作用

    mean(x)

    平均值

    median(x)

    中位数

    sd(x)

    标准差

    var(x)

    方差

    quantile(x, probs)

    求分位数,x为待求分位数的数值型向量,probs是一个由[0,1]的概率值组成的数值型向量

    range(x)

    求值域

    sum(x)

    求和

    min(x)

    求最小值

    max(x)

    求最大值

    scale(x, center=TRUE,scale=TRUE)

    以数据对象x按列进行中心化或标准化,center=TRUE表示数据中心化,scale=TRUE表示数据标准化

    diff(x, lag=n)

    滞后差分,lag用以指定滞后几项,默认为1

    difftime(time1,time2,units=c(“auto”,”secs”,”mins”,”hours”,”days”,”weeks”))

    计算时间间隔,并以星期,天,时,分,秒来表示

     

     

    3.      概率函数

    分布名称

    缩写

    beta分布

    beta

    二项分布

    binom

    柯西分布

    Cauchy

    卡方分布

    chisp

    指数分布

    exp

    F分布

    f

    gamma分布

    gamma

    几何分布

    geom

    超几何分布

    hyper

    对数正态分布

    lnorm

    logistics分布

    logis

    多项分布

    multinom

    负二项分布

    nbinom

    正态分布

    norm

    泊松分布

    pois

    Wilcoxon分布

    signrank

    t分布

    t

    均匀分布

    unif

    weibull分布

    weibull

    Wilcoxon秩和分布

    Wilcox

    在R中,函数函数行如:[x][function]。其中x表示指分布的某一方面,function表示分布名称的缩写。

    d->密度函数(density)

    p->分布函数(distribution function)

    q->分位数函数(quantile function)

    r->生成随机数函数

     

    4.      字符处理函数

    函数

    作用

    nchar

    计算字符数量

    substr(x,start,stop)

    提取或替换一个字符向量中的字串

    grep()

    正则表达式函数,用于查找。

    sub()

    正则表达式函数,用于替换

    strsplit(x,split,fixed=FALSE)

    在splits处分隔字符向量x中的元素

    paste( )

    连接字符串,sep为分隔符

    toupper( )

    小写字母转大写

    tolower( )

    大写字母转小写

     

     

    5.      其他实用函数

    函数

    作用

    length(x)

    获取对象x的长度

    seq(fom,to,by)

    生成一个从from到to间隔为by的序列

    rep(x,n)

    将x重复n遍

    cut(x,n)

    将x分隔为有着N个水平的因子

    pretty(x,n)

    创建分割点,将x分隔成n个区间

    cat(x,file,append)

    连接x对象,并将其输出到屏幕或文件中。

    rownames()

    修改行数据框行变量名

    colnames

    修改行数据框列变量名

    cbind

    根据列进行合并,前提是所有数据行数相等。

    rbind

    根据行进行合并,要求所有数据列数是相同的才能用rbind.

    runif(n, min, max )

    生成n个大于min,小于max的随机数

    rnorm(n, mean, sd )

     

    生成n个平均数为mean,标准差为sd的随机数

     

    注:博客也会发布在微信公众号《数据志》(原:《跟着菜鸟一起学R语言》),关注可以获取更多意想不到的资源。

    转载请注明原文链接:http://blog.csdn.net/wzgl__wh/article/details/61499027

     

     

     

    展开全文
  • * 常用函数封装 * author: slongzhang * date: 2021-01-06 */ (function(){ class Zsl{ constructor(){ // // 正则转义符号 // this.escapeSymbol = ['$','(',')','*','+','.','[',']','?','\\','/','^','{','}...

    这是我自己项目开发过程中对于复用性比较高的一些常用函数和正则的封装,最新代码请已gitee为准,如有疑问或bug欢迎讨论(更新时间:2021-04-04)
    gitee地址
    1.es6开发版

    /**
    * 常用函数封装
    * author: slongzhang
    * date: 2021-01-06
    */
    ( function( global, factory ) {
        "use strict";
        if ( typeof module === "object" && typeof module.exports === "object" ) {
    
            // For CommonJS and CommonJS-like environments where a proper `window`
            // is present, execute the factory and get zslBase.
            // For environments that do not have a `window` with a `document`
            // (such as Node.js), expose a factory as module.exports.
            // This accentuates the need for the creation of a real `window`.
            // e.g. var zslBase = require("zslBase")(window);
            // See ticket #14549 for more info.
            module.exports = global.document ?
                factory( global, true ) :
                function( w ) {
                    if ( !w.document ) {
                        throw new Error( "zslBase requires a window with a document" );
                    }
                    return factory( w );
                };
        } else {
            factory( global );
        }
    
    // Pass this if window is not defined yet
    } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
        "use strict";
        // 正则需要转义的字符
        let regEscapeCharacter = ['$','(',')','*','+','.','[',']','?','\\','/','^','{','}','!','|'];
        // 判断是否为空
        let _empty = function(_value){
            var result = true;// 默认不为空
            if(_value === null){
                result = true;
            }
            else if(typeof(_value) === 'object'){
                result = Object.keys(_value).length>0?false:true;
            }
            else{
                // 0的判断采用php empty弱判断数字0和字符串0都判断为假
                if( _value == 0 ){
                    result = true;
                }else{
                    result = _value?false:true;
                }
            }
            return result;
        }
    
        // 合成模板内部函数
        let _compileHtml = function(_template){
            const evalExpr = /<%=(.+?)%>/g;
            const expr = /<%([\s\S]+?)%>/g;
            _template = _template
                .replace(evalExpr, '`); \n echo( $1 ); \n echo(`')
                .replace(expr, '`); \n $1 \n echo(`');
            _template = 'echo(`' + _template + '`);';
            let script = `(function parse(data){
                let output = "";
                function echo(html){
                    output += html;
                }
                ${ _template }
                return output;
            })`;
            return script;
        }
        let zslBase = {};
        zslBase.version = "1.0.1";
        zslBase.author = 'slongzhang@qq.com';
        /**
        * 加载后才执行
        * _fn            function             一个可执行函数
        */
        zslBase.ready = function(_fn){
            if(typeof _fn !== 'function'){
                throw 'Fn is not a function!';
            }
            function completed() {
                document.removeEventListener( "DOMContentLoaded", completed );
                window.removeEventListener( "load", completed );
                _fn();
            }
            if ( document.readyState === "complete" ||
                ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
                // Handle it asynchronously to allow scripts the opportunity to delay ready
                window.setTimeout( _fn );
            } else {
                // Use the handy event callback
                document.addEventListener( "DOMContentLoaded", completed );
                // A fallback to window.onload, that will always work
                window.addEventListener( "load", completed );
            }
        }
        /**
        * 判断是否json字符串
        * _str          String
        * return        boolean
        .*/
        zslBase.isJson = function(_str){
            if (typeof _str === 'string') {
                try {
                    JSON.parse(_str);
                    return true;
                } catch(e) {}
            }
            return false;
        }
        /**
        * 判断是否是数字
        * val           All         任意要检查的变量
        * return        Boolean     返回ture Or false
        .*/
        zslBase.isNumeric = function(_val){
            // isNaN()函数 把空串 空格 以及NUll 按照0来处理 所以先去除 
            // if(_val === "" || _val === null){
            //     return false;
            // }
            // if(!isNaN(_val)){
            //     //对于空数组和只有一个数值成员的数组或全是数字组成的字符串,isNaN返回false,例如:'123'、[]、[2]、['123'],isNaN返回false,
            //     //所以如果不需要_val包含这些特殊情况,则这个判断改写为if(!isNaN(_val) && typeof _val === 'number' )
            //     return true; 
            // }else{
            //     return false;
            // }
            return _val !== "" && _val !== null && !isNaN(_val);
        }
    
        /**
        * trim基础函数
        * _string           String                要处理的原始字符串
        * _charlist         String                要去除的字符
        * _type             Integer               去除类型:0两边,1:左边,2右边
        .*/
        let _trimBase = function(_string,_charlist,type = 0){
            if(typeof _string !== 'string'){
                return _string;
            }
            if(typeof _charlist === 'undefined'){
                if(type === 1){
                    return _string.replace(/^\s+/gm,'');
                }
                else if(type === 2){
                    return _string.replace(/\s+$/gm,'');
                }
                else{
                    return _string.replace(/^\s+|\s+$/gm,'');
                }
            }
            _charlist = _charlist.split('');
            let zy = regEscapeCharacter,ps='';
            for(let item of _charlist){
                if(zy.includes(item)){
                    ps +='\\';
                }
                ps+=item;
            }
            let reg;
            if(type === 1){
                reg = new RegExp("\^"+ps+"+","gm");
            }
            else if(type === 2){
                reg = new RegExp(ps+"+$","gm");
            }
            else{
                reg = new RegExp("\^"+ps+"+|"+ps+"+$","gm");
            }
            return _string.replace(reg,'');
        }
    
        // 移除两侧指定字符
        zslBase.trim = function(_string,_charlist){
            return _trimBase(_string,_charlist,0);
        }
        
        // 移除左侧指定字符
        zslBase.ltrim = function(_string,_charlist){
            return _trimBase(_string,_charlist,1);
        }
    
        // 移除右侧指定字符
        zslBase.rtrim = function(_string,_charlist){
            return _trimBase(_string,_charlist,2);
        }
    
        /**
        * 获取时间戳,默认毫秒
        * _type                boolean            默认false输出到毫秒,true则输出到秒
        .*/
        zslBase.time = function(_type){
            var timestamp = (new Date()).valueOf();
            if(_type){
                // 返回秒
                timestamp = parseInt(timestamp/1000);
            }
            return timestamp;
        }
        /**
        * 时间计算器
        * _string                String|Integer            日期格式字符串或毫秒时间戳
        * _time                  String|Integer|Object     时间字符串|时间戳|new Date()出来的时间对象
        * 模拟php的strtotime,但未适配日期时间转时间戳,如需处理如 '2021-01-06'转时间戳请使用'0 s'方法如('0 s','2021-01-06')或直接使用new Date('2021-01-06').valueOf();
        .*/
        zslBase.strtotime = function(string, time, toms){
            let date, timestamp, msg = "参数格式错误,请参照 a b a b ……,a:正负数整型,b:单位year(y年),month(m月),week(w周),day(d日),hours(h时),minutes(i分),seconds(s秒)\r\n如: '2 day -1 hours'=》47小时后\r\n如: '-2 day 1 hours'=》47小时前";
            // 判断是否是时间参数
            let isDateParam = function(_str,_toms){
                let _date,_timestamp;
                if(typeof _str === 'undefined' || !_str || (typeof _str === 'object' && _str.length === 0)){
                    return new Date().valueOf();
                }
                // 判断下_str 是不是位于10至12位的纯阿拉伯数字,如果是转为毫秒时间戳
                // if(/^[1-9]\d{9,11}$/.test(_str)){
                //     _str*=1000;
                // }
                if(_str === 'now'){
                    _date = new Date();
                }else{
                    // 直接转处理_str如果是时间格式
                    _date = new Date(_str);
                }
                if(_date.toString() !== 'Invalid Date' && _date.toLocaleDateString() !== '1970/1/1'){
                    // _str就是时间值,参数二变成是否转为时间戳秒单位
                    // 判断第二个参数,如果为真则转为秒的单位
                    _timestamp = _date.valueOf();
                    if(_toms){
                        _timestamp = parseInt(_timestamp/1000);
                    }
                    return _timestamp;
                }
                return false;
            }
            // 判断string是否是直接时间字符串或时间对象,如果是直接返回值
            date = isDateParam(string,time);
            if(date && !isNaN(date)){
                return date;
            }
            // 判断_time参数
            date = isDateParam(time, false);
            if(date && !isNaN(date)){
                timestamp = date;
                date = new Date(date);
            }else{
                date = new Date();
                timestamp = date.valueOf();
            }
            let values,unitNames;
            try {
                // 提取数值和单位,只保留数字和加减点
                values = string.replace(/[^\d-+.]+/g,'_#_').split('_#_').filter(function (s) {
                   return s && parseInt(s);
                });
                // 单位名,只保留纯字母
                unitNames = string.replace(/[^\a-zA-Z]+/g,'_#_').split('_#_').filter(function (s) {
                   return s && s.trim();
                });
            } catch(error) {
                throw msg;
            }
            let oneDayTamp = 86400000, uniqueUnit = {},temp;
            for(let ii = 0; ii < values.length; ii++){
                if(unitNames[ii] === 'minutes'){
                    unitNames[ii] = 'i';
                }
                if(unitNames[ii] && !uniqueUnit.hasOwnProperty(unitNames[ii][0])){
                    let val = parseInt(values[ii]);
                    uniqueUnit[unitNames[ii][0]] = 1;// 取单位的首字母
                    switch(unitNames[ii]){
                        case 'y':
                            // no break;
                        case 'year':
                            temp = new Date(timestamp);
                            temp.setFullYear(temp.getFullYear() + val);
                            timestamp = temp.valueOf();
                            break;
                        case 'm':
                            // no break;
                        case 'month':
                            temp = new Date(timestamp);
                            temp.setMonth(temp.getMonth() + val);
                            timestamp = temp.valueOf();
                            break;
                        case 'w':
                            // no break;
                        case 'week':
                            timestamp += val*604800000;
                            break;
                        case 'd':
                            // no break;
                        case 'day':
                            timestamp += val*86400000;
                            break;
                        case 'h':
                            // no break;
                        case 'hours':
                            timestamp += val*3600000;
                            break;
                        case 'i':
                            // no break;
                        case 'minutes':
                            timestamp += val*60000;
                            break;
                        case 's':
                            // no break;
                        case 'seconds':
                            timestamp += val*1000;
                            break;
                    }
                }
            }
            if(toms){
                timestamp = parseInt(timestamp/1000);
            }
            return timestamp;
        }
    
        /**
        * 获取指定日期格式(代完善)
        * _format            String|Integer            日期格式字符串"Y-m-d H:i:s"或毫秒时间戳
        * _time              String|int|object         时间字符串|时间戳|new Date()出来的时间对象
        .*/
        zslBase.date = function(_format,_time){
            let timeIsObject = false;
            // 如果两个参数都为空则,全部采用默认
            if(typeof _format === 'undefined' && typeof _time === 'undefined'){
                timeIsObject = true;
                _format = 'Y-m-d H:i:s';
                _time = new Date();
            }
            else if(!_format){
                _format = 'Y-m-d H:i:s';
            }
            else if(_format && typeof _time === 'undefined'){
                // // 判断下_str 是不是位于10至12位的纯阿拉伯数字,如果是转为毫秒时间戳
                // if(/^[1-9]\d{9,11}$/.test(_format)){
                //     _format*=1000;
                // }
                if(new Date(_format).toString() === 'Invalid Date'){
                    timeIsObject = true;
                   _time = new Date();
                }else{
                     _time = _format;
                    _format = 'Y-m-d H:i:s';
                }
            }
            if(!timeIsObject){
                try{
                    //  // 判断下_str 是不是位于10至12位的纯阿拉伯数字,如果是转为毫秒时间戳
                    // if(/^[1-9]\d{9,11}$/.test(_time)){
                    //     _time*=1000;
                    // }
                    _time = new Date(_time);
                    if(_time.toString() === 'Invalid Date' || _time.toLocaleDateString() === '1970/1/1'){
                        _time = new Date(null);
                    }
                } catch(error) {
                    _time = new Date();
                }
            }
            // 得到"Wed Apr 07 2021" => ['Wed','Apr','07','2021']
            let dateString = _time.toDateString().split(' ');
            // 补位函数
            let strPad = function(v,len = 2){
                let vLen = v.toString().length;
                if(vLen < len){
                    for(let i = len-vLen; i > 0; i--){
                        v = '0'+v;
                    }
                }
                return v;
            }
            let result = [],temp;
            let len = _format.length;
            for(let ii = 0; ii < len; ii++){
                if(_format[ii] === '\\'){
                    result.push(_format[++ii]);
                    continue;
                }
                switch(_format[ii]){
                    case 'd':
                        // 一个月中的第几天(从 01 到 31)
                        result.push(strPad(_time.getDate()));
                        break;
                    case 'D':
                        // 星期几的文本表示(用三个字母表示)
                        result.push(dateString[0]);
                        break;
                    case 'j':
                        // 一个月中的第几天,不带前导零(1 到 31)
                        result.push(_time.getDate());
                        break;
                    // case 'l':
                    //     // ('L' 的小写形式)- 星期几的完整的文本表示
                    //     break;
                    case 'N':
                        // 星期几的 ISO-8601 数字格式表示(1表示Monday[星期一],7表示Sunday[星期日])
                        result.push(_time.getDay()+1);
                        break;
                    // case 'S':
                    //     // 一个月中的第几天的英语序数后缀(2 个字符:st、nd、rd 或 th。与 j 搭配使用)
                    //     break;
                    case 'w':
                        // 星期几的数字表示(0 表示 Sunday[星期日],6 表示 Saturday[星期六])
                        result.push(_time.getDay());
                        break;
                    case 'z':
                        // 一年中的第几天(从 0 到 365)
                        result.push(Math.ceil((new Date(_time.toDateString()) - new Date(_time.getFullYear().toString()))/(24*60*60*1000)));
                        break;
                    case 'W':
                        // 用 ISO-8601 数字格式表示一年中的第几个星期(第几周)
                        result.push(Math.ceil(Math.ceil((new Date(_time.toDateString()) - new Date(_time.getFullYear().toString()))/(24*60*60*1000))/7));
                        break;
                    // case 'F':
                    //     // 月份的完整的文本表示(January[一月份] 到 December[十二月份])
                    //     break;
                    case 'm':
                        // 月份的数字表示(从 01 到 12)
                        result.push(strPad(_time.getMonth()+1));
                        break;
                    case 'M':
                        // 月份的短文本表示(用三个字母表示)
                        result.push(dateString[1]);
                        break;
                    case 'n':
                        // 月份的数字表示,不带前导零(1 到 12)
                        result.push(strPad(_time.getMonth()+1));
                        break;
                    case 't':
                        // 给定月份中包含的天数
                        temp = new Date(_time);// 防止改变原时间对象
                        temp.setMonth(_time.getMonth()+1);
                        temp.setDate(0);// 设置为0,date会自动切为上一个月的最后一天
                        result.push(temp.getDate());
                        break;
                    case 'L':
                        // 是否是闰年(如果是闰年则为 1,否则为 0)
                        temp = _time.getFullYear();
                        if(temp%4 == 0 && temp%100 != 0 || temp%400 == 0){
                            result.push(1);
                        }else{
                            result.push(0);
                        }
                        break;
                    case 'o':
                        // ISO-8601 标准下的年份数字
                    case 'Y':
                        // 年份的四位数表示
                        result.push(_time.getFullYear());
                        break;
                    case 'y':
                        // 年份的两位数表示
                        result.push(_time.getFullYear().toString().substr(2,2));
                        break;
                    case 'a':
                        //小写形式表示:am 或 pm
                        temp = _time.getHours();
                        result.push(temp<12?'am':'pm');
                        break;
                    case 'A':
                        // 大写形式表示:AM 或 PM
                        temp = _time.getHours();
                        result.push(temp<12?'AM':'PM');
                        break;
                    // case 'B':
                    //     // Swatch Internet Time(000 到 999)
                    //     break;
                    case 'g':
                        // 12 小时制,不带前导零(1 到 12)
                        temp = _time.getHours();
                        result.push(temp>12?temp-12:temp);
                        break;
                    case 'G':
                        // 24 小时制,不带前导零(0 到 23)
                        temp = _time.getHours();
                        result.push(temp);
                        break;
                    case 'h':
                        // 12 小时制,带前导零(01 到 12)
                        temp = _time.getHours();
                        temp = temp>12?temp-12:temp;
                        result.push(strPad(temp));
                        break;
                    case 'H':
                        // 24 小时制,带前导零(00 到 23)
                        temp = _time.getHours();
                        result.push(strPad(temp));
                        break;
                    case 'i':
                        // 分,带前导零(00 到 59)
                        result.push(strPad(_time.getMinutes()));
                        break;
                    case 's':
                        // 秒,带前导零(00 到 59)
                        result.push(strPad(_time.getSeconds()));
                        break;
                    default:
                        result.push(_format[ii]);
                }
            }
            return result.join('');
        }
    
        /**
        * 二维数组排序
        * _data             Array
        * _field            String
        * _type             Boolean|String
        .*/
        zslBase.arraySort = function(_data,_field,_type){
            if(Array.isArray(_data) && _data[0].hasOwnProperty(_field)){
                _data = JSON.parse(JSON.stringify(_data));// 去除指针关系,防止影响源变量
                var judge = function(x,y){
                    if(x < y){
                        return 1;
                    }else if(x > y){
                        return -1;
                    }else if(x == y){
                        return 0;
                    }
                }
                if(typeof _type === 'string'){
                    _type = _type.toLowerCase();// 全部转换小写
                    _type = _type === 'desc'?true:(_type === 'asc')?false:_type;
                }
                if(_type){
                    // 倒序
                    _data.sort(function(x, y){
                        return judge(x[_field],y[_field]);
                    });
                }else{
                    // 正序
                    _data.sort(function(x, y){
                        if(x[_field] == '' || y[_field] == ''){
                            return judge(x[_field],y[_field]);
                        }else{
                            return -judge(x[_field],y[_field]);
                        }
                    });
                }
            }
            return _data;
        }
    
        /**
        * 注入远程js(还可用于JSONP请求)
        * _remoteSrc            String          访问得到得url地址
        * _callback             Function        注入完成后执行得函数
        .*/
        zslBase.injectJs = function(_remoteSrc,_callback){
            if(_remoteSrc){
                let script = document.createElement('script');
                script.setAttribute('type', 'text/javascript');
                script.src = _remoteSrc;
                script.onload = function()
                {
                    // 放在页面不好看,执行完后移除掉
                    this.parentNode.removeChild(this);
                    if(typeof(_callback) === 'function'){
                        _callback();
                    }
                };
                document.body.appendChild(script);
            }
        }
        /**
        * 注入文本js
        * _text                String              script脚本
        * _callback            Function            脚本注入完后执行得脚本
        .*/
        zslBase.injectTextJs = function(_text,_callback){
            if(_text){
                let script = document.createElement('script');
                script.setAttribute('type', 'text/javascript');
                _text = 'try{'+ _text +'}catch(err){console.log(err)}';// 加try防止注入不合法js导致后续代码无法执行
                let textNode=document.createTextNode(_text);//声明变量并创建文本内容;
                script.appendChild(textNode);
                document.body.appendChild(script);
                setTimeout(function()
                {
                    // 放在页面不好看,执行完后移除掉
                    script.parentNode.removeChild(script);
                    if(typeof(_callback) === 'function'){
                        _callback();
                    }
                },200);
            }
        }
        /**
        * 注入远程css
        * _remoteSrc            Url            可访问css文件的合法url地址
        .*/
        zslBase.injectCss = function(_remoteSrc){
            if(_remoteSrc){
                let link = document.createElement('link');
                document.head.appendChild(link);
                link.setAttribute('rel','stylesheet');
                link.setAttribute('href',_remoteSrc);
                link.setAttribute('type','text/css');
            }
        }
        /**
        * 注入本地文本css
        * _text              本地css文本样式
        * [_attr]            Object            设置Style标签的属性名,可选
        .*/
        zslBase.injectTextCss = function(_text,_attr){
            if(_text){
                let style = document.createElement('style');
                style.setAttribute('author', 'slongzhang');
                style.setAttribute('time', Date.now());// 设置注入时间
                if(!_empty(_attr) && _attr.constructor === Object){
                    // 注入标识,便于识别注入的还是原生的
                    _attr = Object.entries(_attr);
                    for(let item of _attr){
                        let k = item[0],v = item[1];
                        if(!_empty(k) && !_empty(v)){
                            style.setAttribute(k,v);
                        }
                    }
                }            
                let textNode = document.createTextNode(_text);//声明变量并创建文本内容;
                style.appendChild(textNode);
                document.body.appendChild(style);
            }
        }
        /**
        * 获取根域名
        * 一般应用于浏览器插件开发或第三方脚本的(如站长统计等识别根域名等),自家项目一般用不到
        .*/
        zslBase.getMainHost = function() {
            var key = 'slongzhang_'+Math.random();
            var keyR = new RegExp( '(^|;)\\s*'+key+'=12345' );
            var expiredTime = new Date( 0 );
            var domain = document.domain;
            var domainList = domain.split( '.' );
    
            var urlItems = [];
            // 主域名一定会有两部分组成
            urlItems.unshift( domainList.pop() );
            // 慢慢从后往前测试
            while( domainList.length ) {
                urlItems.unshift( domainList.pop() );
                var mainHost = urlItems.join( '.' );
                var cookie = key+'=12345;domain=.'+mainHost;
                document.cookie = cookie;
    
                //如果cookie存在,则说明域名合法
                if ( keyR.test( document.cookie ) ) {
                    document.cookie = cookie+';expires='+expiredTime;
                    return mainHost;
                }
            }
        }
        
        /**
        * 模板转换写成全局函数
        * 示例:
        *   let template = `
        *    <ul>
        *    <% for(let i=0; i < data.supplies.length; i++) { %>
        *       <li><%= data.supplies[i] %></li>
        *     <% } %>
        *    </ul>
        *    `;
        *    console.log(GTemplateOutput(template,{ supplies: [ "broom", "mop", "cleaner" ] }));
        */
        zslBase.outputHtml = function(_template,_data){
            if(_template){
                let parse = eval(_compileHtml(_template));
                return parse(_data);
            }else{
                return '';
            }
        }
    
        /**
        * 将xml转换成document树
        * _xml              String            xml的文本字符串
        * return            XML对象(document)
        .*/
        zslBase.parseXML = function(_xml){
            var xmlDoc;
            try {
                if (window.DOMParser){
                    xmlDoc = new DOMParser();
                    xmlDoc = xmlDoc.parseFromString(_xml,"text/xml");
                }
                else // Internet Explorer
                {
                    xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
                    xmlDoc.async = "false";
                    xmlDoc.loadXML(_xml);
                }
            } catch(e) {
                xmlDoc = _xml;
            }
            return xmlDoc;
        }
        /**
        * 全局Eval函数(同window.eval())
        .*/
        zslBase.globalEval = function( data ) {
            // 如果script字符串存在,去除左右空格
            if ( data ) {
                // We use execScript on Internet Explorer
                // We use an anonymous function so that context is window
                ( window.execScript || function( data ) {
                    window[ "eval" ].call( window, data );
                } )( data );
            }
        }
        /**
        * httpBuildQuery
        * _object            Object            要转换成http_query的对象
        .*/
        zslBase.httpBuildQuery = function(_object){
            let query = [];
            if(_object && _object.constructor === Object){
                _object = Object.entries(_object);
                for(let item of _object){
                    if(item[1] && typeof item[1] == 'object'){
                        item[1] = JSON.stringify(item[1]);
                    }
                    let k = item[0],v = encodeURIComponent(item[1]);
                    query.push(k+'='+v);
                }
            }
            return query.join('&');    
        }
        /**
        * 恢复http_query
        * 将http_query转换成对象{}
        .*/
        zslBase.httpQueryObject = function(_string){
            if(!_string){
                return {};
            }
            let result = {},arr = _string.split('&');
            for(let item of arr){
                let [k,v = ''] = item.split('=',2);
                k && (v = decodeURIComponent(v),result[k] = zslBase.isJson(v)?JSON.parse(v):v);
            }
            return result;
        }
        // ajax
        zslBase.ajax = function(_option){
            // 不能为空,不能不是配置参数
            if(!_option || _option.constructor !== Object || !Object.keys(_option).length){
                throw 'Fatal error, please pass in the correct parameter';
            }
            let xhr;
            if (window.XMLHttpRequest){
                xhr = new XMLHttpRequest();
            }
            else{
                xhr = new ActiveXObject('Microsoft.XMLHTTP');
            }
            // 规范写法可以纯大小写或驼峰,但不能乱七八糟写
            let xhrParam = {}; // 最终xhr使用的参数
            let    defaultOption = {
                    url: ''
                    ,async: true // 默认异步
                    ,timeout: 0 // 默认不超时
                    ,headers: {}
                    ,data: {}
                    ,dataType: ['*','text','Text','TEXT','json','Json','JSON','xml','Xml','XML'] // 获取的数据类型
                    ,type: ['get','Get','GET','post','Post','POST','put','Put','PUT','delete','Delete','DELETE'] // 请求的类型
                    ,beforeSend: function(){}
                    ,success: function(){}
                    ,error: function(){}
                    ,complete: function(){}
                };
            defaultOption = Object.entries(defaultOption);
            for(let item of defaultOption){
                let k = item[0],v = item[1],_ov = (_option.hasOwnProperty(k)?_option[k]:null);
                switch(k){
                    case 'type':
                    case 'dataType':
                        // 数组取默认值类型
                        xhrParam[k] = ( (_ov === null || !v.includes(_ov))?v[0]:_ov ).toUpperCase();// 最终处理成大写
                        break;
                    case 'async':
                        // 布尔类型
                        xhrParam[k] = (_ov === null?v:!!_ov);
                        break;
                    case 'data':
                    case 'headers':
                        // xhrParam[k] = (_ov === null || _ov.constructor !== Object)?v:_ov;
                        xhrParam[k] = (_ov === null?v:_ov);
                        break;
                    default: 
                        xhrParam[k] = _ov === null?v:_ov;
                }
            }
            // 判断是get还是post,如果是get则需要将其拼接到url上并置空
            let dataQuery = typeof xhrParam.data == 'object'?zslBase.httpBuildQuery(xhrParam.data):xhrParam.data;
            if(xhrParam.type === 'GET'){
                // 移除右侧?和&
                xhrParam.url = zslBase.rtrim(zslBase.rtrim(xhrParam.url,'?'),'&');// 移除右侧的'?'和'&'
                xhrParam.url += ( xhrParam.url.includes('?')?'&':'?' ) + dataQuery;// 拼接到url
                xhrParam.data = '';// 清空
            }else{
                if(xhrParam.dataType == 'JSON'){
                    xhrParam.data = JSON.stringify(xhrParam.data);
                    xhrParam.headers['Content-Type'] = "application/json; charset=UTF8";
                }else{
                    xhrParam.data = dataQuery;
                    xhrParam.headers['Content-Type'] = "application/x-www-form-urlencoded";
                }
                // xhrParam.headers['X-HTTP-Method-Override'] = xhrParam.type;
                // xhrParam.type = "POST";
            }
    
            // 超时时间是数字并且大于0则设置超时
            if(zslBase.isNumeric(xhrParam.timeout) && xhrParam.timeout > 0){
                xhr.timeout = parseInt(xhrParam.timeout);
                xhr.ontimeout = function(e){
                    // https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest/abort
                    xhr.abort();
                }
            }
            // 设置请求方式
            xhr.open(xhrParam.type.toUpperCase(), xhrParam.url, xhrParam.async );
            // 设置监听事件
            xhr.onreadystatechange = function () { // 状态发生变化时,函数被回调
                if (xhr.readyState === 4) { // 成功完成
                    xhrParam.complete();
                    // 判断响应结果:
                    if (xhr.status === 200) {
                        // 成功,通过responseText拿到响应的文本:
                        let result = xhr.responseText,dataType = xhrParam.dataType.toUpperCase();// 转换成大写,规范处理
                        if(dataType === '*'){
                            // 自动类型,默认json判断,如果不是进行xml处理,如果xml也失败了则返回原始字符串
                            result = zslBase.isJson(result)?JSON.parse(result):result;
                        }
                        if(dataType === 'JSON'){
                            // JSON数据
                            result = zslBase.isJson(result)?JSON.parse(result):result;
                        }
                        else if(dataType === 'XML'){
                            // XML数据
                            result = zslBase.parseXML(result);
                        }
                        xhrParam.success(result,xhr);
                    } else {
                        // 失败,根据响应码判断失败原因:
                        setTimeout(function(){
                            // 失败时将失败处理放到异步栈里,不然onreadystatechange事件会优先于其他事件,导致某些事件判断错误或无法判断
                            xhrParam.error(xhr.status,xhr);
                        },1);
                    }
                } else {
                    // HTTP请求还在继续...
                }
            }
            // 执行请求前操作
            xhrParam.beforeSend(xhr);
            // 遍历请求头(请求头的设置并需在open之后才能设置)
            for(let item of Object.entries(xhrParam.headers)){
                let k = item[0],v = item[1];
                xhr.setRequestHeader(k,v);
            }
            // 发送请求
            xhr.send(xhrParam.data);
        }
        // get
        zslBase.get = function(_url,_fn,_dataType){
            zslBase.ajax({
                url: _url
                ,dataType: _dataType
                ,type: 'get'
                ,success: _fn
            });
        }
        // post
        zslBase.post = function(_url,_data,_fn,_dataType){
            zslBase.ajax({
                url: _url
                ,data: _data
                ,dataType: _dataType
                ,type: 'post'
                ,success: _fn
            });
        }
        /**
         * 生成随机数
         * range             int            如果只有一个参数则range是1到range,两个参数则随机range-maxNum
         * maxNum            int            最大
        .*/
        zslBase.random = function(range,maxNum){ 
            switch(arguments.length){ 
                case 1: 
                    // 如果只要参数1,则参数1表示随机范围的最大
                    return parseInt(Math.random()*range+1,10); 
                    break; 
                case 2: 
                    // 如果有两个参数则求这两个的数值范围
                    return parseInt(Math.random()*(maxNum-range+1)+range,10); 
                    break; 
                default: 
                    return parseInt(Math.random()*10);// 没传参数则返回0-9
                    break; 
            }
        }
        /**
         * 随机字符串
         * length             int            生成的字符串长度
         * pattern            int            字符串模式1:仅数字,10仅小写字母,100仅大写,……
        .*/
        zslBase.randomString = function(length,pattern){
            let chars = '';
            let allChars = {
                number: '0123456789'
                ,letters: 'abcdefghijklmnopqrstuvwxyz'
            }
            pattern = pattern?pattern.toString():'';
            // 按位数写法,个位代表数字,十位代表小写,百位代表大写……
            switch(pattern){
                case '1':
                // 仅数字
                chars = allChars['number'];
                break;
            case '10':
                // 仅小写字母
                chars = allChars['letters'];
                break;
            case '100':
                // 仅大写字母
                chars = allChars['letters'].toUpperCase();
                break;
            case '11':
                // 数字+小写
                chars = allChars['number'] + allChars['letters'];
                break;
            case '101':
                // 数字+大写
                chars = allChars['number'] + allChars['letters'].toUpperCase();
                break;
            case '110':
                // 大小写
                chars = allChars['letters'] + allChars['letters'].toUpperCase();
                break;
            default:
                chars = pattern?pattern:allChars['number'] + allChars['letters'] + allChars['letters'].toUpperCase();
                break;
            }
            let charsLength = chars.length;
            let str = '';
            for(let i = 0; i < length; i++)
            {
                str += chars.charAt(Math.floor(Math.random() * charsLength))
            }
            return str;
        }
    
        // uint8array转为base64字符串
        zslBase.uint8arrayToBase64 = function(u8Arr) {
            let CHUNK_SIZE = 0x8000; //arbitrary number
            let index = 0;
            let length = u8Arr.length;
            let result = '';
            let slice;
            while (index < length) {
                slice = u8Arr.subarray(index, Math.min(index + CHUNK_SIZE, length));
                result += String.fromCharCode.apply(null, slice);
                index += CHUNK_SIZE;
            }
            // web image base64图片格式: "data:image/png;base64," + b64encoded;
            // return  "data:image/png;base64," + btoa(result);
            return btoa(result);
        }
        // base64字符串转为uint8array数组
        zslBase.base64ToUint8Array = function(base64String) {
            let padding = '='.repeat((4 - base64String.length % 4) % 4);
            let base64 = (base64String + padding)
                .replace(/\-/g, '+')
                .replace(/_/g, '/');
            let rawData = window.atob(base64);
            let outputArray = new Uint8Array(rawData.length);
            for (var i = 0; i < rawData.length; ++i) {
                outputArray[i] = rawData.charCodeAt(i);
            }
            return outputArray;
        }
        // csv转数组
        let _csvToArray = function(strData, strDelimiter) {
            // Check to see if the delimiter is defined. If not,then default to comma.
            // 检查是否定义了分隔符。如果未定义,则默认为逗号
            strDelimiter = (strDelimiter || ",");
            // Create a regular expression to parse the CSV values.
            // 创建一个正则表达式来解析CSV值。
            let objPattern = new RegExp((
                // Delimiters.(分隔符)
                "(\\" + strDelimiter + "|\\r?\\n|\\r|^)" +
                // Quoted fields.(引用的字段)
                "(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|" +
                // Standard fields.(标准字段)
                "([^\"\\" + strDelimiter + "\\r\\n]*))"), "gi");
            // Create an array to hold our data. Give the array a default empty first row.
            // 创建一个数组来保存数据。给数组赋值一个空元素数组
            let arrData = [
                []
            ];
            // Create an array to hold our individual pattern matching groups.
            // 创建一个数组来保存我们的单个模式匹配组
            let arrMatches = null;
            // Keep looping over the regular expression matches until we can no longer find a match.
            // 正则表达式匹配上保持循环,直到我们再也找不到匹配的
            while (arrMatches = objPattern.exec(strData)) {
                // Get the delimiter that was found.
                // 获取找到的分隔符
                let strMatchedDelimiter = arrMatches[1];
                // Check to see if the given delimiter has a length
                // 检查给定的分隔符是否有长度
                // (is not the start of string) and if it matches
                // (不是字符串的开头)如果匹配
                // field delimiter. If id does not, then we know
                // 字段分隔符。如果身份证没有,那我们就知道了
                // that this delimiter is a row delimiter.
                // 此分隔符是行分隔符。
                if (strMatchedDelimiter.length && (strMatchedDelimiter != strDelimiter)) {
                    // Since we have reached a new row of data,add an empty row to our data array.
                    // 既然我们得到了新的一行数据,向数据数组中添加一个空行。
                    arrData.push([]);
                }
                // Now that we have our delimiter out of the way,
                // 既然我们已经把分隔符弄出来了,
                // let's check to see which kind of value we
                // 让我们来看看我们需要什么样的价值观
                // captured (quoted or unquoted).
                // 捕获(引用或未引用)。
                let strMatchedValue;
                if (arrMatches[2]) {
                    // We found a quoted value. When we capture this value, unescape any double quotes.
                    // 我们找到一个引用值。当我们抓到这个值,取消显示任何双引号
                    strMatchedValue = arrMatches[2].replace(
                        new RegExp("\"\"", "g"), "\"");
                } else {
                    // We found a non-quoted value.
                    // 我们找到了一个没有引号的值。
                    strMatchedValue = arrMatches[3];
                }
                // Now that we have our value string, let's add it to the data array.
                // 现在我们有了值字符串,让我们将其添加到数据数组中
                arrData[arrData.length - 1].push(strMatchedValue);
            }
            // 移除最后一个空数据
            arrData.splice(-1);
            
            // Return the parsed data.
            // 返回解析结果
            return (arrData);
        }
        // csv转对象
        zslBase.csvToObject = function(csv){
            let array = _csvToArray(csv);
            let objArray = [];
            for (let i = 1; i < array.length; i++) {
                objArray[i - 1] = {};
                for (let k = 0; k < array[0].length && k < array[i].length; k++) {
                    let key = array[0][k];
                    objArray[i - 1][key] = array[i][k]
                }
            }
            return objArray;
        }
    
    
        // 常见表单正则( 用户名,手机号,密码强度,身份证号,固定电话/座机 )
        zslBase.check = {
            number: function(_val){
                // 是否纯数字(可整型也可浮点型)
                try {
                    return _val !== "" && _val !== null && !isNaN(_val);
                } catch(error) { }
                return false;        
            }
            ,integer: function(_val){
                // 是否整型
                try {
                    return val%1 === 0;
                } catch(error) { }
                return false;
            }
            ,float: function(_val){
                // 是否浮点型
                try {
                    return _val !== "" && _val !== null && !isNaN(_val) && val%1 !== 0;
                } catch(error) { }
                return false;
            }
            /**
             * 邮箱验证(仅支持常规验证,不支持中文域名、中文邮箱)
             */
            ,email: function(_email){
                // 常规正则+过滤特殊情况(顶级域名后缀只能是纯字母)
                if(/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/.test(_email) && /\.[a-zA-Z]+$/.test(_email)){
                    return true;
                }
                return false;
            }
            ,username: function(){
                // 用户名验证
            }
            ,mobile: function(_phone){
                // 手机号验证
                return /^1[3456789]\d{9}$/.test(_phone);
            }
            /**
             * 密码验证
             * _pwd              String            要验证的密码
             * _level            Int               验证级别,默认2,不能单一类型密码
             * _min              Int               不能少于X位,默认6
             * _max              Int               不能多于X位,默认16
             * _chars            String            要使用的特殊符号,常见需要转义的特殊字符默认已添加处理了,如有遗落自行处理handleChar函数;
             */
            ,password: function(_pwd, _level = 2, _min = 6, _max = 16, _chars = ',.!@#$%^&*'){
                let result = false,reg,psChars = '';
                try { // 防止出现乱七八糟的参数
                    // 转义特殊字符
                    let handleChar = function(_str){
                        _str = _str.split('');
                        let zy = regEscapeCharacter,ps='';
                        for(let v of _str){
                            if(zy.includes(v)){
                                ps +='\\\\';
                            }
                            ps+=v;
                        }
                        return ps;
                    }
                    switch(_level){
                        case 0:
                            // 字母+数字,位数在_min到_max之间即可(可单一类型)
                            reg = new RegExp('^[a-zA-Z0-9]{' + _min + ',' + _max + '}$');
                            result = reg.test(_pwd);
                            break;
                        case 1:
                            // 字母+数字+特殊字符,.!@#$%^&* ,位数在_min到_max之间即可(可单一类型)
                            reg = new RegExp('^[a-zA-Z0-9,' + handleChar(_chars) + ']{' + _min + ',' + _max + '}$');
                            result = reg.test(_pwd);
                            break;
                        case 2:
                            // 字母+数字+特殊字符,.!@#$%^&*,必须两种及以上组合(可字母数字组合,字母特殊字符组合,数字和特殊字符组合,大写和小写组合)
                            psChars = handleChar(_chars);
                            reg = new RegExp('(?!^\\d+$)(?!^[a-z]+$)(?!^[A-Z]+$)(?!^[' + psChars + ']+$)(^[a-zA-Z0-9' + psChars + ']{' + _min + ',' + _max + '}$)');
                            result = reg.test(_pwd);
                            break;
                        case 3:
                            // 字母+数字+特殊字符,.!@#$%^&*,必须两种及以上组合(可字母数字组合,字母特殊字符组合,数字和特殊字符组合)
                            psChars = handleChar(_chars);
                            reg = new RegExp('(?!^\\d+$)(?!^[a-zA-Z]+$)(?!^[' + psChars + ']+$)(^[a-zA-Z0-9' + psChars + ']{' + _min + ',' + _max + '}$)');
                            result = reg.test(_pwd);
                            break;
                        default:
                            // 任意字符只要符合位数即可
                            reg = new RegExp('.{' + _min + ',' + _max + '}$');
                            result = reg.test(_pwd);
                    }
                    return result;
                } catch(error) {
                    return false;
                }
            }
            /**
             * 身份证号验证
             *   结构和形式
             *     1.号码的结构 
             *       公民身份号码是特征组合码,由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。 
             *     2.地址码 
             *       表示编码对象常住户口所在县(市、旗、区)的行政区划代码,按GB/T2260的规定执行。 
             *     3.出生日期码 
             *       表示编码对象出生的年、月、日,按GB/T7408的规定执行,年、月、日代码之间不用分隔符。 
             *     4.顺序码 
             *       表示在同一地址码所标识的区域范围内,对同年、同月、同日出生的人编定的顺序号,顺序码的奇数分配给男性,偶数分配给女性。 
             *     5.校验码
             *       根据前面十七位数字码,按照ISO 7064:1983.MOD 11-2校验码计算出来的检验码。
             *
             *  计算方法
             *    1、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为:7-9-10-5-8-4-2-1-6-3-7-9-10-5-8-4-2。
             *    2、将这17位数字和系数相乘的结果相加。
             *    3、用加出来和除以11,看余数是多少?
             *    4、余数只可能有0-1-2-3-4-5-6-7-8-9-10这11个数字。其分别对应的最后一位身份证的号码为1-0-X -9-8-7-6-5-4-3-2。
             *    5、通过上面得知如果余数是3,就会在身份证的第18位数字上出现的是9。如果对应的数字是2,身份证的最后一位号码就是罗马数字x。
             *    例如:某男性的身份证号码为【53010219200508011x】, 我们看看这个身份证是不是合法的身份证。
             *    首先我们得出前17位的乘积和【(5*7)+(3*9)+(0*10)+(1*5)+(0*8)+(2*4)+(1*2)+(9*1)+(2*6)+(0*3)+(0*7)+(5*9)+(0*10)+(8*5)+(0*8)+(1*4)+(1*2)】是189,然后用189除以11得出的结果是189/11=17----2,也就是说其余数是2。最后通过对应规则就可以知道余数2对应的检验码是X。所以,可以判定这是一个正确的身份证号码。
             */ 
            ,IDnumber: function(_id){
                //身份证正则表达式(18位) 
                let reg = /^[1-9]\d{5}(19\d{2}|[2-9]\d{3})((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])(\d{4}|\d{3}X)$/i;
                let stard = "10X98765432"; //最后一位身份证的号码
                let first = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]; //1-17系数
                let sum = 0;
                if (!reg.test(_id)) {
                    return false;
                }
                let year = _id.substr(6, 4);
                let month = _id.substr(10, 2);
                let day = _id.substr(12, 2);
                let birthday = _id.substr(6, 8);
                //校验日期是否合法
                if (birthday != zslBase.date('Ymd', new Date(year + '/' + month + '/' + day))) {
                    return false;
                }
                for (let i = 0; i < _id.length - 1; i++) {
                    sum += _id[i] * first[i];
                }
                let result = sum % 11;
                let last = stard[result]; //计算出来的最后一位身份证号码
                if (_id[_id.length - 1].toUpperCase() == last) {
                    return true;
                } else {
                    return false;
                }
            }
            /**
             * 匹配国内电话号码(0511-4405222 或 021-87888822) 
             */
            ,landline: function(_val){
                return /\d{3}-\d{8}|\d{4}-\d{7}/.test(_val);
            }
        };
        // 用户自定义更多的扩展
        zslBase.ed = {};
        zslBase.empty = _empty;
    
        var
    
        // Map over zslBase in case of overwrite
        _zslBase = window.zslBase,
    
        // Map over the zsl in case of overwrite
        _zsl = window.zsl;
        // 解除zsl和zslBase变量的使用
        zslBase.noConflict = function( deep ) {
            if ( window.zsl === zslBase ) {
                window.zsl = _zsl;
            }
    
            if ( deep && window.zslBase === zslBase ) {
                window.zslBase = _zslBase;
            }
    
            return zslBase;
        };
        if ( typeof noGlobal === "undefined" ) {
            window.zslBase = window.zsl = zslBase;
        }
        // 开始冻结对象,除了ed可以自己扩展外其他的不允许再添加或修改了
        Object.freeze(zslBase);
        return zslBase;
    });
    

    2.转es5的压缩版

    !function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("zslBase requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(window,noGlobal){"use strict";function _slicedToArray(e,t){return _arrayWithHoles(e)||_iterableToArrayLimit(e,t)||_unsupportedIterableToArray(e,t)||_nonIterableRest()}function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _iterableToArrayLimit(e,t){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e)){var r=[],a=!0,n=!1,o=void 0;try{for(var s,i=e[Symbol.iterator]();!(a=(s=i.next()).done)&&(r.push(s.value),!t||r.length!==t);a=!0);}catch(e){n=!0,o=e}finally{try{a||null==i.return||i.return()}finally{if(n)throw o}}return r}}function _arrayWithHoles(e){if(Array.isArray(e))return e}function _createForOfIteratorHelper(e,t){var r;if("undefined"==typeof Symbol||null==e[Symbol.iterator]){if(Array.isArray(e)||(r=_unsupportedIterableToArray(e))||t&&e&&"number"==typeof e.length){r&&(e=r);var a=0,n=function(){};return{s:n,n:function(){return a>=e.length?{done:!0}:{done:!1,value:e[a++]}},e:function(e){throw e},f:n}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,s=!0,i=!1;return{s:function(){r=e[Symbol.iterator]()},n:function(){var e=r.next();return s=e.done,e},e:function(e){i=!0,o=e},f:function(){try{s||null==r.return||r.return()}finally{if(i)throw o}}}}function _unsupportedIterableToArray(e,t){if(e){if("string"==typeof e)return _arrayLikeToArray(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);return"Object"===r&&e.constructor&&(r=e.constructor.name),"Map"===r||"Set"===r?Array.from(e):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?_arrayLikeToArray(e,t):void 0}}function _arrayLikeToArray(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,a=new Array(t);r<t;r++)a[r]=e[r];return a}function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}var regEscapeCharacter=["$","(",")","*","+",".","[","]","?","\\","/","^","{","}","!","|"],_empty=function(e){return null===e||("object"===_typeof(e)?!(Object.keys(e).length>0):0==e||!e)},_compileHtml=function(e){return e=e.replace(/<%=(.+?)%>/g,"`); \n echo( $1 ); \n echo(`").replace(/<%([\s\S]+?)%>/g,"`); \n $1 \n echo(`"),'(function parse(data){\n            let output = "";\n            function echo(html){\n                output += html;\n            }\n            '.concat(e="echo(`"+e+"`);","\n            return output;\n        })")},zslBase={version:"1.0.1",author:"slongzhang@qq.com",ready:function(e){if("function"!=typeof e)throw"Fn is not a function!";function t(){document.removeEventListener("DOMContentLoaded",t),window.removeEventListener("load",t),e()}"complete"===document.readyState||"loading"!==document.readyState&&!document.documentElement.doScroll?window.setTimeout(e):(document.addEventListener("DOMContentLoaded",t),window.addEventListener("load",t))},isJson:function(e){if("string"==typeof e)try{return JSON.parse(e),!0}catch(e){}return!1},isNumeric:function(e){return""!==e&&null!==e&&!isNaN(e)}},_trimBase=function(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0;if("string"!=typeof e)return e;if(void 0===t)return 1===r?e.replace(/^\s+/gm,""):2===r?e.replace(/\s+$/gm,""):e.replace(/^\s+|\s+$/gm,"");t=t.split("");var a,n,o=regEscapeCharacter,s="",i=_createForOfIteratorHelper(t);try{for(i.s();!(a=i.n()).done;){var u=a.value;o.includes(u)&&(s+="\\"),s+=u}}catch(e){i.e(e)}finally{i.f()}return n=1===r?new RegExp("^"+s+"+","gm"):2===r?new RegExp(s+"+$","gm"):new RegExp("^"+s+"+|"+s+"+$","gm"),e.replace(n,"")};zslBase.trim=function(e,t){return _trimBase(e,t,0)},zslBase.ltrim=function(e,t){return _trimBase(e,t,1)},zslBase.rtrim=function(e,t){return _trimBase(e,t,2)},zslBase.time=function(e){var t=(new Date).valueOf();return e&&(t=parseInt(t/1e3)),t},zslBase.strtotime=function(e,t,r){var a,n,o,s,i=function(e,t){var r,a;return void 0===e||!e||"object"===_typeof(e)&&0===e.length?(new Date).valueOf():"Invalid Date"!==(r="now"===e?new Date:new Date(e)).toString()&&"1970/1/1"!==r.toLocaleDateString()&&(a=r.valueOf(),t&&(a=parseInt(a/1e3)),a)};if((a=i(e,t))&&!isNaN(a))return a;(a=i(t,!1))&&!isNaN(a)?(n=a,a=new Date(a)):n=(a=new Date).valueOf();try{o=e.replace(/[^\d-+.]+/g,"_#_").split("_#_").filter(function(e){return e&&parseInt(e)}),s=e.replace(/[^\a-zA-Z]+/g,"_#_").split("_#_").filter(function(e){return e&&e.trim()})}catch(e){throw"参数格式错误,请参照 a b a b ……,a:正负数整型,b:单位year(y年),month(m月),week(w周),day(d日),hours(h时),minutes(i分),seconds(s秒)\r\n如: '2 day -1 hours'=》47小时后\r\n如: '-2 day 1 hours'=》47小时前"}for(var u,c={},l=0;l<o.length;l++)if("minutes"===s[l]&&(s[l]="i"),s[l]&&!c.hasOwnProperty(s[l][0])){var p=parseInt(o[l]);switch(c[s[l][0]]=1,s[l]){case"y":case"year":(u=new Date(n)).setFullYear(u.getFullYear()+p),n=u.valueOf();break;case"m":case"month":(u=new Date(n)).setMonth(u.getMonth()+p),n=u.valueOf();break;case"w":case"week":n+=6048e5*p;break;case"d":case"day":n+=864e5*p;break;case"h":case"hours":n+=36e5*p;break;case"i":case"minutes":n+=6e4*p;break;case"s":case"seconds":n+=1e3*p}}return r&&(n=parseInt(n/1e3)),n},zslBase.date=function(e,t){var r=!1;if(void 0===e&&void 0===t?(r=!0,e="Y-m-d H:i:s",t=new Date):e?e&&void 0===t&&("Invalid Date"===new Date(e).toString()?(r=!0,t=new Date):(t=e,e="Y-m-d H:i:s")):e="Y-m-d H:i:s",!r)try{"Invalid Date"!==(t=new Date(t)).toString()&&"1970/1/1"!==t.toLocaleDateString()||(t=new Date(null))}catch(e){t=new Date}for(var a,n=t.toDateString().split(" "),o=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2,r=e.toString().length;if(r<t)for(var a=t-r;a>0;a--)e="0"+e;return e},s=[],i=e.length,u=0;u<i;u++)if("\\"!==e[u])switch(e[u]){case"d":s.push(o(t.getDate()));break;case"D":s.push(n[0]);break;case"j":s.push(t.getDate());break;case"N":s.push(t.getDay()+1);break;case"w":s.push(t.getDay());break;case"z":s.push(Math.ceil((new Date(t.toDateString())-new Date(t.getFullYear().toString()))/864e5));break;case"W":s.push(Math.ceil(Math.ceil((new Date(t.toDateString())-new Date(t.getFullYear().toString()))/864e5)/7));break;case"m":s.push(o(t.getMonth()+1));break;case"M":s.push(n[1]);break;case"n":s.push(o(t.getMonth()+1));break;case"t":(a=new Date(t)).setMonth(t.getMonth()+1),a.setDate(0),s.push(a.getDate());break;case"L":(a=t.getFullYear())%4==0&&a%100!=0||a%400==0?s.push(1):s.push(0);break;case"o":case"Y":s.push(t.getFullYear());break;case"y":s.push(t.getFullYear().toString().substr(2,2));break;case"a":a=t.getHours(),s.push(a<12?"am":"pm");break;case"A":a=t.getHours(),s.push(a<12?"AM":"PM");break;case"g":a=t.getHours(),s.push(a>12?a-12:a);break;case"G":a=t.getHours(),s.push(a);break;case"h":a=(a=t.getHours())>12?a-12:a,s.push(o(a));break;case"H":a=t.getHours(),s.push(o(a));break;case"i":s.push(o(t.getMinutes()));break;case"s":s.push(o(t.getSeconds()));break;default:s.push(e[u])}else s.push(e[++u]);return s.join("")},zslBase.arraySort=function(e,t,r){if(Array.isArray(e)&&e[0].hasOwnProperty(t)){e=JSON.parse(JSON.stringify(e));var a=function(e,t){return e<t?1:e>t?-1:e==t?0:void 0};"string"==typeof r&&(r="desc"===(r=r.toLowerCase())||"asc"!==r&&r),r?e.sort(function(e,r){return a(e[t],r[t])}):e.sort(function(e,r){return""==e[t]||""==r[t]?a(e[t],r[t]):-a(e[t],r[t])})}return e},zslBase.injectJs=function(e,t){if(e){var r=document.createElement("script");r.setAttribute("type","text/javascript"),r.src=e,r.onload=function(){this.parentNode.removeChild(this),"function"==typeof t&&t()},document.body.appendChild(r)}},zslBase.injectTextJs=function(e,t){if(e){var r=document.createElement("script");r.setAttribute("type","text/javascript"),e="try{"+e+"}catch(err){console.log(err)}";var a=document.createTextNode(e);r.appendChild(a),document.body.appendChild(r),setTimeout(function(){r.parentNode.removeChild(r),"function"==typeof t&&t()},200)}},zslBase.injectCss=function(e){if(e){var t=document.createElement("link");document.head.appendChild(t),t.setAttribute("rel","stylesheet"),t.setAttribute("href",e),t.setAttribute("type","text/css")}},zslBase.injectTextCss=function(e,t){if(e){var r=document.createElement("style");if(r.setAttribute("author","slongzhang"),r.setAttribute("time",Date.now()),!_empty(t)&&t.constructor===Object){var a,n=_createForOfIteratorHelper(t=Object.entries(t));try{for(n.s();!(a=n.n()).done;){var o=a.value,s=o[0],i=o[1];_empty(s)||_empty(i)||r.setAttribute(s,i)}}catch(e){n.e(e)}finally{n.f()}}var u=document.createTextNode(e);r.appendChild(u),document.body.appendChild(r)}},zslBase.getMainHost=function(){var e="slongzhang_"+Math.random(),t=new RegExp("(^|;)\\s*"+e+"=12345"),r=new Date(0),a=document.domain.split("."),n=[];for(n.unshift(a.pop());a.length;){n.unshift(a.pop());var o=n.join("."),s=e+"=12345;domain=."+o;if(document.cookie=s,t.test(document.cookie))return document.cookie=s+";expires="+r,o}},zslBase.outputHtml=function(_template,_data){if(_template){var parse=eval(_compileHtml(_template));return parse(_data)}return""},zslBase.parseXML=function(e){var t;try{window.DOMParser?t=(t=new DOMParser).parseFromString(e,"text/xml"):((t=new ActiveXObject("Microsoft.XMLDOM")).async="false",t.loadXML(e))}catch(r){t=e}return t},zslBase.globalEval=function(e){e&&(window.execScript||function(e){window.eval.call(window,e)})(e)},zslBase.httpBuildQuery=function(e){var t=[];if(e&&e.constructor===Object){var r,a=_createForOfIteratorHelper(e=Object.entries(e));try{for(a.s();!(r=a.n()).done;){var n=r.value;n[1]&&"object"==_typeof(n[1])&&(n[1]=JSON.stringify(n[1]));var o=n[0],s=encodeURIComponent(n[1]);t.push(o+"="+s)}}catch(e){a.e(e)}finally{a.f()}}return t.join("&")},zslBase.httpQueryObject=function(e){if(!e)return{};var t,r={},a=_createForOfIteratorHelper(e.split("&"));try{for(a.s();!(t=a.n()).done;){var n=_slicedToArray(t.value.split("=",2),2),o=n[0],s=n[1],i=void 0===s?"":s;o&&(i=decodeURIComponent(i),r[o]=zslBase.isJson(i)?JSON.parse(i):i)}}catch(e){a.e(e)}finally{a.f()}return r},zslBase.ajax=function(e){if(!e||e.constructor!==Object||!Object.keys(e).length)throw"Fatal error, please pass in the correct parameter";var t;t=window.XMLHttpRequest?new XMLHttpRequest:new ActiveXObject("Microsoft.XMLHTTP");var r,a={},n={url:"",async:!0,timeout:0,headers:{},data:{},dataType:["*","text","Text","TEXT","json","Json","JSON","xml","Xml","XML"],type:["get","Get","GET","post","Post","POST","put","Put","PUT","delete","Delete","DELETE"],beforeSend:function(){},success:function(){},error:function(){},complete:function(){}},o=_createForOfIteratorHelper(n=Object.entries(n));try{for(o.s();!(r=o.n()).done;){var s=r.value,i=s[0],u=s[1],c=e.hasOwnProperty(i)?e[i]:null;switch(i){case"type":case"dataType":a[i]=(null!==c&&u.includes(c)?c:u[0]).toUpperCase();break;case"async":a[i]=null===c?u:!!c;break;case"data":case"headers":a[i]=null===c?u:c;break;default:a[i]=null===c?u:c}}}catch(e){o.e(e)}finally{o.f()}var l="object"==_typeof(a.data)?zslBase.httpBuildQuery(a.data):a.data;"GET"===a.type?(a.url=zslBase.rtrim(zslBase.rtrim(a.url,"?"),"&"),a.url+=(a.url.includes("?")?"&":"?")+l,a.data=""):"JSON"==a.dataType?(a.data=JSON.stringify(a.data),a.headers["Content-Type"]="application/json; charset=UTF8"):(a.data=l,a.headers["Content-Type"]="application/x-www-form-urlencoded"),zslBase.isNumeric(a.timeout)&&a.timeout>0&&(t.timeout=parseInt(a.timeout),t.ontimeout=function(e){t.abort()}),t.open(a.type.toUpperCase(),a.url,a.async),t.onreadystatechange=function(){if(4===t.readyState)if(a.complete(),200===t.status){var e=t.responseText,r=a.dataType.toUpperCase();"*"===r&&(e=zslBase.isJson(e)?JSON.parse(e):e),"JSON"===r?e=zslBase.isJson(e)?JSON.parse(e):e:"XML"===r&&(e=zslBase.parseXML(e)),a.success(e,t)}else setTimeout(function(){a.error(t.status,t)},1)},a.beforeSend(t);for(var p=0,d=Object.entries(a.headers);p<d.length;p++){var f=d[p],h=f[0],y=f[1];t.setRequestHeader(h,y)}t.send(a.data)},zslBase.get=function(e,t,r){zslBase.ajax({url:e,dataType:r,type:"get",success:t})},zslBase.post=function(e,t,r,a){zslBase.ajax({url:e,data:t,dataType:a,type:"post",success:r})},zslBase.random=function(e,t){switch(arguments.length){case 1:return parseInt(Math.random()*e+1,10);case 2:return parseInt(Math.random()*(t-e+1)+e,10);default:return parseInt(10*Math.random())}},zslBase.randomString=function(e,t){var r="",a={number:"0123456789",letters:"abcdefghijklmnopqrstuvwxyz"};switch(t=t?t.toString():""){case"1":r=a.number;break;case"10":r=a.letters;break;case"100":r=a.letters.toUpperCase();break;case"11":r=a.number+a.letters;break;case"101":r=a.number+a.letters.toUpperCase();break;case"110":r=a.letters+a.letters.toUpperCase();break;default:r=t||a.number+a.letters+a.letters.toUpperCase()}for(var n=r.length,o="",s=0;s<e;s++)o+=r.charAt(Math.floor(Math.random()*n));return o},zslBase.uint8arrayToBase64=function(e){for(var t,r=0,a=e.length,n="";r<a;)t=e.subarray(r,Math.min(r+32768,a)),n+=String.fromCharCode.apply(null,t),r+=32768;return btoa(n)},zslBase.base64ToUint8Array=function(e){for(var t=(e+"=".repeat((4-e.length%4)%4)).replace(/\-/g,"+").replace(/_/g,"/"),r=window.atob(t),a=new Uint8Array(r.length),n=0;n<r.length;++n)a[n]=r.charCodeAt(n);return a};var _csvToArray=function(e,t){t=t||",";for(var r=new RegExp("(\\"+t+'|\\r?\\n|\\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\\'+t+"\\r\\n]*))","gi"),a=[[]],n=null;n=r.exec(e);){var o=n[1];o.length&&o!=t&&a.push([]);var s=void 0;s=n[2]?n[2].replace(new RegExp('""',"g"),'"'):n[3],a[a.length-1].push(s)}return a.splice(-1),a};zslBase.csvToObject=function(e){for(var t=_csvToArray(e),r=[],a=1;a<t.length;a++){r[a-1]={};for(var n=0;n<t[0].length&&n<t[a].length;n++){var o=t[0][n];r[a-1][o]=t[a][n]}}return r},zslBase.check={number:function(e){try{return""!==e&&null!==e&&!isNaN(e)}catch(e){}return!1},integer:function(e){try{return val%1==0}catch(e){}return!1},float:function(e){try{return""!==e&&null!==e&&!isNaN(e)&&val%1!=0}catch(e){}return!1},email:function(e){return!(!/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/.test(e)||!/\.[a-zA-Z]+$/.test(e))},username:function(){},mobile:function(e){return/^1[3456789]\d{9}$/.test(e)},password:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:6,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:16,n=arguments.length>4&&void 0!==arguments[4]?arguments[4]:",.!@#$%^&*",o=!1,s="";try{var i=function(e){e=e.split("");var t,r=regEscapeCharacter,a="",n=_createForOfIteratorHelper(e);try{for(n.s();!(t=n.n()).done;){var o=t.value;r.includes(o)&&(a+="\\\\"),a+=o}}catch(e){n.e(e)}finally{n.f()}return a};switch(t){case 0:o=new RegExp("^[a-zA-Z0-9]{"+r+","+a+"}$").test(e);break;case 1:o=new RegExp("^[a-zA-Z0-9,"+i(n)+"]{"+r+","+a+"}$").test(e);break;case 2:s=i(n),o=new RegExp("(?!^\\d+$)(?!^[a-z]+$)(?!^[A-Z]+$)(?!^["+s+"]+$)(^[a-zA-Z0-9"+s+"]{"+r+","+a+"}$)").test(e);break;case 3:s=i(n),o=new RegExp("(?!^\\d+$)(?!^[a-zA-Z]+$)(?!^["+s+"]+$)(^[a-zA-Z0-9"+s+"]{"+r+","+a+"}$)").test(e);break;default:o=new RegExp(".{"+r+","+a+"}$").test(e)}return o}catch(e){return!1}},IDnumber:function(e){var t=[7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2],r=0;if(!/^[1-9]\d{5}(19\d{2}|[2-9]\d{3})((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])(\d{4}|\d{3}X)$/i.test(e))return!1;var a=e.substr(6,4),n=e.substr(10,2),o=e.substr(12,2);if(e.substr(6,8)!=zslBase.date("Ymd",new Date(a+"/"+n+"/"+o)))return!1;for(var s=0;s<e.length-1;s++)r+=e[s]*t[s];var i="10X98765432"[r%11];return e[e.length-1].toUpperCase()==i},landline:function(e){return/\d{3}-\d{8}|\d{4}-\d{7}/.test(e)}},zslBase.ed={},zslBase.empty=_empty;var _zslBase=window.zslBase,_zsl=window.zsl;return zslBase.noConflict=function(e){return window.zsl===zslBase&&(window.zsl=_zsl),e&&window.zslBase===zslBase&&(window.zslBase=_zslBase),zslBase},void 0===noGlobal&&(window.zslBase=window.zsl=zslBase),Object.freeze(zslBase),zslBase});
    
    展开全文
  • InfluxDB常用函数

    千次阅读 2020-06-13 20:30:51
    InfluxDB常用函数及Grafana参数

    常用函数

    • 聚合类
      1、COUNT() :返回一个field中的非空值数量
      2、MEAN() 函数:求平均值,字段类型必须是整型或浮点型
      3、SPREAD()函数:返回字段的最小值和最大值的差值,字段类型必须是整型或浮点型
      4、SUM()函数:求和,字段类型必须是整型或浮点型
    • 选择类
      TOP()函数:返回字段中最大的前N个值,字段必须是整型或浮点型
      BOTTOM()函数:返回字段中最小的N个值,使用方法同上
      MAX()函数:返回字段中最大的值,该字段类型必须是长整型,float64,或布尔类型。
      MIN()函数:返回一个字段中的最小值。该字段类型必须是长整型,float64,或布尔类型。
    • 转换类
      DIFFERENCE()函数:返回一个字段中连续的时间值之间的差异,字段类型必须是长整型或float64。
    • 预测类
      HOLT_WINTERS():返回N个预测字段值

    参数
    $__interval:group time(interval)会对查询结果按照interval进行聚合,例如,time(5m),interval=5m, 则会将数据每隔5m进行聚合

    展开全文
  • 常用函数的傅里叶变换汇总

    万次阅读 多人点赞 2020-03-19 12:42:42
    快速链接: ...常用函数的傅里叶变换汇总 (3) LTI 系统 与 滤波器 常用函数的傅里叶变换汇总 f(t)⟵⟶F(jω)F(jt)⟵⟶2πf(−ω)f(αt)⟵⟶1∣α∣F(jωα)a⋅f1+b⋅f2⟵⟶a⋅F1+b⋅F2f(t±...
    
    

    常用函数的傅里叶变换汇总

    f(t)F(jω)F(jt)2πf(ω)f(αt)1αF(jωα)af1+bf2aF1+bF2f(t±t0)e±jωt0F(jω)f(t±t0)F(jω)ej[φ(ω)±ωt0]ejω0tf(t)F[j(ω±ω0)]f1(t)f2(t)F1(jω)F2(jω)f1(t)f2(t)12πF1(jω)F2(jω)f(n)(t)(jω)nF(jω)tf(x)dxπF(0)δ(ω)+F(jω)jω(jt)nf(t)F(n)(jω)πf(0)δ(t)+f(t)jtωF(jx)dxeαtε(t)1α+jωeαt2αα2+ω2gτ(t)τSaωτ212πδ(ω)δ1δjωδ(n)(jω)nε(t)πδ(ω)+1jωsgn(t)2jωR(τ)E(ω)f(t)f(tτ)dtF(jω)2R(τ)P(ω)limT[1TT2T2f(t)f(tτ)dt]limTFT(jω)2Tejω0t2πδ(ωω0)ejω0t2πδ(ω+ω0)cos(ω0t)π[δ(ω+ω0)+δ(ωω0)]sin(ω0t)jπ[δ(ω+ω0)δ(ωω0)]fT(t)FT(jω)δT(t)f0(t)ΩδΩ(ω)F0(jω)δT(t)f0(t)Ωn=F0(jnΩ)δ(ωnΩ)n=FnejnΩt2πn=Fnδ(ωnΩ)\begin{aligned} \displaystyle f({\color{blue}t}) \longleftarrow& \longrightarrow F({\color{blue}j\omega}) \\ F(j t) \longleftarrow& \longrightarrow {\color{blue}2\pi }f(-\omega)\\ f({\color{blue}\alpha} t) \longleftarrow& \longrightarrow {\color{blue}\frac{1}{\lvert \alpha \rvert}}F(j\frac{\omega}{{\color{blue}\alpha}})\\ {\color{blue}a}\cdot f_1 + {\color{blue}b}\cdot f_2 \longleftarrow& \longrightarrow {\color{blue}a}\cdot F_1 + {\color{blue}b}\cdot F_2 \\ f(t {\color{blue}\pm t_0}) \longleftarrow& \longrightarrow {\color{blue}e^{\pm j \omega t_0}}F(j\omega)\\ f(t {\color{blue}\pm t_0}) \longleftarrow& \longrightarrow \lvert F(j\omega)\rvert {\color{blue}e^{j[\varphi(\omega)\pm \omega t_0]}}\\ {\color{blue}e^{\mp j\omega_0 t}}f(t)\longleftarrow& \longrightarrow F\big[j(\omega{\color{blue}\pm\omega_0})\big]\\ f_1(t) {\color{blue}\star} f_2(t) \longleftarrow& \longrightarrow F_1(j\omega){\color{blue}\cdot} F_2(j\omega)\\ f_1(t){\color{blue}\cdot} f_2(t) \longleftarrow& \longrightarrow {\color{blue}\frac{1}{2\pi}}F_1(j\omega){\color{blue}\star} F_2(j\omega)\\ f^{{\color{blue}(n)}} (t) \longleftarrow& \longrightarrow {\color{blue}(j\omega)^n} F(j\omega)\\ \int^{t}_{-\infty} f(x) dx \longleftarrow& \longrightarrow \pi F(0)\delta(\omega) + \frac{F(j\omega)}{j\omega}\\ {\color{blue}(-jt)^n} f (t) \longleftarrow& \longrightarrow F^{{\color{blue}(n)}}(j\omega)\\ \pi f(0)\delta(t) + \frac{f(t)}{{\color{red}-}jt} \longleftarrow& \longrightarrow \int^{\omega}_{-\infty}F(jx)dx\\ e^{-\alpha t} \varepsilon(t)\longleftarrow& \longrightarrow \frac{1}{\alpha + j\omega}\\ e^{-\alpha \lvert t\rvert} \longleftarrow& \longrightarrow \frac{2\alpha}{\alpha^2 + \omega^2} \\ g_{\color{blue}\tau}(t) \longleftarrow& \longrightarrow {\color{blue}\tau} \text{Sa} \Big\lgroup \displaystyle \frac{\omega{\color{blue}\tau}}{2} \Big\rgroup\\ {\color{red}1} \longleftarrow& \longrightarrow {\color{blue}2\pi}\delta{(\omega)}\\ {\color{red}\delta} \longleftarrow& \longrightarrow 1 \\ \delta^{\color{blue}\prime} \longleftarrow& \longrightarrow {\color{blue}j\omega} \\ \delta^{{\color{blue}(n)}} \longleftarrow& \longrightarrow (j\omega)^{\color{blue}n} \\ {\color{red}\varepsilon}(t)\longleftarrow& \longrightarrow \pi \delta(\omega) + \frac{1}{j\omega}\\ {\color{blue}\text{sgn}}(t)\longleftarrow& \longrightarrow \frac{2}{j\omega}\\ \downarrow R(\tau) \longleftarrow& \longrightarrow {\color{red}E}(\omega) \downarrow \\ {\int^{\infty}_{-\infty}f(t)f(t-\tau)dt} \longleftarrow& \longrightarrow \lvert F(j\omega) \rvert ^2\\ \downarrow R(\tau) \longleftarrow& \longrightarrow {\color{red}P}(\omega)\downarrow \\ \lim_{T\to\infty} \big[ \frac{1}{T} \int^{\frac{T}{2}}_{-\frac{T}{2}} f(t)f(t-\tau)dt \big] \longleftarrow& \longrightarrow \lim_{T\to\infty} \frac{\lvert F_T(j\omega)\rvert ^2}{T}\\ e^{j{\color{blue}\omega_0} t} \longleftarrow& \longrightarrow 2\pi \delta (\omega {\color{blue}- \omega_0}) \\ e^{-j\omega_0 t} \longleftarrow& \longrightarrow 2\pi \delta (\omega + \omega_0) \\ {\color{blue}\cos} ( \omega_0 t )\longleftarrow& \longrightarrow \pi \big[ \delta(\omega + \omega_0) {\color{blue}+} \delta(\omega-\omega_0)\big] \\ {\color{blue}\sin} (\omega_0 t) \longleftarrow& \longrightarrow {\color{blue}j}\pi \big[ \delta(\omega + \omega_0){\color{blue} -} \delta(\omega-\omega_0)\big] \\ f_{\color{blue}T}(t) \longleftarrow& \longrightarrow F_{\color{blue}T}(j\omega)\\ \delta_T(t) \star f_0(t) \longleftarrow& \longrightarrow \Omega \delta_\Omega(\omega) F_0(j\omega)\\ \delta_T(t) \star f_0(t) \longleftarrow& \longrightarrow \Omega \sum_{n=-\infty}^{\infty} F_0(jn\Omega) \delta (\omega- n\Omega)\\ \sum_{n=-\infty}^{\infty} F_n e^{jn\Omega t} \longleftarrow& \longrightarrow 2\pi \sum_{n=-\infty}^{\infty} F_n \delta (\omega- n\Omega) \\ \end{aligned}

    展开全文
  • ORACLE 常用函数——聚合函数

    千次阅读 2018-07-19 14:02:31
    ORACLE 常用函数    这个系列我将整理一些日常我们经常使用到的ORACLE函数,鉴于篇幅太长,我大体会按下面分类来整理、汇总这些常用的ORACLE函数,如果有些常用函数没有被整理进来,也希望大家指点一二。 ...
  • oracle常用函数

    千次阅读 2020-06-29 08:45:58
    oracle常用函数 一般函数 NVL(E1, E2) :如果E1为null,则返回E2. coalesce(a,b,c,d) :返回第一个不是null的值。 NVL2(E1, E2, E3):如果E1为null,则返回E3,如果E1不为null,则返回E2. to_char(a):将a转换为...
  • Office Excel 常用函数

    万次阅读 2020-11-18 09:11:36
    文章链接
  • 每个Ajax 框架都对Javascript 做了扩展,提供了很多常用函数,增强了 Javascript 的开发效率。在这里将对部分Dojo 中的常用函数做简单的介绍。由于Dojo的常用函数较多,也为方便大家阅读,将这些常用函数分为了五个...
  • XPath常用函数

    万次阅读 2019-05-20 10:03:43
    有关数值的函数 有关字符串的函数 关于布尔值的函数 有关序列的函数 一般性的函数 测试序列容量的函数 Equals, Union, Intersection and Except 合计函数 生成序列的函数 上下文函数 函数示例 摘自W3...
  • Mysql 常用函数

    千次阅读 2018-01-11 14:30:51
    Mysql 常用函数集1.分类导航一共分为5类函数 1. 字符型函数 2. 数值型函数 3. 日期型函数 4. 统计型函数 5. 其它型函数 2.字符型函数[约48个]如下: ascii(str)bin(n)bit_length(str)char(n,... [using charset...
  • Excel常用函数大全

    万次阅读 多人点赞 2018-03-22 10:31:19
    Excel常用函数大全1、ABS函数 函数名称:ABS 主要功能:求出相应数字的绝对值。 使用格式:ABS(number) 参数说明:number代表需要求绝对值的数值或引用的单元格。 应用举例:如果在B2单元格中输入公式:=ABS(A2...
  • matlab常用函数

    千次阅读 2016-07-27 13:47:30
    本部分记录matlab常用函数 spy
  • C语言windows.h库的常用函数(二)

    万次阅读 多人点赞 2018-06-20 14:27:50
    emmm,最近学校事务繁忙,所拖更一个多月,所以对不起各位读者,今天更新windows.h库常用函数的第二期,第三期也在准备中。 GetCursorPos函数 在上一篇中的WindowFromPoint函数的示例代码中就已经用到了...
  • Excel常用函数介绍

    千次阅读 2018-06-15 20:46:34
    Excel常用函数 作者:任尚益 ...
  • Python的常用函数:append()

    万次阅读 多人点赞 2019-07-08 15:19:48
    Python的常用函数:append() 1. 描述 append()函数用于在列表末尾添加新的对象。 2. 语法 list.append(obj) 其中: list:列表对象; obj:添加到列表末尾的对象。 注意:append()函数无返回值,但是会修改原本的列表...
  • algorithm头文件下常用函数

    万次阅读 多人点赞 2018-04-23 21:40:48
    algorithm头文件下常用函数 1. max(),min(),abs() max(x,y)和min(x,y)分别返回x和y中的最大值和最小值,且参数必须是两个。 abs(x) 返回x的绝对值。x必须为整数,浮点型的绝对值要用math头文件下的fabs 2. ...
  • Python Radom常用函数

    千次阅读 2019-05-11 15:35:47
    Python Radom模块常用函数 常用函数 random()函数,生成0到1的随机小数 uniform(a,b)生成a到b的随机小数 randint(a,b)生成一个a到b的随即整数 randrange(a,b,c) 生成一个a到b,以c递增的数 choice() 随机返回一个...
  • Axure RP9教程 常用函数

    万次阅读 2020-06-07 17:21:58
    Axure教程 常用函数一、说明二、基本语法三、 数字函数1.toExponential(decimalPoints)2.toFixed(decimalPoints)3.toPrecision(length)四、 数学函数五、 字符串函数六、 时间函数函数七、中继器函数 一、说明 在...
  • DB2常用函数二:类型转换函数

    千次阅读 2017-10-17 15:08:27
    DB2类型转换常用函数
  • matlab常用函数与常用指令大全

    千次阅读 多人点赞 2016-05-06 14:11:58
    matlab常用函数与常用指令大全 matlab常用函数- - 1、特殊变量与常数 ans 计算结果的变量名 computer 确定运行的计算机 eps 浮点相对精度 Inf 无穷大 I 虚数单位 inputname 输入参数名 NaN 非数 ...
  • 044 麦克劳林公式常用函数记忆

    千次阅读 2017-10-09 19:31:14
    044 麦克劳林公式常用函数记忆
  • Xpath常用函数

    千次阅读 2015-07-21 16:44:01
    函数定义:返回类型不能是void,参数类型,常用函数,节点集函数 last()返回当前节点的最后一个节点的位置号数: eg://ul[@class='c-unstyled']/li[last()-1] 显示倒数第二个li元素 position()返回当前节点的...
  • C++ GMP常用函数

    千次阅读 2019-05-04 23:22:59
    C++ GMP常用函数 explicit mpz_class::mpz_class (const char *s, int base = 0) explicit mpz_class::mpz_class (const string& s, int base = 0) Construct an mpz_class converted from a string using mpz...
  • mysql常用函数整理

    千次阅读 2016-07-19 00:17:03
    mysql常用函数: 1⃣️concat(str1,str2,str3…) 同一条记录中多个字段进行连接 2⃣️group_concat(字段名) 一对多关联查询时,如果返回一条记录对应另外一张表多条记录,需要将那张表其中一个字段所有的值,...
  • oracle中常用函数大全

    万次阅读 多人点赞 2018-04-23 13:57:01
    1、数值型常用函数 函数 返回值 样例 显示ceil(n) 大于或等于数值n的最小整数 select ceil(10.6) from dual; 11floor(n) 小于等于数值n的最大整数 select ceil(10.6) from dual; 10mod(m,n) m除以n的余数,若n=...
  • Arduino常用函数总结

    万次阅读 2018-04-22 17:01:45
    Arduino常用函数总结https://wenku.baidu.com/view/6fc3460b27d3240c8547ef20.html1//数字 IO 口辒入辒出模式定义凼数 pinMode(pin, mode)2//设置数字 IO 口输出电平定义凼数 digitalWrite(pin, value)3//获取 IO ...
  • <Excel> 数据分析excel常用函数

    万次阅读 多人点赞 2018-10-23 17:12:42
    本文整理了用excel数据分析时的几种常用函数: 简单函数(包含加总、计数、平均、最值、排序、乘积、除余、取整) 逻辑函数(包含if、iferror、and、or) 文本函数(包含文本提取、文本查找、文本替换、文本转换及...
  • Tableau常用函数、功能

    千次阅读 2019-06-16 21:58:00
    Tableau常用函数 创建计算字段: Tableau常用功能 转载于:https://www.cnblogs.com/imcati/p/11033167.html
  • makefile中常用函数

    万次阅读 2016-07-29 03:46:12
    makefile中常用函数 http://blog.sina.com.cn/s/blog_4c4d6e74010009jr.html一函数的调用语法 二字符串处理函数subst fromtotext patsubst patternreplacementtext strip string findstring findin filter pattern...
  • SQL Server常用函数 & SQL语法函数

    万次阅读 2020-08-07 09:29:10
    一、字符转换函数 1、ASCII() 返回字符表达式最左端字符的ASCII 码值。在ASCII()函数中,纯数字的字符串可不用‘’括起来,但含其它字符的字符串必须用‘’括起来使用,否则会出错。 2、CHAR() 将ASCII 码转换为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,554
精华内容 63,821
关键字:

常用函数