Ryan Shang

/**
 * 通过类名查找元素
 * @param strClass 一个或多个类名
 * @param context 上下文 范围(可选) 默认是document
 */
function getByClass(strClass, context) {
  context = context || document;
  if (document.getElementsByClassName) {
    return nodeListToArray(context.getElementsByClassName(strClass));
  }
  var aryClass = strClass.match(/\S+/);
  var eles = nodeListToArray(context.getElementsByTagName('*'));
  for (var i = 0; i < aryClass; i++) {
    var reg = new RegExp('(^| +)' + aryClass[i] + '( +|$)');
    for (var j = 0; j < eles.length; j++) {
      if (!reg.test(eles[i].className)) {
        eles.splice(j, 1);
        j--;
      }
    }
  }
  return eles;
}

/**
 *
 * @param ele 当前元素
 * @param strClass  单个类名
 * @return true|false
 */
function hasClass(ele, strClass) {
  var reg = new RegExp("(^| +)" + strClass + "( +|$)");
  return reg.test(ele.className)
}

/**
 * 添加类名
 * @param ele  当前的元素
 * @param strClass 一个类名或多个类名
 */
function addClass(ele, strClass) {
  var aryClass = strClass.replace(/(^\s+|\s+$)/g, "").split(/\s+/g);
  for (var i = 0; i < aryClass.length; i++) {
    var curClass = aryClass[i];
    if (!hasClass(ele, curClass)) { // 若没有这个类名,才添加
      ele.className += " " + curClass;
    }
  }
}

/**
 * 删除类名
 * @param ele  当前元素
 * @param strClass 一个类名或多个类名
 */
function removeClass(ele, strClass) {
  //拆分strClass,把每个类名拿到
  var aryClass = strClass.replace(/^ +| +$/g, "").split(/ +/g);
  for (var i = 0; i < aryClass.length; i++) {
    var curClass = aryClass[i]; // 每个类名
    // 判断是否有这个类名,若有这个类名,则把这个类名删了
    var reg = new RegExp("(^| +)" + curClass + "( +|$)", "g");
    if (hasClass(ele, curClass)) {
      ele.className = ele.className.replace(reg, " ");
    }
  }
}

/**
 * 获取任意css样式
 * @param ele 当前元素
 * @param attr css属性
 */
function getCss(ele, attr) {
  var res = null;
  if (typeof getComputedStyle == "function") {
    res = window.getComputedStyle(ele, null)[attr];
  } else {
    if (attr == "opacity") {
      res = ele.currentStyle.filter;//"alpha(opacity = 50)"
      var reg = /^alpha\(opacity\s*=\s*(\d+(?:\.\d+)?)\)$/;
      // reg.exec(res)[1] RegExp.$1
      res = reg.test(res) ? RegExp.$1 / 100 : 1;
    } else {
      res = ele.currentStyle[attr];
    }
  }
  // 对单位的处理
  // 若获取值是->左边是数值,右边是单位,则把单位去掉并转化成数类型
  var reg = /^[+-]?(?:\d+(?:\.\d+)?)(?:px|rem|pt|em)?$/i;
  return reg.test(res) ? parseFloat(res) : res;
}

/**
 *
 * @param ele 当前元素
 * @param attr css属性
 * @param value css属性值
 */
function setCss(ele, attr, value) {
  // 1.对浮动处理
  if (attr == "float") {
    ele.style.cssFloat = value;
    ele.style.styleFloat = value;
    return;
  }
  // 2.对透明度处理
  if (attr == "opacity") {
    ele.style.opacity = value;
    ele.style.filter = "alpha(opacity =" + value * 100 + ")";
    return;
  }
  // 3.设置单位-对没有设置单位的添加单位
  var reg = /^(?:width|height|((?:margin|padding)?(?:top|bottom|left|right)?))$/i;
  if (reg.test(attr) && !isNaN(value)) value = value + 'px';
  ele.style[attr] = value;
}

/**
 * 批量设置css样式
 * @param ele 当前元素
 * @param opt 对象类型 -每一项是css属性和css属性值
 */
function setGroup(ele, opt) {
  //先检测opt的数据类型
  if (Object.prototype.toString.call(opt) !== "[object Object]") return;
  for (var attr in opt) {
    setCss(ele, attr, opt[attr]);
  }
}

/**
 *通过参数确定是调用哪个方法(getCss,setCss,setGroup)
 */
function css() {
  var fn = getCss;
  if (arguments.length === 3) fn = setCss;
  if (arguments.length === 2 && typeof arguments[1] === 'object') fn = setCssGroup;
  return fn.apply(null, arguments);
}

let flat1 = (arr) => {
  let res = []
  let flat = (target) => {
    if (target instanceof Array) {
      target.forEach(item => {
        flat(item);
      })
    } else {
      res.push(target);
    }
  }
  flat(arr);
  return res
};

let flat2 = (arr) => {
  Array.prototype[Symbol.iterator] = function () {
    let arr = [].concat(this);
    let getFirst = (array) => {
      let first = array.shift();
      if (first instanceof Array) {
        if (first.length > 1) {
          arr = first.slice(1).concat(array);
        }
        first = first[0];
      }
      return first;
    };
    return {
      next: function () {
        let item = getFirst(arr);
        if (item !== undefined) {
          return {
            value: item,
            done: false
          };
        } else {
          return {
            done: true
          };
        }
      }
    };
  };
  let res = [];
  for (let i of arr) { res.push(i); }
  return res;
};

function bubbleSort(ary) {
  var flag = false;
  var temp = null;
  for (var i = 0; i < ary.length - 1; i++) {
    for (var j = 0; j < ary.length - 1 - i; j++) {
      if (ary[j] > ary[j + 1]) {
        temp = ary[j];
        ary[j] = ary[j + 1];
        ary[j + 1] = temp;
        flag = true;
      }
    }
    // 一轮过后没有变化，则已经是结果
    if (flag) {
      flag = false;
    } else {
      break;
    }
  }
  return ary;
}

function insertSort(ary) {
  var newAry = [];
  newAry.push(ary[0]);
  for (var i = 1; i < ary.length; i++) {
    var cur = ary[i];
    for (var j = newAry.length - 1; j >= 0;) {
      if (cur < newAry[j]) {
        j--;
        if (j === -1) {
          newAry.unshift(cur);
        }
      } else {
        newAry.splice(j + 1, 0, cur);
        j = -1;
      }
    }
  }
  return newAry;
}

function Father() {
  this.x = 10;
  this.y = 20;
}
Father.prototype.fn=function () {
  console.log(this.x);
};
function Son() {
  //this->实例
  Father.call(this); //父类上的私有属性拷贝一份放到子类的实例上
}