console.log('script start');

setTimeout(function() {
  console.log('setTimeout');
}, 0);

Promise.resolve().then(function() {
  console.log('promise1');
}).then(function() {
  console.log('promise2');
});

console.log('script end');

// 执行顺序
// script start
// script end
// promise1
// promise2
// setTimeout

    /**
     * 格式为`百分比方式显示` 
     * 
     * @param {number} molecular 分子 `横线`上面的数
     * @param {number} denominator 分母
     * @see [百度百科-分数](https://baike.baidu.com/item/%E5%88%86%E6%95%B0/2067623?fr=aladdin)
     * @see [a](http://www.css88.com/archives/7340)
     */
    function getPercentNumber(molecular, denominator) {
        
        // 这种写法, 牵扯了浮点型小数问题
        // const quotient = Number((molecular / denominator).toFixed(2)) * 100;

        // 方式1：移位运算
        // console.log( (molecular / denominator) * 100 >> 2 );
        // return (molecular / denominator) * 100 >> 2;

        // 方式2：换成整数方式处理
        // console.log( parseInt(String(molecular / denominator * 100)) );
        // console.log(denominator, molecular);
        return parseInt(String(molecular / denominator * 100));

    }

console.log( getPercentNumber(1, 3) );    // 33  -- number
console.log( getPercentNumber(23, 60) );  // 38
console.log( getPercentNumber(66, 100) ); // 66

function formatWan(n) {
    if (n <= 10000) return `${n}`;
    n = n.toString(); // 返回字符串表示
    return (n / 10000).toFixed(1) + '万'; // toFixed(1)四舍五入保留指定小数位小数
}
console.log( formatWan(100) );    // '100'
console.log( formatWan(10000) );  // '10000'
console.log( formatWan(100000) ); // '10.0万'

/**
 * 判断某个数字有几位小数.
 *
 * @param {number} num 需要判断的数字
 * @param {number} len 指定小数点位数
 * @return {boolean} 数字判断位数后的结果
 * 
 * @see https://blog.csdn.net/yanlingdi/article/details/52849314
 */
 function isNumLen(num, len) {
        const x = String(num).indexOf('.') + 1; // 小数点的位置
        const y = String(num).length - x; // 位数

        if (x >= len) { // 不少于指定位数
          return true;
        } else {
          return false;
        }
   }

/**
 * 浮点值处理为至多两位小数. 
 * 
 * @param {number} num 需要格式化的数字.
 * @return {number|string} 格式化后的数字或字符串.
 * @see https://www.jb51.net/article/120127.htm
 * @see https://www.runoob.com/w3cnote/javascript-two-decimal.html
 */
 function getNum(num) {
        // console.log(typeof num, num);
        // if (num == 0) return 0;
        // console.log('浮动处理');

        // const reg = /([0-9]+\.[0-9]{2})[0-9]*/;
        // return num.replace(reg, '$1');
        const isThan2 = isNumLen(num, 2);
        if (isThan2) { // 至少两位小数
          return num.toFixed(2);
        } else {
          return num;
        }
   }

console.log( getNum(100) );          // 100
console.log( getNum(100.1) );        // 100.10
console.log( getNum(100.20) );      // 100.20
console.log( getNum(100.25) );      // 100.25
console.log( getNum(100.253) );    // 100.25
console.log( getNum(100.255) );    // 100.25

// method1
new Array()

// method2
new Array(size)

// method3
new Array(elem0, elem1, ..., elem)

const arr1 = new Array();
const arr2 = new Array(1);
const arr3 = new Array(0, 1, 2, 3, 4);
const arr4 = new Array(0, [1, 3], [4, 5]);

console.log(arr1);  // []
console.log(arr2);  // [empty]
console.log(arr3);  // [0, 1, 2, 3, 4];
console.log(arr4);  // [0, [1, 3], [4, 5]];

const arr = new Array(5).fill(1);
console.log(arr);  // [1, 1, 1, 1, 1]

let a = [1, true, 'abc'];
let b = [a[0], a[0]*2, f(x)];

let a = new Array();                       // a.length 初始化为 0

let b = new Array(3);                      // b.length 初始化为 3

let c = new Array('one', 'two', 'three');  // c.length 初始化为 3
c[4] = 'four';                             // c.length 更新为 5
c[5] = 'blastoff';                         // c.length 更新为 6
console.log(c);                            // ["one", "two", "three", empty, "four", "blastoff"]
console.log(c[3]);                         // undefined 空的项被 undefined 填充 
console.log(c.length);                     // 返回 c 的长度，这里为 6 

const arr = [];

console.log(arr.length); // 0

// 原数组内容增加了一项
arr.length = 1;
console.log(arr);        // [empty] 

arr[0] = 1;
console.log(arr);        // [1]
console.log(arr.length); // 1

arr[1] = 2;
console.log(arr);        // [1, 2]
console.log(arr.length); // 2

// 原数组内容不改变.
arr.length = 2;          
console.log(arr);        // [1, 2]

// 原数组内容被删除了.
arr.length = 1;          
console.log(arr);        // [1]

    // @desc 通过给Function.prototype增加方法来使得该方法对所有函数都可用
    //       通过给Function.prototype增加一个method方法，我们下次给对象增加
    //       方法的时候就不必键入prototype这一个字符,省去了麻烦，
    //       这样添加以后所有的构造函数（这里是给函数添加的方法）由于构造函数
    //       也是函数，所以所有的函数都可以用
    // @example 
    // ```
    // Array.method('eReduce', func)
    // ```
    if (Function.prototype.method !== 'function') {
        Function.prototype.method = function(name, func) {
            // TODO: 扩展函数的功能
        }
    }

Array.from(arrayLike[, mapFn[, thisArg]])

Array.from('Hello'); // => ["H", "e", "l", "l", "o"]

// 
let s = new Set(['Hello', window]);
Array.from(s);  // => ["Hello", Window]

// Map
let m = new Map([[1, 2], [3, 4], [5, 6]]);
Array.from(m) // => [[1, 2], [3, 4], [5, 6]]

// 
function fn() {
    return Array.from(arguments);
}
fn(1, 2, 3); // => [1, 2, 3]

const arr = [1, 2, 3];
Array.from(arr, x => x + x); // => [2, 4, 6]

Array.isArray(obj)

// 下面的函数调用都返回 true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
// 鲜为人知的事实：其实 Array.prototype 也是一个数组。
Array.isArray(Array.prototype); 

// 下面的函数调用都返回 false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray('Array');
Array.isArray(true);
Array.isArray(false);
Array.isArray({ __proto__: Array.prototype });
// Q1
Array.isArray(Array);

const iframe = document.createElement('iframe');
document.body.appendChild(iframe);

const xArray = window.frames[window.frames.length-1].Array;
const arr = new xArray(1, 2, 3);

Array.isArray(arr);      // => true
arr instanceof Array;    // => false

const arr1 = [1, 2, 3];
Array.isArray(arr1);     // => true
arr1 instanceof Array;   // => true

Array.of(element0[, element1[, ...[, elementN]]])

Array.of(7);           // => [7] 
Array.of(1, 2, 3);     // => [1, 2, 3]

Array(7);              // => [ , , , , , , ]
Array(1, 2, 3);        // => [1, 2, 3]

const arr1 = Array(7);
console.log(arr1[0]);  // => undefined

Array.of(1);         // => [1]
Array.of(1, 2, 3);   // => [1, 2, 3]
Array.of(undefined); // => [undefined]

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

let a = [1, 2, 3];
let a1 = a.concat(4, 5);            // => a1 = [1, 2, 3, 4, 5]；        a不变
let a2 = a.concat([4, 5]);          // => a2 = [1, 2, 3, 4, 5];         a不变
let a3 = a.concat([4, 5], [6, 7]);  // => a3 = [1, 2 ,3 ,4, 5, 6, 7];   a不变
let a4 = a.concat(4, [5, [6, 7]]);  // => a4 = [1, 2, 3, 4, 5, [6, 7]]; a不变

const a = [1, 2, 3],
      b = [4, 5],
      c = [6, [0, 0]];

let d = [],
    e = [];

d = a.concat(a, b);

console.log(d); // [ 1, 2, 3, 1, 2, 3, 4, 5 ]
console.log(a); // [ 1, 2, 3 ]
console.log(b); // [ 4, 5 ]

const a = [1, 2, 3],
      b = [4, 5],
      c = [6, [0, 0]];

let d = [],
    e = [];
e = a.concat(b, c);

console.log(e); // [ 1, 2, 3, 4, 5, 6, [ 0, 0 ] ] 
console.log(c); // [ 6, [ 0, 0 ] ]

const thisArr = [0];
// feat1
const arr1 = [].concat.apply(thisArr, [1, 2, 3]);
// or
// const arr1 = [].concat.call(thisArr, 1, 2, 3);

const arr2 = thisArr.concat(1, 2, 3);
// or
// const arr2 = thisArr.concat([1, 2, 3]);

console.log(thisArr); // [0]
console.log(arr1);    // [0, 1, 2, 3]
console.log(arr2);    // [0, 1, 2, 3] 

let result1 = [1, 2, 3].every( x => x < 5 ); // => result1 = true
let result2 = [1, 2, 3].every( x => x < 3 ); // => result2 = false
let result3 = [].every( x => false ); // true: []总返回true

let result = [1, 2, 3].filter( x => x > 1 ) // => result = [2, 3];

let a = [1, 2, 3];
a.forEach( (x, i, a) => { a[i]++; }); // a = [1, 4, 9];

let result1 = ['a', 'b', 'c'].indexOf('b'); // => 1 即 result1 == 1
let result2 = ['a', 'b', 'c'].indexOf('d'); // => -1 即 result2 == -1
let result3 = ['a', 'b', 'c'].indexOf('a', 1); // => -1 即 result3 == -1

let a = new Array(1, 2, 3, 'testing');
s = a.join('+'); // => s == '1+2+3+testing'

let result = [1, 2, 3].map( x => x*x ); // => result == [1, 4, 9]

// pop()与伴随的push()方法。可以提供先进后出（FILO）的栈功能
let stack = []; // stack: []
let s1 = stack.push(1, 2); // stack: [1, 2] s1 == 2
let s2 = stack.pop(); // stack: [1] s2 == 2
let s3 = stack.push([4, 5]); // stack: [1, [4, 5]] s3 == 2
let s4 = stack.pop(); // stack: [1] s4 == [4, 5]
let s5 = stack.pop(); // stack: []  s5 == 1

let r = [1, 2, 3, 4].reduce((x, y) => x*y); // => r == 24

let r = [2, 10, 60].reduceRight((x, y) => x / y); // => r == 3

let a = new Array(1, 2, 3); // => a[0] == 1, a[2] == 3;
a.reverse(); // => a[0] == 3, a[2] == 1;

let a = [1, [2, 3], 4];
let s = a.shift(); // => s == 1; a == [[2, 3], 4];
let s2 = a.shift(); // => s2 == [2, 3]; a == [4]

let a = [1, 2, 3, 4, 5];
let s1 = a.slice(0, 3); // => s1 == [1, 2, 3]
let s2 = a.slice(3); // s2 == [4, 5]
let s3 = a.slice(1, -1); // s3 == [2, 3, 4]
let s4 = a.slice(-3, -2); // => s4 == [3] ；但在ie4下有误,返回[1, 2, 3]

let s1 = [1, 2, 3].some(x => x > 5); // => s1 == false
let s2 = [1, 2, 3].some(x => x > 2); // => s2 == true
let s3 = [1, 2, 3].some(x => false); // => s3 = false; []总是返回false

// 用来数组排序的排序函数
function numberOreder(a, b) { return a - b };
a = new Array(33, 4, 111, 222);
let s1 = a.sort(); // => s1 == [1111, 222, 33, 4] 字母排序
let s2 = a.sort( numberOrder ); // => s2 == [4, 33, 222, 1111] 数值排序

var a = [1, 2, 3, 4, 5, 6, 7, 8];
let s1 = a.splice(1, 2); // => s1 == [2, 3]; a == [1, 4, 5, 6, 7, 8];
let s2 = a.splice(1, 1); // => s2 == [4]; a == [1, 5, 6, 7, 8];
let s3 = a.splice(1,0,2,3) // => s3 == []; a == [1,2,3,5,6,7,8]

// unshift()经常与shift()一起使用
let a = [];
let s1 = a.unshift(1); // => s1 == 1; a == [1]
let s2 = a.unshift(22); // => s2 == 2; a == [22, 1]
let s3 = a.shift(); // => s3 == 1; a == [1];
let s4 = a.unshift(33, [4, 5]); // => s4 == 3 ; a == [33, [4, 5], 1];

console.log(...[1, 2, 3])
// 1 2 3

console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5

[...document.querySelectorAll('div')]
// [<div>, <div>, <div>]

function push(array, ...items) {
  array.push(...items);
}

function add(x, y) {
  return x + y;
}

var numbers = [4, 38];
add(...numbers) // 42

function f(v, w, x, y, z) { }
var args = [0, 1];
f(-1, ...args, 2, ...[3]);

const arr = [
  ...(x > 0 ? ['a'] : []),
  'b',
];

[...[], 1]
// [1]

// ES5 的写法
function f(x, y, z) {
  // ...
}
var args = [0, 1, 2];
f.apply(null, args);

// ES6的写法
function f(x, y, z) {
  // ...
}
var args = [0, 1, 2];
f(...args);

// ES5 的写法
Math.max.apply(null, [14, 3, 77])

// ES6 的写法
Math.max(...[14, 3, 77])

// 等同于
Math.max(14, 3, 77);

// ES5的 写法
var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
Array.prototype.push.apply(arr1, arr2);

// ES6 的写法
var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
arr1.push(...arr2);

// ES5
new (Date.bind.apply(Date, [null, 2015, 1, 1]))
// ES6
new Date(...[2015, 1, 1]);

// ES5
[1, 2].concat(more)
// ES6
[1, 2, ...more]

var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e'];

// ES5的合并数组
arr1.concat(arr2, arr3);
// [ 'a', 'b', 'c', 'd', 'e' ]

// ES6的合并数组
[...arr1, ...arr2, ...arr3]
// [ 'a', 'b', 'c', 'd', 'e' ]

// ES5
a = list[0], rest = list.slice(1)
// ES6
[a, ...rest] = list

const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest  // [2, 3, 4, 5]

const [first, ...rest] = [];
first // undefined
rest  // []

const [first, ...rest] = ["foo"];
first  // "foo"
rest   // []

const [...butLast, last] = [1, 2, 3, 4, 5];
// 报错

const [first, ...middle, last] = [1, 2, 3, 4, 5];
// 报错

var dateFields = readDateFields(database);
var d = new Date(...dateFields);

[...'hello']
// [ "h", "e", "l", "l", "o" ]

'x\uD83D\uDE80y'.length // 4
[...'x\uD83D\uDE80y'].length // 3

function length(str) {
  return [...str].length;
}

length('x\uD83D\uDE80y') // 3

let str = 'x\uD83D\uDE80y';

str.split('').reverse().join('')
// 'y\uDE80\uD83Dx'

[...str].reverse().join('')
// 'y\uD83D\uDE80x'

var nodeList = document.querySelectorAll('div');
var array = [...nodeList];

let arrayLike = {
  '0': 'a',
  '1': 'b',
  '2': 'c',
  length: 3
};

// TypeError: Cannot spread non-iterable object.
let arr = [...arrayLike];

let map = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);

let arr = [...map.keys()]; // [1, 2, 3]

var go = function*(){
  yield 1;
  yield 2;
  yield 3;
};

[...go()] // [1, 2, 3]

var obj = {a: 1, b: 2};
let arr = [...obj]; // TypeError: Cannot spread non-iterable object

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

// NodeList对象
let ps = document.querySelectorAll('p');
Array.from(ps).forEach(function (p) {
  console.log(p);
});

// arguments对象
function foo() {
  var args = Array.from(arguments);
  // ...
}

Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']

let namesSet = new Set(['a', 'b'])
Array.from(namesSet) // ['a', 'b']

Array.from([1, 2, 3])
// [1, 2, 3]

// arguments对象
function foo() {
  var args = [...arguments];
}

// NodeList对象
[...document.querySelectorAll('div')]

Array.from({ length: 3 });
// [ undefined, undefined, undefined ]

const toArray = (() =>
  Array.from ? Array.from : obj => [].slice.call(obj)
)();

Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);

Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]

let spans = document.querySelectorAll('span.name');

// map()
let names1 = Array.prototype.map.call(spans, s => s.textContent);

// Array.from()
let names2 = Array.from(spans, s => s.textContent)

Array.from([1, , 2, , 3], (n) => n || 0)
// [1, 0, 2, 0, 3]

function typesOf () {
  return Array.from(arguments, value => typeof value)
}
typesOf(null, [], NaN)
// ['object', 'object', 'number']

Array.from({ length: 2 }, () => 'jack')
// ['jack', 'jack']

function countSymbols(string) {
  return Array.from(string).length;
}

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]

Array.of() // []
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]

function ArrayOf(){
  return [].slice.call(arguments);
}

Array.prototype.copyWithin(target, start = 0, end = this.length)

[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

// 将3号位复制到0号位
[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]

// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]

// 将3号位复制到0号位
[].copyWithin.call({length: 5, 3: 1}, 0, 3)
// {0: 1, 3: 1, length: 5}

// 将2号位到数组结束，复制到0号位
var i32a = new Int32Array([1, 2, 3, 4, 5]);
i32a.copyWithin(0, 2);
// Int32Array [3, 4, 5, 4, 5]

// 对于没有部署 TypedArray 的 copyWithin 方法的平台
// 需要采用下面的写法
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]

[1, 4, -5, 10].find((n) => n < 0)
// -5

[1, 5, 10, 15].find(function(value, index, arr) {
  return value > 9;
}) // 10

[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) // 2

[NaN].indexOf(NaN)
// -1

[NaN].findIndex(y => Object.is(NaN, y))
// 0

['a', 'b', 'c'].fill(7)
// [7, 7, 7]

new Array(3).fill(7)
// [7, 7, 7]

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

for (let index of ['a', 'b'].keys()) {
  console.log(index);
}
// 0
// 1

for (let elem of ['a', 'b'].values()) {
  console.log(elem);
}
// 'a'
// 'b'

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']

[1, 2, 3].includes(2)     // true
[1, 2, 3].includes(4)     // false
[1, 2, NaN].includes(NaN) // true

[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true

if (arr.indexOf(el) !== -1) {
  // ...
}

[NaN].indexOf(NaN)
// -1

[NaN].includes(NaN)
// true

const contains = (() =>
  Array.prototype.includes
    ? (arr, value) => arr.includes(value)
    : (arr, value) => arr.some(el => el === value)
)();
contains(['foo', 'bar'], 'baz'); // => false

Array(3) // [, , ,]

0 in [undefined, undefined, undefined] // true
0 in [, , ,] // false

// forEach方法
[,'a'].forEach((x,i) => console.log(i)); // 1

// filter方法
['a',,'b'].filter(x => true) // ['a','b']

// every方法
[,'a'].every(x => x==='a') // true

// some方法
[,'a'].some(x => x !== 'a') // false

// map方法
[,'a'].map(x => 1) // [,1]

// join方法
[,'a',undefined,null].join('#') // "#a##"

// toString方法
[,'a',undefined,null].toString() // ",a,,"

Array.from(['a',,'b'])
// [ "a", undefined, "b" ]

[...['a',,'b']]
// [ "a", undefined, "b" ]

[,'a','b',,].copyWithin(2,0) // [,"a",,"a"]

new Array(3).fill('a') // ["a","a","a"]

let arr = [, ,];
for (let i of arr) {
  console.log(1);
}
// 1
// 1

// entries()
[...[,'a'].entries()] // [[0,undefined], [1,"a"]]

// keys()
[...[,'a'].keys()] // [0,1]

// values()
[...[,'a'].values()] // [undefined,"a"]

// find()
[,'a'].find(x => true) // undefined

// findIndex()
[,'a'].findIndex(x => true) // 0

// 返回数据 res or res.data 兼容性处理 start ==================
let _res = (res && res.data) ? res.data : res;
// 返回数据 res or res.data 兼容性处理 end ==================

// Notice: 
`_this.slideProgress` ji

/**
 * 粉色255,72,145 过渡到 灰色51,51,51
 */
// 放大平方(2次方)倍的变化速率
r = Math.floor((255 - 51) * (1 - Math.pow(Math.abs(_this.slideProgress), 2)) + 51)
g = Math.floor((72 - 51) * (1 - Math.pow(Math.abs(_this.slideProgress), 2)) + 51)
b = Math.floor((145 - 51) * (1 - Math.pow(Math.abs(_this.slideProgress), 2)) + 51)

// 正常变化速率
r = Math.floor((255 - 51) * (1- Math.abs(_this.slideProgress)) + 51)
g = Math.floor((72 - 51) * (1 - Math.abs(_this.slideProgress)) + 51)
b = Math.floor((145 - 51) * (1 - Math.abs(_this.slideProgress)) + 51)

// bad
const arr = [1, 2, 3];
for (let i = 0; i < arr.length; i++) {
    // do something
}

// good 
for (let i = 0, len = arr.length; i < len; i++) {
    // do something
}

// bad way
const list = [1, 2, 3];
const proxyList = new Proxy(list, {
  get(target, key) {
     if (key === 'length') {
       console.log('Get Length');
       return target.length;
     } else {
		return target[key];
     }
  }
});

for (let i = 0; i < proxyList.length; i++) {
  console.log(proxyList[i]);
}

// 输出：
// Get Length
// 1
// Get Length
// 2
// Get Length
// 3
// Get Length

// god way
const list = [1, 2, 3];
const proxyList = new Proxy(list, {
  get(target, key) {
     if (key === 'length') {
       console.log('Get Length');
       return target.length;
     } else {
		return target[key];
     }
  }
});
for (let i = 0, len = proxyList.length; i < len; i++) {
  console.log(proxyList[i]);
}

// 输出：
// Get Length
// 1
// 2
// 3

// bad
export default {
  data: {
    foo: 'bar'
  }
}

// good
export default {
  data () {
    return {
      foo: 'bar'
    }
  }
}

// bad
export default {
  props: {
    'greeting-text': String
  }
};

// good
export default {
  props: {
    greetingText: String
  }
}

export default {
  name: '',

  mixins: [],

  components: {},

  props: {},

  data() {},

  computed: {},

  watch: {},

  created() {},

  mounted() {},

  destroyed() {},

  methods: {}
};

export default {
  computed: {
    formattedValue() {
      // ...
    },

    styles() {
      // ...
    }
  },

  methods: {
    onInput() {
      // ...
    },

    onChange() {
      // ...
    }
  }
};

:style="{backgroundImage:'url(' + item.videopic + ')'}" 或者
:style="{ backgroundImage: `url(${item.videopic})` }"

list: [
 require('@/assets/img/index/banner.png')
]

const Util = {
      /**
       * 是否大于指定的随机数.
       * 
       * @param {parNum} 百分比字符串
       * @return true/false 中: true, 未中: false
       */
      isPass(perNum) {
        // 获取小数
        const _decimals = 1 - parseInt(`${perNum}`) / 100;
        const _randomNum = Math.random();

        return (_randomNum >= _decimals) ? true : false;
      }
 }

// 使用
Util.isPass('50%') // 判断50%的概率是否中