document.activeElement

mix.js('resources/assets/vuejs/user/user.js', 'public/js');
mix.sass('resources/assets/vuejs/user/assets/theme/black.scss', 'public/css', {outputStyle: 'compressed'});
mix.sass('resources/assets/vuejs/user/assets/theme/white.scss', 'public/css', {outputStyle: 'compressed'});

// 生产环境
if (mix.inProduction()) {
  mix.version([]);
  mix.options({
    uglify: {
      parallel: true, // 加快构建速度
      sourceMap: false
    }
  });

  // 去除console.log
  mix.config.uglify.uglifyOptions = {
    compress: {
      warnings: false,
      drop_console: true,
      pure_funcs: ['console.log']
    }
  };
}

网页可见区域宽：document.body.clientWidth 
网页可见区域高：document.body.clientHeight 
网页可见区域宽：document.body.offsetWidth (包括边线的宽) 
网页可见区域高：document.body.offsetHeight (包括边线的宽) 
网页正文全文宽：document.body.scrollWidth 
网页正文全文高：document.body.scrollHeight 
网页被卷去的高：document.body.scrollTop 
网页被卷去的左：document.body.scrollLeft 
网页正文部分上：window.screenTop 
网页正文部分左：window.screenLeft 
屏幕分辨率的高：window.screen.height 
屏幕分辨率的宽：window.screen.width 
屏幕可用工作区高度：window.screen.availHeight 
屏幕可用工作区宽度：window.screen.availWidth 


HTML精确定位:scrollLeft,scrollWidth,clientWidth,offsetWidth 
scrollHeight: 获取对象的滚动高度。 
scrollLeft:设置或获取位于对象左边界和窗口中目前可见内容的最左端之间的距离 
scrollTop:设置或获取位于对象最顶端和窗口中可见内容的最顶端之间的距离 
scrollWidth:获取对象的滚动宽度 
offsetHeight:获取对象相对于版面或由父坐标 offsetParent 属性指定的父坐标的高度 
offsetLeft:获取对象相对于版面或由 offsetParent 属性指定的父坐标的计算左侧位置 
offsetTop:获取对象相对于版面或由 offsetTop 属性指定的父坐标的计算顶端位置 
event.clientX 相对文档的水平座标 
event.clientY 相对文档的垂直座标 
event.offsetX 相对容器的水平坐标 
event.offsetY 相对容器的垂直坐标 
document.documentElement.scrollTop 垂直方向滚动的值 
event.clientX+document.documentElement.scrollTop 相对文档的水平座标+垂直方向滚动的

"dependencies": {
    "lerna": "file:core/lerna"
 }

function (num, len) {
  return (Array(len).join('0') + num).slice(-len)
}

var taskChartOpt = {
      color: ['#d5a200', '#10d092', '#4cc3cb', '#716cc5', '#ef5350'],
      tooltip: {
        trigger: 'axis',
        axisPointer: { // 坐标轴指示器，坐标轴触发有效
          type: 'shadow' // 默认为直线，可选为：'line' | 'shadow'
        },
        formatter: function (params) {
          return params[0].name + '<br>' + params[0].marker + params[0].seriesName + ': ' + byteFormat(params[0].value)
        }
      },
      grid: {
        left: '3%',
        right: '4%',
        bottom: '0',
        containLabel: true
      },
      xAxis: {
        type: 'category',
        data: [],
        axisLine: {
          show: false
        },
        axisTick: {
          show: false
        },
        axisLabel: {
          color: '#5182c1',
          interval: 0,
          rotate: 20
        }
      },
      yAxis: {
        type: 'value',
        axisLine: {
          show: false,
        },
        axisTick: {
          show: false
        },
        splitLine: {
          lineStyle: {
            type: 'dashed',
            color: '#1f385e5f'
          }
        },
        axisLabel: {
          color: '#5182c1',
        }
      },
      series: [{
        name: '空间占用',
        type: 'bar',
        itemStyle: {
          normal: {
            color: function (params) {
              var colorList = ['#d5a200', '#10d092', '#4cc3cb', '#716cc5', '#ef5350'];
              return colorList[params.dataIndex];
            }
          }
        },
        barWidth: '30%',
        data: []
      }]
    };

import 'element-ui/lib/theme-default/index.css'

import 'element-ui/lib/theme-chalk/index.css'

configureWebpack: {
  resolve: {
    alias: {
      'vue$': 'vue/dist/vue.esm.js' 
    }
  }
}

// 手动重定向页面到 '/redirect' 页面
const { fullPath } = this.$route
this.$router.replace({
  path: '/redirect' + fullPath
})

<script>
export default {
  inject: ['reload']
}
</script>

    function onScroll() {
      var scrollH = $('#carousel-container').height()
      var windowH = $(window).scrollTop()
      if (windowH > scrollH) {
        $('.navbar-default').addClass('active')
      } else {
        $('.navbar-default').removeClass('active')
      }
    }
    window.addEventListener('scroll', onScroll, false);

  let a = document.createElement('a')
  a.setAttribute('href', `文件的地址`)
  a.setAttribute('download', '') // 强制下载
  document.body.appendChild(a)
  a.click()
  document.body.removeChild(a) // 下载后移除a标签

/**
 * 函数节流
 * @param {Function} fn 函数
 * @param {Number} delay 延时
 */
function throttle(fn, delay) {
  var baseTime = 0
  return function () {
    var currentTime = Date.now()
    if (baseTime + delay <= currentTime) {
      baseTime = currentTime
      fn.apply(this, arguments)
    }
  }
}

/**
 * 函数节流
 * @param {Function} fn 函数
 * @param {Number} delay 延时
 * @param {Object} context 上下文
 */
function throttle (fn, delay = 100, context = this) {
  let timeout = null
  let fnArgs = null
  return (...args) => {
    if (!timeout) {
      fnArgs = args
      timeout = setTimeout(() => {
        fn.apply(context, fnArgs)
        timeout = null
      }, delay)
    }
  }
}

const mutations = {
  EDIT (state, obj) {
    for(var i in obj){
      state[i] = obj[i]  // 覆盖
    }
  }
}

toTree(data) {
  data.forEach((item) => {
    delete item.children
  })
  this.treeObj = {}
  let map = {}
  data.forEach((item) => {
    map[item.Id] = item
  })
  this.treeObj = map
  let val = []
  data.forEach((item) => {
    let parent = map[item.ParentId]
    if (parent) {
      (parent.children || ( parent.children = [] )).push(item)
    } else {
      item.children = []
      val.push(item)
    }
  })
  return val
}

/**
 * @jest-environment node
 */

function insertContent(content) {
      if (!content) { // 如果插入的内容为空则返回
        return
      }
      let sel = null
      if (document.selection) { // IE9以下
        sel = document.selection
        sel.createRange().pasteHTML(content)
      } else {
        sel = window.getSelection()
        console.log(sel)
        if (sel.rangeCount > 0) {
          let range = sel.getRangeAt(0) // 获取选择范围
          range.deleteContents() // 删除选中的内容
          let el = document.createElement("div") // 创建一个空的div外壳 
          el.innerHTML = content // 设置div内容为我们想要插入的内容。
          let frag = document.createDocumentFragment() // 创建一个空白的文档片段，便于之后插入dom树
          let node = el.firstChild
          let lastNode = frag.appendChild(node)
          range.insertNode(frag) // 设置选择范围的内容为插入的内容
          let contentRange = range.cloneRange() // 克隆选区
          contentRange.setStartAfter(lastNode) // 设置光标位置为插入内容的末尾
          contentRange.collapse(true) // 移动光标位置到末尾
          sel.removeAllRanges() // 移出所有选区
          sel.addRange(contentRange) // 添加修改后的选区
        }
      }
    }
  }

export default function getChromePath () {
  if (process.platform === 'win32') {
    return 'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'
  } else {
    return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
  }
}

const puppeteer = require('puppeteer-core')
... ...
await puppeteer.launch({
  headless: true,
  executablePath: this.getChromePath()
})

... ...
 created () {
    try {
      document.body.removeChild(document.getElementById('loading-spinner'))
    } catch (e) {
    }
  },
... ...

fileChange (e) {
  const file = e.target.files[0]
  const reader = new FileReader()
  reader.onload = (evt) => {
    this.importContent = evt.target.result
  }
  reader.readAsText(file)
}

this.$options.filters

document.querySelector('css选择器').scrollIntoView({
    behavior: 'smooth'
})

window.scroll({
  top: 2500, 
  left: 0, 
  behavior: 'smooth'
});

window.addEventListener('beforeunload', event => {
  event.preventDefault()
  event.returnValue = true
})

`testestetaet<0,1,5,1,False,False>ewfafewf`.match(/\<([^>]+)\>/)[1]

dom.value(newval)
dom.dispatchEvent(new Event('input'))

const copyToClipboard = str => {
  const el = document.createElement('textarea');
  el.value = str;
  el.setAttribute('readonly', '');
  el.style.position = 'absolute';
  el.style.left = '-9999px';
  document.body.appendChild(el);
  const selected =
    document.getSelection().rangeCount > 0 ? document.getSelection().getRangeAt(0) : false;
  el.select();
  document.execCommand('copy');
  document.body.removeChild(el);
  if (selected) {
    document.getSelection().removeAllRanges();
    document.getSelection().addRange(selected);
  }
};

/**
 * 深拷贝
 * @param {*} obj 拷贝对象(object or array)
 * @param {*} cache 缓存数组
 */
function deepCopy (obj, cache = []) {
  // typeof [] => 'object'
  // typeof {} => 'object'
  if (obj === null || typeof obj !== 'object') {
    return obj
  }
  // 如果传入的对象与缓存的相等, 则递归结束, 这样防止循环
  /**
   * 类似下面这种
   * var a = {b:1}
   * a.c = a
   * 资料: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value
   */
  const hit = cache.filter(c => c.original === obj)[0]
  if (hit) {
    return hit.copy
  }

  const copy = Array.isArray(obj) ?  [] :   {}
  // 将copy首先放入cache, 因为我们需要在递归deepCopy的时候引用它
  cache.push({
    original: obj,
    copy
  })
  Object.keys(obj).forEach(key => {
    copy[key] = deepCopy(obj[key], cache)
  })

  return copy
}

function stringifyRep(key, value) {
  if (typeof value === "function") {
    return `${value}`;
  }
  return value;
}
function parseRep(key, value) {
  return eval(value);
}
var a = {
  b: () => 1 + 1
}
var aa = JSON.parse(JSON.stringify(a, stringifyRep), parseRep)

import Vue from 'vue'
import Vuex from 'vuex'
import getters from './getters'

Vue.use(Vuex)

// https://webpack.js.org/guides/dependency-management/#requirecontext
const modulesFiles = require.context('./modules', false, /\.js$/)

// you do not need `import app from './modules/app'`
// it will auto require all vuex module from modules file
const modules = modulesFiles.keys().reduce((modules, modulePath) => {
  // set './app.js' => 'app'
  const moduleName = modulePath.replace(/^\.\/(.*)\.\w+$/, '$1')
  const value = modulesFiles(modulePath)
  modules[moduleName] = value.default
  return modules
}, {})

const store = new Vuex.Store({
  modules,
  getters
})

export default store

/<\/?.+?\/?>/g

    getSuperResultTree() {
      // 初始化结果树
      this.treeResultData = JSON.parse(JSON.stringify(this.defaultResultData))
      const arr = JSON.parse(JSON.stringify(this.$refs.leftTree.getCheckedNodes(true)))
      this.useTotal = arr.length // 计入高级搜索的分类数, 用于判断结束
      // 将选择的分类相关节点遍历到指定位置
      arr.forEach(v => {
        let i1 = this.treeResultData.findIndex(t1 => {
          return t1.id === v.res[0]
        })
        let i2 = this.treeResultData[i1].children.findIndex(t2 => {
          return t2.data_type === v.res[1]
        })
        this.treeResultData[i1].children[i2].children.push(v)
      })
      // 清除未用节点
      this.treeResultData = this.treeResultData.filter(v => {
        v.children = v.children.filter(u => {
          return u.children.length !== 0
        })
        return v.children.length !== 0
      })
      console.log('高级结果树', this.treeResultData)
    }

function ImgToBase64(file, maxLen, callBack) {
  var img = new Image();

  var reader = new FileReader();//读取客户端上的文件
  reader.onload = function () {
      var url = reader.result;//读取到的文件内容.这个属性只在读取操作完成之后才有效,并且数据的格式取决于读取操作是由哪个方法发起的.所以必须使用reader.onload，
      img.src = url;//reader读取的文件内容是base64,利用这个url就能实现上传前预览图片
  };
  img.onload = function () {
      img.width = maxLen;
      img.height = maxLen;
      //生成canvas
      var canvas = document.createElement("canvas");
      var ctx = canvas.getContext("2d");
      canvas.width = img.width;
      canvas.height = img.height;
      ctx.drawImage(img, 0, 0, img.width, img.height);
      var base64 = canvas.toDataURL('image/jpeg', 0.9);
      callBack(base64);
  };
  reader.readAsDataURL(file);
}

var obj = Object.create(null)

obj.test = 'ttt'
obj.hasOwnProperty('test') // => Uncaught TypeError: obj.hasOwnProperty is not a function
Object.hasOwnProperty.call(obj, 'test') // => true
Object.hasOwnProperty.apply(obj, ['test']) // => true
Object.hasOwnProperty.bind(obj)('test') // => true

import 'es6-promise/auto'