liujinhuan / learnnotes Goto Github PK

function debounce(func, wait, immediate) {

    var timeout, result;

    var debounced = function () {
        var context = this;
        var args = arguments;

        if (timeout) clearTimeout(timeout);
        // 是否立即执行
        if (immediate) {
            // 如果已经执行过，不再执行
            var callNow = !timeout;
            timeout = setTimeout(function(){
                timeout = null;
            }, wait)
            // 返回值的情况、处理this、处理参数event
            if (callNow) {
                result = func.apply(context, args)
            }
        } else {
            timeout = setTimeout(function(){
                func.apply(context, args)
            }, wait);
        }
        return result;
    };
    // 取消
    debounced.cancel = function() {
        clearTimeout(timeout);
        timeout = null;
    };

    return debounced;
}

// 使用时间戳
function throttle(func, wait) {
    var context,args;
    var previous = 0;
    return function(){
        var now = +Date()
        context = this;
        args = arguments
        if(now-previous>wait){
            func.apply(context,arg)
            previous = now
        }
    }
}
// 使用定时器
function throttle(func, wait) {
    var context,args,timeout;
    return function(){
        context = this;
        args = arguments
        if(!timeout){
            timeout = setTimeout(function(){
                timeout = null
                func.apply(context,arg)
            },wait)
        }
    }
}

// leading：false 表示禁用第一次执行
// trailing: false 表示禁用停止触发的回调
// 二者不可同时设置
function throttle(func, wait, options) {
    var timeout, context, args, result;
    var previous = 0;
    if (!options) options = {};

    var later = function() {
        previous = options.leading === false ? 0 : new Date().getTime();
        timeout = null;
        func.apply(context, args);
        if (!timeout) context = args = null;
    };

    var throttled = function() {
        var now = new Date().getTime();
        // 禁用第一次的话，上一个的时间就设置为此时
        if (!previous && options.leading === false) previous = now;
        // 下次触发 func 剩余的时间
        var remaining = wait - (now - previous);
        context = this;
        args = arguments;
        // 如果没有剩余的时间了或者你改了系统时间
        if (remaining <= 0 || remaining > wait) {
            // 清空定时器
            if (timeout) {
                clearTimeout(timeout);
                timeout = null;
            }
            // 上一个的时间就设置为此时
            previous = now;
            // 立即执行
            func.apply(context, args);
            if (!timeout) context = args = null;
        } else if (!timeout && options.trailing !== false) {// 禁用停止触发的回调
            timeout = setTimeout(later, remaining);
        }
    };
    throttled.cancel = function() {
        clearTimeout(timeout);
        previous = 0;
        timeout = null;
    }
    return throttled;
}

// array：表示要去重的数组，必填
// isSorted：表示函数传入的数组是否已排过序，如果为 true，将会采用更快的方法进行去重
// iteratee：传入一个函数，可以对每个元素进行重新的计算，然后根据处理的结果进行去重
var array3 = [1, 1, 'a', 'A', 2, 2];

// 第二版
// iteratee 英文释义：迭代 重复
function unique(array, isSorted, iteratee) {
    var res = [];
    var seen = [];

    for (var i = 0, len = array.length; i < len; i++) {
        var value = array[i];
        var computed = iteratee ? iteratee(value, i, array) : value;
        if (isSorted) {
            if (!i || seen !== computed) {
                res.push(value)
            }
            seen = computed;
        }
        else if (iteratee) {
            if (seen.indexOf(computed) === -1) {
                seen.push(computed);
                res.push(value);
            }
        }
        else if (res.indexOf(value) === -1) {
            res.push(value);
        }        
    }
    return res;
}

console.log(unique(array3, false, function(item){
    return typeof item == 'string' ? item.toLowerCase() : item
})); // [1, "a", 2]

// 第二版
var class2type = {};

// 生成class2type映射
"Boolean Number String Function Array Date RegExp Object Error".split(" ").map(function(item, index) {
    class2type["[object " + item + "]"] = item.toLowerCase();
})

function type(obj) {
    // 一箭双雕
    if (obj == null) {
        return obj + "";
    }
    return typeof obj === "object" || typeof obj === "function" ?
        class2type[Object.prototype.toString.call(obj)] || "object" :
        typeof obj;
}

var shallowCopy = function(obj) {
    // 只拷贝对象
    if (typeof obj !== 'object') return;
    // 根据obj的类型判断是新建一个数组还是对象
    var newObj = obj instanceof Array ? [] : {};
    // 遍历obj，并且判断是obj的属性才拷贝
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            newObj[key] = obj[key];
        }
    }
    return newObj;
}

var deepCopy = function(obj) {
    if (typeof obj !== 'object') return;
    var newObj = obj instanceof Array ? [] : {};
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            newObj[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key];
        }
    }
    return newObj;
}

sudo npm install verdaccio -g

npm set registry http://localhost:4873

npm adduser –registry http://localhost:4873

// 创建测试文件夹
mkdir npmtest
// 初始化项目，一路回车即可
npm init 
// 创建index.js文件，内容如下
!function(){
    console.log(`这是引入的包入口`)
}()

// 发布
npm publish
// 期间可能会遇到提示未登录的错误信息，重新登录下即可，输入userName 和 password 和 email
npm login –registry http://localhost:4873

// 创建测试目录
mkdir test
// 初始化项目，一路回车
npm init
// 安装我们自己的包依赖，可以在package.json文件中看到
npm install npmtest@1.0.0 --save-dev
// 编写测试文件index.js，内容如下
var f = require('npmtest')
// 执行测试文件，结果如下图所示就OK了
node index.js