setCORS() {
    return (req, res, next) => {
      res.header("Access-Control-Allow-Origin", req.headers.origin);
      res.header("Access-Control-Allow-Credentials", true);
      res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
      res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
      // res.header("X-Powered-By", '3.2.1');
      if (req.method === 'OPTIONS') {
        return res.send('support CORS')
      }
      next();
    }
 },

import React from "react"
import PropTypes from "prop-types"
import {bindActionCreators} from 'redux'

class Provider extends React.Component{
  static childContextTypes={
    //设置上下的类型是对象
    store:PropTypes.object
  };
  getChildContext(){
    //获取并设置后代上下文的内容
    return {store:this.props.store}
  }
  render(){
    return this.props.children;
  }
}
let connect =(mapStateToProps,mapDispatchToProps)=>(C)=>{
  return class Proxy extends React.Component{
    static contextTypes={
      store:PropTypes.object
    };
    constructor(props,context){
      super();
      //将参数mapStateToProps 的解构赋值代理组件的状态
      this.state=mapStateToProps(context.store.getState())
    }
    componentDidMount(){
      this.unsubscribe = this.context.store.subscribe(()=>{
        this.setState(mapStateToProps(this.context.store.getState()))
      })
    }
    componentWillUnmount(){
      this.unsubscribe()
    }
    render(){
      let _disPatch;
      if(typeof mapDispatchToProps === 'function'){
        _disPatch = mapDispatchToProps(this.context.store.dispatch);
      }else {
        _disPatch = bindActionCreators(mapDispatchToProps,this.context.store.dispatch)
      }

      return <C {...this.state} {..._disPatch}/>
    }
  }
};
export {Provider,connect}

function createStore(reducer) {
  let state, listener = [], getState, dispatch, subscribe;
  dispatch = action => {
    state = reducer(state, action)
    listener.forEach(item => item())
  }
  dispatch({})
  subscribe = fn => {
    listener = [...listener, fn]
    return () => {
      listener = listener.filter(item => item !== fn)
    }
  }
  getState = () => JSON.parse(JSON.stringify(state))
  return {dispatch, getState, subscribe}
}
/**
 * combineReducers 合并reducers
 * @param reducers[Object] 接收一个对象
 * @returns {function()}
 */
function combineReducers(reducers) {

  return (state = {}, action) => {
    let obj = {}
    for (let key in reducers) {
      if(!reducers.hasOwnProperty(key)) continue;
      obj[key] = reducers[key](state[key], action)
    }
    return obj
  }
}

/**
 * bindActionCreators 合并actions返回使用dispatch包装的结果
 * @param actions
 * @param dispatch
 * @returns {{}}
 */
function bindActionCreators(actions,dispatch) {
  //将actions 包装成 mapDispatchToProps返回的对象

    let obj={};
    for(let key in actions){
      if(!actions.hasOwnProperty(key)) continue;
      obj[key]=(...arg)=>{
        dispatch(actions[key](...arg))
      }
    }
    return obj;

}

class React {
  constructor() {
  };


  static createElement(type, options, ...arg) {
    options = options || {};
    // arg 储存的是剩下的参数集合,没有的话就是空数组

    let obj = {type, key: null, ref: null, props: {}};

    ['key', 'ref'].forEach(item => {
      if (item in options) {
        obj[item] = options[item];
        delete options[item]
      }
    });

    obj.props = {...options};
    let len = arg.length;
    switch (len) {
      case 0:
        // 没有子节点,没有children
        break;
      case 1:
        // 只有一个子节点,children 不是一个数组
        obj.props.children = arg[0];
        break;
      default:
        // 多个子节点
        obj.props.children = JSON.parse(JSON.stringify(arg))
    }

    return obj
  }
}

class ReactDOM {
  static handChild(children, newEle) {
    if (typeof children === 'object') {
      // children 是一个虚拟dom
      ReactDOM.render(children, newEle)
    } else {
      // children 是一个字符串
      newEle.appendChild(document.createTextNode(children))
    }
  }

  static render(objJSX, container, cb) {
    let {type, props} = objJSX,
      newEle = document.createElement(type);
    for (let key in props) {
      if (!props.hasOwnProperty(key)) continue;

      if (key === 'children') {
        let children = props['children'];
        if (children instanceof Array) {
          // children 是数组
          children.forEach(itemChild => {
            ReactDOM.handChild(itemChild, newEle)
          });
          continue
        }
        // 只有一个子节点
        ReactDOM.handChild();
        continue;
      }

      // class
      if (key === 'className') {
        newEle.setAttribute('class', props['className']);
        continue;
      }

      // style 把props中的style的值依次遍历,并设置给元素
      if (key === 'style') {
        for (let key in props['style']) {
          if (!props['style'].hasOwnProperty(key)) continue;
          newEle.style[key] = props['style'][key]
        }
      }

      newEle.setAttribute(key, props[key])
    }
    container.appendChild(newEle);
    cb && cb()
  }
}

React.createElement('div', undefined);
styleObj = {color: 'red'};