const CancelToken = axios.CancelToken;
const source = CancelToken.source();

axios.get('/user/12345', {
  cancelToken: source.token
}).catch(function (thrown) {
  if (axios.isCancel(thrown)) {
    console.log('Request canceled', thrown.message);
  } else {
    // handle error
  }
});

axios.post('/user/12345', {
  name: 'new name'
}, {
  cancelToken: source.token
})

// cancel the request (the message parameter is optional)
source.cancel('Operation canceled by the user.');

const CancelToken = axios.CancelToken;
let cancel;

axios.get('/user/12345', {
  cancelToken: new CancelToken(function executor(c) {
    // An executor function receives a cancel function as a parameter
    cancel = c;
  })
});

// cancel the request
cancel();

Vue.prototype.store = {
       source: {
           token: null,
           cancel: null
       }
};

//router.js

router.beforeEach((to, from, next) => {
    console.log(Vue.prototype.store.source);
    const CancelToken = axios.CancelToken;
    Vue.prototype.store.source.cancel && Vue.prototype.store.source.cancel();
    Vue.prototype.store.source = CancelToken.source();
    next();
});

const http = axios.create()
http.interceptors.request.use(config => {
    config.cancelToken = store.source.token
    return config
}, err => {
    return Promise.reject(err)
})

let map = new Map();
map.set(1,'num');
map.set('1','str');
map.set(true,'bool');
// Object 会将所有的键转化为字符串
map.get(1); // 'num'
map.get('1'); // 'str'

let map = new Map();
let obj = {a:1};
map.set(obj,1);
map.get(obj); // 1

let map = new Map([['1','str'],[1,'num']]);

let map = new Map(Object.entries({
	name:'Jhon',
  age:12
}));

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);
// 迭代键（vegetables）
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}
// 迭代值（amounts）
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}
// 迭代键值对 [key, value]
for (let entry of recipeMap) { // 和 recipeMap.entries() 一样
  alert(entry); // cucumber,500（等等）
}

recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 等等
});

let set = new Set();
let john = { name: "John" };
let pete = { name: "Pete" };
let mary = { name: "Mary" };
// 访客，一些用户来了多次
set.add(john);
set.add(pete);
set.add(mary);
set.add(john);
set.add(mary);
// set 保证了值的唯一
alert( set.size ); // 3
for (let user of set) {
  alert(user.name); // John（然后是 Pete 和 Mary）
}

let set = new Set(["oranges", "apples", "bananas"]);
for (let value of set) alert(value);
// 和 forEach 相同：
set.forEach((value, valueAgain, set) => {
  alert(value);
});

let newArr = Array.from(new Set(oldArr));

let xml = new XMlHttoRequest()
xml.open('GET',url)
xml.onload = function(){}
xml.onerror = function(){}
xml.send()

let xml = new XMlHttoRequest()
xml.open('GET',url)
xml.send()
xml.onload = function(){}
xml.onerror = function(){}

module.exports = {
    // 修改 src 为 examples
    pages: {
        index: {
            entry: 'examples/main.js',
            template: 'public/index.html',
            filename: 'index.html'
        }
    },
    css: {
        extract: false,
    },
    // 扩展 webpack 配置，使 packages 加入编译
    chainWebpack: config => {
        config.module
            .rule('js')
            .include
            .add('/packages')
            .end()
            .use('babel')
            .loader('babel-loader')
            .tap(options => {
                // 修改它的选项...
                return options;
            });
    }
};

// 导入组件
import datePicker from './datepicker';

// 存储组件列表
const components = [
    datePicker
];

// 定义 install 方法，接收 Vue 作为参数。如果使用 use 注册插件，则所有的组件都将被注册
const install = function (Vue) {
    // 判断是否安装
    if (install.installed) return;
    // 遍历注册全局组件
    components.map(component => Vue.component(component.name, component));
};

// 判断是否是直接引入文件
if (typeof window !== 'undefined' && window.Vue) {
    install(window.Vue);
}

export default {
    // 导出的对象必须具有 install，才能被 Vue.use() 方法安装
    install,
    // 以下是具体的组件列表
    datePicker
};

import datepicker from './src/date-picker';

// 为组件提供 install 安装方法，供按需引入
datepicker.install = function (Vue) {
    Vue.component(datepicker.name, datepicker); //datepiacker.name 下面解释
};

// 默认导出组件
export default datepicker;

"lib": "vue-cli-service build --target lib --name vue-simple-datepicker --dest lib packages/index.js",

"main": "lib/vue-simple-datepicker.umd.min.js",

//注意在 deviceready 后使用,写在methods中
//点击返回按键
  onBackKeyDown() {
       this.$toast('再点击一次退出应用');
       document.removeEventListener("backbutton", this.onBackKeyDown, false); // 注销返回键
       document.addEventListener("backbutton", this.exitApp, false);//绑定退出事件
       setInterval(() => {
             document.addEventListener("backbutton", this.onBackKeyDown, false);
             document.removeEventListener("backbutton", this.exitApp, false);
           }, 3000)
        }
//关闭APP
 exitApp() {
         navigator.app.exitApp();
        },

created() {
      document.addEventListener("backbutton", this.onBackKeyDown, false);
      this.refreshTask();
      this.refreshNotice();
  }

beforeDestroy() {
       document.removeEventListener("backbutton", this.onBackKeyDown, false); // 注销返回键
       document.removeEventListener("backbutton", this.exitApp, false);
   }

beforeRouteLeave(to, from, next) {
    document.removeEventListener("backbutton", this.onBackKeyDown, false); // 注销返回键
    document.removeEventListener("backbutton", this.exitApp, false);
    this.$indicator.close()
    next()
}

function downLoad(fileInfo) {
    Vue.$toast('正在下载，请稍等');
    new FileTransfer().download(
        encodeURI(FILES_HOST + "/" + fileInfo.fileid), //uri网络下载路径
        cordova.file.dataDirectory + fileInfo.fileid, //文件本地存储路径
        function (fileEntry) {
            preView(fileEntry, fileInfo);
        },
        function (error) {
            Vue.$toast('下载失败');
            console.log(error);
        },
        false,
        {
            headers: {'Authorization': `Bearer ${localStorage.getItem('CFA0')}`},
        }
    );
}

function preView(fileEntry, fileInfo) {
    Vue.$toast('开始预览');
    let url;
    let platform = device.platform.toLowerCase();
    if (platform === 'android') {
        url = fileEntry.toInternalURL() //安卓预览路径
    } else {
        url = fileEntry.toURL() //ios 预览路径
    }
    console.log('路径', url);
    cordova.plugins.fileOpener2.showOpenWithDialog(
        url,
        mime.lookup(fileInfo.fileType),
        {
            error: function (e) {
                Vue.$toast('预览失败');
            },
            success: function () {
                Vue.$toast('预览成功');
            }
        },
    );
}

console.log(a) //undefined

var a = 1;

console.log(a) //ReferenceError: a is not defined

let a = 1;

console.log(a) // [Function:a]
a()//我是a
function a(){console.log('我是a')}

console.log(a) //ReferenceError: a is not defined

const a = 1;

let a = 1;
let b = a;
a === b // true
b = 2;
a === 1 ; //true

let a = {};
let b = {};
let c = a ;
a === b //false
a === c //true

let a = {name:'张三',info:{age:11,sex:'男'}};
let b = a;
b.info.age = 22;
a === b //true
a.info.age === 22 //true

let a = {name:'张三',info:{age:11,sex:'男'}};
let b = a ; //展开运算符浅拷贝
a === b //false
a.name === b.name //true
a.info === b.info //true

let a = {name:'张三',info:{age:11,sex:'男'}};
let b = JSON.parse(JSON.stringify) ; //深拷贝
a === b //false
a.name === b.name //true
a.info === b.info //false
a.info.age === b.info.age//true

let res = [
    {name:'Anne', age: 23, gender:'female'},
    {name:'Lisa', age: 16, gender:'female'},
    {name:'Jay', age: 19, gender:'male'},
    {name:'Jay', age: 22, gender:'male'},
    {name:'Mark', age: 40, gender:'male'}
]

function findOneByName(res, name) {
    return res.filter(item => item.name === name) //注意:filter返回的是数组
}
console.log(findOneByName(res,'Anne')) // [ { name: 'Anne', age: 23, gender: 'female' } ]

function findSomeByName(res, name) {
    let result = []
    res.forEach(e => {
        if (e.name === name) {
            result.push(e)
        }
    });
    return result
}
console.log(findSomeByName(res, 'Jay')) 
//[ { name: 'Jay', age: 19, gender: 'male' },
//  { name: 'Jay', age: 22, gender: 'male' } ]

function findOneByNameAge(res, name, age) {
    return res.filter(item => item.name === name && item.age === age)
}
console.log(findOneByNameAge(res, 'Jay', 22));
//[ { name: 'Jay', age: 22, gender: 'male' } ]

function multiFilter(array, filters) {
    const filterKeys = Object.keys(filters)
    // filters all elements passing the criteria
    return array.filter((item) => {
        // dynamically validate all filter criteria
        return filterKeys.every(key => {
            //ignore when the filter is empty Anne
            if (!filters[key].length) return true
            return !!~filters[key].indexOf(item[key])
        })
    })
}

let filter = {
    name: ['Jay', 'Anne'],
    age: []
}
console.log(multiFilter(res, filter));

// res 里有没有 Anne ?
console.log(res.some(item => item.name === 'Anne'));//true
// res 里是不是全都是 Anne ?
console.log(res.every(item => item.name === 'Anne'));//false

let arr = [1, 2, 3]
console.log(Object.keys(arr)); // [ '0', '1', '2' ]

let obj = {
    a: '1',
    b: '2',
    c: '3'
}
console.log(Object.keys(obj));//[ 'a', 'b', 'c' ]

let newRes = Json.parse(Json.stringify(res)); 
//数据量不大的时候使用，而且必须遵循JSON格式,假如有 function 就无法拷贝

//递归深拷贝 o1:得到的新对象 , o2:原对象
let newRes = {} ; //想得到数组
let newRes = [] ; //想得到对象
function deepClone(o1, o2) {
    for (let k in o2) {
        if (typeof o2[k] === 'object') {
            o1[k] = {};
            deepClone(o1[k], o2[k]);
        } else {
            o1[k] = o2[k];
        }
    }
}
deepClone(newRes,res)

import qs from 'qs'
import assert from 'assert' //用来测试

let obj = qs.parse('a=c'); // {a:'c'}

let nullObject = qs.parse("a[hasOwnProperty]=b", { plainObjects: true }); //无原型链
var protoObject = qs.parse("a[hasOwnProperty]=b", {allowPrototypes: true});//有原型链

let obj = qs.parse("foo[bar]=baz"); //{foo:{bar:baz}}

//嵌套的深度设置
var deep = qs.parse('a[b][c][d][e][f][g][h][i]=j', { depth: 1 });
assert.deepEqual(deep, { a: { b: { '[c][d][e][f][g][h][i]': 'j' } } });
//最多只能到五层
var expected = {
    a: {
        b: {
            c: {
                d: {
                    e: {
                        f: {
                            '[g][h][i]': 'j'
                        }
                    }
                }
            }
        }
    }
};
var string = 'a[b][c][d][e][f][g][h][i]=j';
assert.deepEqual(qs.parse(string), expected);

var limited = qs.parse('a=b&c=d', { parameterLimit: 1 }); //限制为1
assert.deepEqual(limited, { a: 'b' });

var prefixed = qs.parse('?a=b&c=d', { ignoreQueryPrefix: true });
assert.deepEqual(prefixed, { a: 'b', c: 'd' });

var delimited = qs.parse('a=b;c=d', { delimiter: ';' });// delimiter可以随意设置，比如 , { |
assert.deepEqual(delimited, { a: 'b', c: 'd' });

var regexed = qs.parse('a=b;c=d,e=f', { delimiter: /[;,]/ });
assert.deepEqual(regexed, { a: 'b', c: 'd', e: 'f' });

var withDots = qs.parse('a.b=c', { allowDots: true });
assert.deepEqual(withDots, { a: { b: 'c' } });

var withArray = qs.parse('a[]=b&a[]=c');
assert.deepEqual(withArray, { a: ['b', 'c'] });

var withIndexes = qs.parse('a[1]=c&a[0]=b');
assert.deepEqual(withIndexes, { a: ['b', 'c'] });

var withIndexes = qs.parse('a[1]=c&a[15]=b');
assert.deepEqual(withIndexes, { a: ['b', 'c'] });

var withEmptyString = qs.parse('a[]=&a[]=b');
assert.deepEqual(withEmptyString, { a: ['', 'b'] });
 
var withIndexedEmptyString = qs.parse('a[0]=b&a[1]=&a[2]=c');
assert.deepEqual(withIndexedEmptyString, { a: ['b', '', 'c'] });

var withMaxIndex = qs.parse('a[100]=b');
assert.deepEqual(withMaxIndex, { a: { '100': 'b' } });

var withArrayLimit = qs.parse('a[1]=b', { arrayLimit: 0 });
assert.deepEqual(withArrayLimit, { a: { '1': 'b' } });

var noParsingArrays = qs.parse('a[]=b', { parseArrays: false });
assert.deepEqual(noParsingArrays, { a: { '0': 'b' } });

var mixedNotation = qs.parse('a[0]=b&a[b]=c');
assert.deepEqual(mixedNotation, { a: { '0': 'b', b: 'c' } });

var arraysOfObjects = qs.parse('a[][b]=c');
assert.deepEqual(arraysOfObjects, { a: [{ b: 'c' }] });

qs.stringify(object, [options]);
assert.equal(qs.stringify({ a: 'b' }), 'a=b');
assert.equal(qs.stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');

var unencoded = qs.stringify({ a: { b: 'c' } }, { encode: false });
assert.equal(unencoded, 'a[b]=c');

var encodedValues = qs.stringify(
    { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
    { encodeValuesOnly: true }
);
assert.equal(encodedValues,'a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h');

var encoded = qs.stringify({ a: { b: 'c' } }, { encoder: function (str) {
    // Passed in values `a`, `b`, `c`
    return // Return encoded string
}})

var decoded = qs.parse('x=z', { decoder: function (str) {
    // Passed in values `x`, `z`
    return // Return decoded string
}})

qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' })
// 'a[0]=b&a[1]=c'
qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' })
// 'a[]=b&a[]=c'
qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' })
// 'a=b&a=c'

qs.stringify({ a: { b: { c: 'd', e: 'f' } } });
// 'a[b][c]=d&a[b][e]=f'

qs.stringify({ a: { b: { c: 'd', e: 'f' } } }, { allowDots: true });
// 'a.b.c=d&a.b.e=f'

assert.equal(qs.stringify({ a: '' }), 'a=');
assert.equal(qs.stringify({ a: null }), 'a=');

assert.equal(qs.stringify({ a: [] }), '');
assert.equal(qs.stringify({ a: {} }), '');
assert.equal(qs.stringify({ a: [{}] }), '');
assert.equal(qs.stringify({ a: { b: []} }), '');
assert.equal(qs.stringify({ a: { b: {}} }), '');

assert.equal(qs.stringify({ a: null, b: undefined }), 'a=');

assert.equal(qs.stringify({ a: 'b', c: 'd' }, { addQueryPrefix: true }), '?a=b&c=d');

assert.equal(qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' }), 'a=b;c=d');

var date = new Date(7);
assert.equal(
    qs.stringify({ a: date }, { serializeDate: function (d) { return d.getTime(); } }),
    'a=7'
);

function alphabeticalSort(a, b) {
    return a.localeCompare(b);
}
assert.equal(qs.stringify({ a: 'c', z: 'y', b : 'f' }, { sort: alphabeticalSort }), 'a=c&b=f&z=y');

function filterFunc(prefix, value) {
    if (prefix == 'b') {
        // Return an `undefined` value to omit a property.
        return;
    }
    if (prefix == 'e[f]') {
        return value.getTime();
    }
    if (prefix == 'e[g][0]') {
        return value * 2;
    }
    return value;
}
qs.stringify({ a: 'b', c: 'd', e: { f: new Date(123), g: [2] } }, { filter: filterFunc });
// 'a=b&c=d&e[f]=123&e[g][0]=4'
qs.stringify({ a: 'b', c: 'd', e: 'f' }, { filter: ['a', 'e'] });
// 'a=b&e=f'
qs.stringify({ a: ['b', 'c', 'd'], e: 'f' }, { filter: ['a', 0, 2] });
// 'a[0]=b&a[2]=d'

var withNull = qs.stringify({ a: null, b: '' });
assert.equal(withNull, 'a=&b=');

var equalsInsensitive = qs.parse('a&b=');
assert.deepEqual(equalsInsensitive, { a: '', b: '' });

var strictNull = qs.stringify({ a: null, b: '' }, { strictNullHandling: true });
assert.equal(strictNull, 'a&b=');

var parsedStrictNull = qs.parse('a&b=', { strictNullHandling: true });
assert.deepEqual(parsedStrictNull, { a: null, b: '' });

var nullsSkipped = qs.stringify({ a: 'b', c: null}, { skipNulls: true });
assert.equal(nullsSkipped, 'a=b');