// 使用原始包装函数
var s = new String("my string");
var n = new Number(101);
var b = new Boolean(true);


// 推荐这种
var s = "my string";
var n = 101;
var b = true;

// 原始string
var greet = "Hello there";
// 使用split()方法分割
greet.split(' ')[0]; // "Hello"
// 给原始类型添加新属性不会报错
greet.smile = true;
// 单没法获取这个值（18章ECMAScript实现里我们讲了为什么）
console.log(typeof greet.smile); // "undefined"

// 原始string
var greet = new String("Hello there");
// 使用split()方法分割
greet.split(' ')[0]; // "Hello"
// 给包装函数类型添加新属性不会报错
greet.smile = true;
// 可以正常访问新属性
console.log(typeof greet.smile); // "boolean"

/**
 * 频率控制 返回函数连续调用时，func 执行频率限定为 次 / wait
 * 
 * @param  {function}   func      传入函数
 * @param  {number}     wait      表示时间窗口的间隔
 * @param  {object}     options   如果想忽略开始边界上的调用，传入{leading: false}。
 *                                如果想忽略结尾边界上的调用，传入{trailing: false}
 * @return {function}             返回客户调用函数   
 */
_.throttle = function(func, wait, options) {
  var context, args, result;
  var timeout = null;
  // 上次执行时间点
  var previous = 0;
  if (!options) options = {};
  // 延迟执行函数
  var later = function() {
    // 若设定了开始边界不执行选项，上次执行时间始终为0
    previous = options.leading === false ? 0 : _.now();
    timeout = null;
    result = func.apply(context, args);
    if (!timeout) context = args = null;
  };
  return function() {
    var now = _.now();
    // 首次执行时，如果设定了开始边界不执行选项，将上次执行时间设定为当前时间。
    if (!previous && options.leading === false) previous = now;
    // 延迟执行时间间隔
    var remaining = wait - (now - previous);
    context = this;
    args = arguments;
    // 延迟时间间隔remaining小于等于0，表示上次执行至此所间隔时间已经超过一个时间窗口
    // remaining大于时间窗口wait，表示客户端系统时间被调整过
    if (remaining <= 0 || remaining > wait) {
      clearTimeout(timeout);
      timeout = null;
      previous = now;
      result = func.apply(context, args);
      if (!timeout) context = args = null;
    //如果延迟执行不存在，且没有设定结尾边界不执行选项
    } else if (!timeout && options.trailing !== false) {
      timeout = setTimeout(later, remaining);
    }
    return result;
  };
};

/**
 * 空闲控制 返回函数连续调用时，空闲时间必须大于或等于 wait，func 才会执行
 *
 * @param  {function} func        传入函数
 * @param  {number}   wait        表示时间窗口的间隔
 * @param  {boolean}  immediate   设置为ture时，调用触发于开始边界而不是结束边界
 * @return {function}             返回客户调用函数
 */
_.debounce = function(func, wait, immediate) {
  var timeout, args, context, timestamp, result;

  var later = function() {
    // 据上一次触发时间间隔
    var last = _.now() - timestamp;

    // 上次被包装函数被调用时间间隔last小于设定时间间隔wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last);
    } else {
      timeout = null;
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args);
        if (!timeout) context = args = null;
      }
    }
  };

  return function() {
    context = this;
    args = arguments;
    timestamp = _.now();
    var callNow = immediate && !timeout;
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait);
    if (callNow) {
      result = func.apply(context, args);
      context = args = null;
    }

    return result;
  };
};

var Anim = function(){...};
Anim.prototype = {
    start:function() {
        ...
    },
    stop:function() {
        ...
    }
};

Function.prototype.method = function(name,fn) {
    this.prototype[name] = fn;
    return this;
};//用于链式调用
var Anim = function(){};
Anim.method('start',function() {});
Anim.method('stop',function() {});

function getBeerById(id, callback) {
    //使用Id来请求数据，返回数据。
    getRequest('get', 'beer.url ? id =' + id, function(resp) {
        //callback调用responseTest
        callback(resp.responseTest)
    });
}

var elm = document.getElementById('test');
elm.addEventListener('click', getBeerByIdBridge, false);
function getBeerByIdBridge(e) {
    getBeerById(this.id, function(beer) {
        console.log('Requested beer:' + beer);
    });
}

var a=[1,2,3], b=[4,5,6]
Array.prototype.push.apply(a, b);
//a = [1,2,3,4,5,6];

var arr = Array.prototype.slice.call(arguments);

//TODO: 有问题！
function preFixInt(num, length) {
  return (num / Math.pow(10,length)).toFixed(length).substr(2);
}

var a=[1,2,3,7,8,9], b=[4,5,6], insertIndex=3;
a.splice.apply(a, Array.prototype.concat(insertIndex, 0, b));
//a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

Math.max.apply(Math, [1,2,3]); //3
Math.min.apply(Math, [1,2,3]); //1

var str = "aaaaabbbccccbddddd";
console.log(str.split("").reverse().join(""));

funciton unq(a) {
  var b = [], c = {}, i;
  for (i in a) {
    c[a[i]] || (b.push(a[i])), c[a[i]] = true;
  }
  return b;
}

Array.prototype.unq = function () {
  var tempArr = [];
  var tempObj = {};
  for (var i=0; i<this.length; i++) {
    if (!(this[i] in tempObj) || !(this[i] === tempObj[this[i]])) {
      tempArr.push(this[i]);
      tempObj[this[i]] = this[i];
    }
    
  }
  return tempArr;
}

function randomFrom(low, up) {
  var choices = up - low + 1;
  return Math.floor(Math.random()*choices + low);
}