let arr=[1,2,3]
console.log(arr instanceof Array)

let arr=[1,2,3]
console.log(arr.constructor===Array)

let arr=[1,2,3]
console.log(Array.isArray(arr))

let arr=[1,2,3]
console.log(Object.prototype.toString.call(arr)==='[object Array]')

let arr=[1,2,3]
console.log(arr.__proto__===Array.prototype)

let arr=[1,2,3]
console.log(Object.getPrototypeOf(arr)===Array.prototype);//true

let arr=[1,2,3]
console.log(Array.prototype.isPrototypeOf(arr))

props:{
    //字符串形式
    name:String//接收的类型参数
    //对象形式
    age:{
        type:Number,//接收的类型为数值
        default:18;//默认值为18
        require:true;//age属性必须传递
    }
}

<Children name='jack' age=18/>

this.$emit('add',good)

<Children @add="cartAdd($event)"

<Children ref='foo'/>
    this.$refs.foo//获取子组件实例，通过子组件实例我们可以拿到对应数据

class Bus{
    constructor(){
        this.events={};
    }
    on(event,fn){
        this.events[event]=this.events[event]||[];
        this.events[event].push(fn)
        
    }
    emit(event,data){
        if(this.events[event]){
            this.events[event].forEach(cb=>{
                cb(data)
            })
        }
        
    }
    off(event,fn){
        if(this.events[event]){
            for(let i=0;i<this.events[event].length;i++){
                if(this.events[event][i]===fn){
                    this.events[event].splice(i,1);
                    break;
                }
            }
        }
    }
}

//main.js
import {createApp} from 'vue'
import App from './App.vue'
//引入事件类
import EventBus from 'lib/Bus.js'
const $bus=new Bus()
//挂载
//1使用provide
app.provide('$bus',$bus);
//2 挂载到this上
app.config.globalProperties.$bus=$bus

export default{
    created(){
        this.$bus.emit('ButtonCreated')
    }
}

import {inject} from 'vue'
export default {
    setup(){
        const $bus=inject('$bus')
        $bus.emit('ButtonSetup')
    }
}

<C v-bind="$attrs" v-on="$listeners"></C>

<template>
<div>
  <h2>组件A 数据项:{{myData}}</h2>
  <B @changeMyData="changeMyData" :myData="myData"></B>
</div>
</template>
<script>
import B from "./B";
export default {
  data() {
    return {
      myData: "100"
    };
  },
  components: { B },
  methods: {
    changeMyData(val) {
      this.myData = val;
    }
  }
};
</script>

<template>
  <div>
    <h3>组件B</h3>
    <C v-bind="$attrs" v-on="$listeners"></C>
  </div>
</template>
<script>
import C from "./C";
export default {
  components: { C },
};
</script>

<template>
  <div>
    <h5>组件C</h5>
    <input v-model="myc" @input="hInput" />
  </div>
</template>
<script>
export default {
  props: { myData: { String } },
  created() {
    this.myc = this.myData;  // 在组件A中传递过来的属性
    console.info(this.$attrs, this.$listeners);
  },
  methods: {
    hInput() {
      this.$emit("changeMyData", this.myc); // // 在组件A中传递过来的事件
    }
  }
};
</script>

provide(){
	return {
        foo:'foo'

	}
}

inject:['foo'];//获取到祖先组件传递过来的值

function Component(){
    
}
Component.prototype.data={
    count:0
}

const componentA=new Component()
const componentB=new Component();
console.log(componentB.data.count);//0
componentA.data.count=1;
console.log(componentB.data.count)//1

function Component(){
	this.data = this.data()
}
Component.prototype.data = function (){
    return {
   		count : 0
    }
}

console.log(componentB.data.count)  // 0
componentA.data.count = 1
console.log(componentB.data.count)  // 0

function initData (vm: Component) {
  let data = vm.$options.data
  data = vm._data = typeof data === 'function'
    ? getData(data, vm)
    : data || {}
    ...
}

Vue.prototype._init = function (options?: Object) {
    ...
    // merge options
    if (options && options._isComponent) {
      // optimize internal component instantiation
      // since dynamic options merging is pretty slow, and none of the
      // internal component options needs special treatment.
      initInternalComponent(vm, options)
    } else {
      vm.$options = mergeOptions(
        resolveConstructorOptions(vm.constructor),
        options || {},
        vm
      )
    }
    ...
  }

strats.data = function (
  parentVal: any,
  childVal: any,
  vm?: Component
): ?Function {
  if (!vm) {
    if (childVal && typeof childVal !== "function") {
      process.env.NODE_ENV !== "production" &&
        warn(
          'The "data" option should be a function ' +
            "that returns a per-instance value in component " +
            "definitions.",
          vm
        );

      return parentVal;
    }
    return mergeDataOrFn(parentVal, childVal);
  }
  return mergeDataOrFn(parentVal, childVal, vm);
};

const curry=(fn,...args)=>{
    return args.length<fn.length//函数参数个数可以通过函数.length属性访问，
    ?(..._args)=>curry(fn,...args,..._args)//传入参数小于原始函数fn参数的个数时，继续对当前函数进行柯里化，返回一个接受所有参数（当前参数和剩余参数）的函数
    :fn(...args)//否则直接执行函数
}
function add1(a,b,c,d){
    return a+b+c+d;
}
var add=curry(add1)
console.log(add(1,2,3,4))//10
console.log(add(1)(2)(3)(4));//10
console.log(add(1,2)(3,4));//10

// 正常正则验证字符串 reg.test(txt)

// 函数封装后
function check(reg, txt) {
    return reg.test(txt)
}

check(/\d+/g, 'test')       //false
check(/[a-z]+/g, 'test')    //true

// Currying后
function curryingCheck(reg) {
    return function(txt) {
        return reg.test(txt)
    }
}

var hasNumber = curryingCheck(/\d+/g)
var hasLetter = curryingCheck(/[a-z]+/g)

hasNumber('test1')      // true
hasNumber('testtest')   // false
hasLetter('21212')      // false

var addEvent=function(el,type,fn,capture){
    if(window.addEventListener){
        el.addEventListener(type,function(e){
            fn.call(el,e);
        },capture);
    }
    else if(window.attachEvent){
        el.attachEvent("on"+type,function(e){
            fn.call(el,e);
        })
    }
}

var addEvent=(function(){
    if(window.addEventListener){
        el.addEventListener(type,function(e){
            fn.call(el,e);
        },capture);
    }
    else if(window.attachEvent){
        el.attachEvent("on"+type,function(e){
            fn.call(el,e);
        })
    }
})();

Function.prototype.bind=function(context){
    var self=this;
    var args=Array.prototype.slice.call(arguments,1);
    return funtion(){
        return self.apply(context,args);
    }
}

is=function(x,y){
    if(x===y){//如果x===y并且+0和-0=>+0!==0false -0!==0false 1/+0===1/-0false返回false
        return x!==0||y!==0||1/x===1/y
    }else{
        //解决NaN===NaN为false,NaN!==NaNtrue NaN!==NaN true 返回true
        return x!==x&&y!==y;
    }
}
console.log(is(0,0))//true
console.log(is(+0,-0))//false
console.log(is(NaN,NaN))//true

Object.defineProperty(Object,'assign',{
    value:
    function (target,...args){
        if(target===null)return new TypeError("Can't convert null or undefined to object")
        //目标对象统一为引用数据类型
        const to=Object(target);
        for(let i=0;i<args.length;i++){
            //每一个源对象
            const nextSource=args[i];
            if(nextSource!==null){
                //使用for...in 和hasOwnProperty双重判断，确保只拿到本身的属性，方法（不包含继承的)
                for(const nextKey in nextSource){
                    if(Object.prototype.hasOwnProperty.call(nextSource,nextKey)){
                        to[nextKey]=nextSource[nextKey];
                    }
                }
            }
        }
        return to;
    },
    //不可枚举
    enumerable:false,
    writable:true,
    configurable:true  
})

Function.prototype._call=function(context=window,...args){//如果没有传入对象，则会默认this指向window
    if(typeOf context !=='function'){
        throw Error('Type Error')
    }
    const fn=Symbol('thisObj');
    context[fn]=this;//给目标对象增加一个属性，并且将this赋给该属性
    let res=context[fn](ars);//通过临时属性调用该函数并返回结果
    delete context[fn];//删除该临时属性
    return res;
    
}