const _String = Object.prototype.toString;

// 获取类型
function getType(item) {
  return _String.call(item).slice(8, -1);
}
// 判断类型
function isType(item, type) {
  return item && type && item === type;
}

// 考虑值是否是简单对象
// 1，该对象的返回原先必须是对象原型链，就是他自身
// 2.是否为window对象
// 3.是否object类型
function isPlianObejct(obj) {
  return (
    Object.getPrototypeOf(obj) === Object.prototype &&
    isWindow(obj) &&
    isType(obj, 'Object')
  );
}
// 考虑window是否为window(undefined)的情况
function isWindow(obj) {
  return obj != null && obj === obj.window;
}

// 拓展方法
function extend() {
  let target = arguments[0] || {},
    i = 1,
    lens = arguments.length,
    deep = false;

  let options, //待拷贝容器
    name, // 待拷贝容器的子项名称
    src, // 目标的子项内容
    copy, // 待拷贝容器的子项拷贝对象
    copyIsArr, // 拷贝对象是否为数组
    clone; // 需要再拷贝的内容

  // 如果参数第一个布尔值的话，则判断是否需要深拓展拷贝
  if (typeof target === 'boolean') {
    deep = target;
    //   将被拷贝值往后退一位
    target = arguments[1];
    // 同时被拷贝的项也往后推一位
    i++;
  }
  // 如果目标值不是对象，而且也不是方法的话,必须初始化为对象。
  if (typeof target !== 'object' && isType(target, 'Function')) {
    target = {};
  }

  // 如果参数长度等于初始化值的话
  //  待拷贝目标属于自身，同时将被拷贝内容序号往前推一位。
  if (i === lens) {
    target = this;
    i--;
  }

  //   开始正式拷贝
  for (; i < lens; i++) {
    //   将被拷贝对象赋值给otpions，同时必须保证对象不能为null
    if ((options = arguments[i]) != null) {
      // 循环options对象赋值给target
      for (name in options) {
        src = target[name];
        copy = options[name];

        // 如果拷贝对象和被拷贝的相等 则跳过该阶段的迭代，走一轮
        if (src === copy) {
          continue;
        }

        // 如果存在copy的值，且是深拷贝模式，且copy属于简单对象or属于数组对象
        if (
          deep &&
          copy &&
          isPlianObejct(copy || (copyIsArr = isType(copy, 'Array')))
        ) {
          if (copyIsArr) {
            // 如果为数组对象,则判断src是否为数组对象，
            // 如果是则赋值，不是则初始化数组[]
            clone = src && isType(src, 'Array') ? src : [];
          } else {
            // 同理
            // 如果src为简单对象,则判断src是否为数组对象，
            // 如果是则赋值，不是则初始化数组[]
            clone = src && isPlianObejct(obj) ? src : {};
          }
          //   递归该方法，不断往里面拷贝拓展
          target[name] = extend(deep, clone, copy);
        } else if (copy !== undefined) {
          target[name] = copy;
        }
      }
    }
  }
}

window.alert()

// 当前 HTML 的 URL
location.href
//  https://www.baidu.com/lastpath/go?name=zhangshan&id=89785#index

// 查询字符串部分
location.search
// ?name=zhangshan&id=89785

// #号后面的值
location.hash
// #index

// 域名
location.host
// www.baidu.com

// 主域名
location.hostname
// baidu.com

// 主域名后面部分/路径
location.pathname
// lastpath/go

// 端口号
location.port
// 80(默认端口号)

// 协议部分
location.protocal
// https:

// 加载指定的URL
location.assign()

// 替换指定的URL,不同于assgin，无法返回
location.replace()

// 刷新
location.reload()

Function.prototype.myApply = function(context,args){
    // 如果是调用自己，则返回undefined
    if(this===Function.prototype) return false;
    
    context=context || window;

    var fn = Symbol(),
    result;
    
    context[fn]=this;
    
    if(Array.isarray(args)){
        result = context[fn](...args);
    }else{
        result = context[fn]();
    }
    
    delete context[fn];
    return result;
}

let promise = new Promise((resolve, reject) => {
      console.log(1)
      // 如果执行失败，则调用reject()
      // reject('fail')
      
      console.log(2)
      
      // 如果执行成功，则调用resolve()
      resolve('success')
    })

    // 如果执行成功，则继续调用then方法
    promise.then(res => {
      // console.log(res)
      console.log(3)
    })

    // 如果执行失败，则用catach捕获失败
    promise.catch(err => {
      console.log(err)
      console.log(4)
    })

let _toString = Object.prototype.toString
// 类型库
let map = {
  array: 'Array',
  object: 'Object',
  function: 'Function',
  string: 'String',
  null: 'Null',
  undefined: 'Undefined',
  boolean: 'Boolean',
  number: 'Number'
}

// 获取类型
let getType = item => {
  // console.log(_toString.call(item))
  // [object Number]

  return _toString.call(item).slice(8, -1) // Number
}

// 判断类型是否相同
let isType = (item, type) => map[type] && map[type] === getType(item)