| /* |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * Created by jiachenpan on 16/11/18. |
| */ |
| |
| export function parseTime(time, cFormat) { |
| if (arguments.length === 0) { |
| return null |
| } |
| const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}' |
| let date |
| if (typeof time === 'object') { |
| date = time |
| } else { |
| if (('' + time).length === 10) time = parseInt(time) * 1000 |
| date = new Date(time) |
| } |
| const formatObj = { |
| y: date.getFullYear(), |
| m: date.getMonth() + 1, |
| d: date.getDate(), |
| h: date.getHours(), |
| i: date.getMinutes(), |
| s: date.getSeconds(), |
| a: date.getDay() |
| } |
| const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => { |
| let value = formatObj[key] |
| // Note: getDay() returns 0 on Sunday |
| if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value ] } |
| if (result.length > 0 && value < 10) { |
| value = '0' + value |
| } |
| return value || 0 |
| }) |
| return time_str |
| } |
| |
| export function formatTime(time, option) { |
| time = +time * 1000 |
| const d = new Date(time) |
| const now = Date.now() |
| |
| const diff = (now - d) / 1000 |
| |
| if (diff < 30) { |
| return '刚刚' |
| } else if (diff < 3600) { |
| // less 1 hour |
| return Math.ceil(diff / 60) + '分钟前' |
| } else if (diff < 3600 * 24) { |
| return Math.ceil(diff / 3600) + '小时前' |
| } else if (diff < 3600 * 24 * 2) { |
| return '1天前' |
| } |
| if (option) { |
| return parseTime(time, option) |
| } else { |
| return ( |
| d.getMonth() + |
| 1 + |
| '月' + |
| d.getDate() + |
| '日' + |
| d.getHours() + |
| '时' + |
| d.getMinutes() + |
| '分' |
| ) |
| } |
| } |
| |
| // 格式化时间 |
| export function getQueryObject(url) { |
| url = url == null ? window.location.href : url |
| const search = url.substring(url.lastIndexOf('?') + 1) |
| const obj = {} |
| const reg = /([^?&=]+)=([^?&=]*)/g |
| search.replace(reg, (rs, $1, $2) => { |
| const name = decodeURIComponent($1) |
| let val = decodeURIComponent($2) |
| val = String(val) |
| obj[name] = val |
| return rs |
| }) |
| return obj |
| } |
| |
| /** |
| *get getByteLen |
| * @param {Sting} val input value |
| * @returns {number} output value |
| */ |
| export function getByteLen(val) { |
| let len = 0 |
| for (let i = 0; i < val.length; i++) { |
| if (val[i].match(/[^\x00-\xff]/gi) != null) { |
| len += 1 |
| } else { |
| len += 0.5 |
| } |
| } |
| return Math.floor(len) |
| } |
| |
| export function cleanArray(actual) { |
| const newArray = [] |
| for (let i = 0; i < actual.length; i++) { |
| if (actual[i]) { |
| newArray.push(actual[i]) |
| } |
| } |
| return newArray |
| } |
| |
| export function param(json) { |
| if (!json) return '' |
| return cleanArray( |
| Object.keys(json).map(key => { |
| if (json[key] === undefined) return '' |
| return encodeURIComponent(key) + '=' + encodeURIComponent(json[key]) |
| }) |
| ).join('&') |
| } |
| |
| export function param2Obj(url) { |
| const search = url.split('?')[1] |
| if (!search) { |
| return {} |
| } |
| return JSON.parse( |
| '{"' + |
| decodeURIComponent(search) |
| .replace(/"/g, '\\"') |
| .replace(/&/g, '","') |
| .replace(/=/g, '":"') + |
| '"}' |
| ) |
| } |
| |
| export function html2Text(val) { |
| const div = document.createElement('div') |
| div.innerHTML = val |
| return div.textContent || div.innerText |
| } |
| |
| export function objectMerge(target, source) { |
| /* Merges two objects, |
| giving the last one precedence */ |
| |
| if (typeof target !== 'object') { |
| target = {} |
| } |
| if (Array.isArray(source)) { |
| return source.slice() |
| } |
| Object.keys(source).forEach(property => { |
| const sourceProperty = source[property] |
| if (typeof sourceProperty === 'object') { |
| target[property] = objectMerge(target[property], sourceProperty) |
| } else { |
| target[property] = sourceProperty |
| } |
| }) |
| return target |
| } |
| |
| export function toggleClass(element, className) { |
| if (!element || !className) { |
| return |
| } |
| let classString = element.className |
| const nameIndex = classString.indexOf(className) |
| if (nameIndex === -1) { |
| classString += '' + className |
| } else { |
| classString = |
| classString.substr(0, nameIndex) + |
| classString.substr(nameIndex + className.length) |
| } |
| element.className = classString |
| } |
| |
| export const pickerOptions = [ |
| { |
| text: '今天', |
| onClick(picker) { |
| const end = new Date() |
| const start = new Date(new Date().toDateString()) |
| end.setTime(start.getTime()) |
| picker.$emit('pick', [start, end]) |
| } |
| }, |
| { |
| text: '最近一周', |
| onClick(picker) { |
| const end = new Date(new Date().toDateString()) |
| const start = new Date() |
| start.setTime(end.getTime() - 3600 * 1000 * 24 * 7) |
| picker.$emit('pick', [start, end]) |
| } |
| }, |
| { |
| text: '最近一个月', |
| onClick(picker) { |
| const end = new Date(new Date().toDateString()) |
| const start = new Date() |
| start.setTime(start.getTime() - 3600 * 1000 * 24 * 30) |
| picker.$emit('pick', [start, end]) |
| } |
| }, |
| { |
| text: '最近三个月', |
| onClick(picker) { |
| const end = new Date(new Date().toDateString()) |
| const start = new Date() |
| start.setTime(start.getTime() - 3600 * 1000 * 24 * 90) |
| picker.$emit('pick', [start, end]) |
| } |
| } |
| ] |
| |
| export function getTime(type) { |
| if (type === 'start') { |
| return new Date().getTime() - 3600 * 1000 * 24 * 90 |
| } else { |
| return new Date(new Date().toDateString()) |
| } |
| } |
| |
| export function debounce(func, wait, immediate) { |
| let timeout, args, context, timestamp, result |
| |
| const later = function() { |
| // 据上一次触发时间间隔 |
| const last = +new Date() - 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(...args) { |
| context = this |
| timestamp = +new Date() |
| const callNow = immediate && !timeout |
| // 如果延时不存在,重新设定延时 |
| if (!timeout) timeout = setTimeout(later, wait) |
| if (callNow) { |
| result = func.apply(context, args) |
| context = args = null |
| } |
| |
| return result |
| } |
| } |
| |
| /** |
| * This is just a simple version of deep copy |
| * Has a lot of edge cases bug |
| * If you want to use a perfect deep copy, use lodash's _.cloneDeep |
| */ |
| export function deepClone(source) { |
| if (!source && typeof source !== 'object') { |
| throw new Error('error arguments', 'shallowClone') |
| } |
| const targetObj = source.constructor === Array ? [] : {} |
| Object.keys(source).forEach(keys => { |
| if (source[keys] && typeof source[keys] === 'object') { |
| targetObj[keys] = deepClone(source[keys]) |
| } else { |
| targetObj[keys] = source[keys] |
| } |
| }) |
| return targetObj |
| } |
| |
| export function uniqueArr(arr) { |
| return Array.from(new Set(arr)) |
| } |
| |
| export function isExternal(path) { |
| return /^(https?:|mailto:|tel:)/.test(path) |
| } |
| |
| export function parsePulsarSchema(path) { |
| if (path != null) { |
| return path.split('://') |
| } |
| return '' |
| } |
| |
| export function trim(str) { |
| return str.replace(/(^\s*)|(\s*$)/g, '') |
| } |
| |
| export function formatBytes(bytes, decimals = 2) { |
| if (bytes === 0) return '0 Bytes' |
| |
| const k = 1024 |
| const dm = decimals < 0 ? 0 : decimals |
| const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] |
| const i = Math.floor(Math.log(bytes) / Math.log(k)) |
| return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i] |
| } |