浅谈react-router@4.0 使用方法和源码分析

import React, { Component } from 'react';
import { Switch, Route } from 'react-router-dom';

const router = [{
 path: '/',
 exact: true,
 component:importPath({
 loader: () => import(/* webpackChunkName:"home" */ "pages/home/index.js"),
 }),
 },]
const Routers = () => (
 <main>
 <Switch>
 {
 router.map(({component,path,exact},index)=>{
 return <Route exact={exact} path={path} component={component} key={path} />
 })
 }
 </Switch>
 </main>
);

export default Routers;

import {HashRouter} from 'react-router-dom';
import React from 'react';
import ReactDOM from 'react-dom';
import Routers from './router';

ReactDOM.render (
 <HashRouter>
 <Routers />
 </HashRouter>,
 document.getElementById ('App')
);

import { withRouter } from "react-router-dom";

@withRouter
class Home extends React.Component<PropsType, stateType> {
 constructor(props: PropsType) {
 super(props);
 this.state = {};
 }
 goPath=()=>{
 this.props.history.push('/home')
 }
 render() {
 return (
 <div onClick={this.goPath}>home</div>
 );
 }
export default Home;

function _possibleConstructorReturn(self, call) {
 if (!self) {
 throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 }
 if(call&&(typeof call === "object" || typeof call === "function") ){
 return call
 }else {
 return self
 }
}
var Switch = function (_React$Component) {
 function Switch() {
 //使用传递进来的组件覆盖本身
 return _possibleConstructorReturn(this, _React$Component.apply(this, arguments)); 
 }
 Switch.prototype.render = function render() {
 var route = this.context.router.route;
 var children = this.props.children;
 var location = this.props.location || route.location;
 var match = void 0,child = void 0;
 
 //检查element是否是react组件，初始match为null,
 React.Children.forEach(children, function (element) {
 //如果match符合，forEach不会进入该if
 if (match == null && React.isValidElement(element)) { 
 var _element$props = element.props,
 pathProp = _element$props.path,
 exact = _element$props.exact,
 strict = _element$props.strict,
 sensitive = _element$props.sensitive,
 from = _element$props.from;
 var path = pathProp || from;
 child = element; 
 //检查当前配置是否符合,
 match = matchPath(location.pathname, { path: path, exact: exact, strict: strict, sensitive: sensitive }, route.match); 
 }
 });
 //如果有匹配元素，则返回克隆child
 return match ? React.cloneElement(child, { location: location, computedMatch: match }) : null;
 };

 return Switch;
}(React.Component);

var Route = function (_React$Component) {
 function Route() {
 var _temp, _this, _ret;
 //获取参数
 for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
 args[_key] = arguments[_key];
 }
 //修改this
 return _ret = (
 _temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), 
 //检查当前元素是否符合match
 _this.state = {match: _this.computeMatch(_this.props,_this.context.router)},_temp),
 //这里是真正return
 _possibleConstructorReturn(_this, _ret); 
 }
 // 设置content
 Route.prototype.getChildContext = function getChildContext() {
 return {
 router: _extends({}, this.context.router, {
 route: {
 location: this.props.location || this.context.router.route.location,
 match: this.state.match
 }
 })
 };
 };
 // 根据参数检查当前元素是否符合匹配规则
 Route.prototype.computeMatch = function computeMatch(_ref, router) {
 var computedMatch = _ref.computedMatch,
 location = _ref.location,
 path = _ref.path,
 strict = _ref.strict,
 exact = _ref.exact,
 sensitive = _ref.sensitive;

 if (computedMatch) return computedMatch;

 var route = router.route;

 var pathname = (location || route.location).pathname;

 return matchPath(pathname, { path: path, strict: strict, exact: exact, sensitive: sensitive }, route.match);
 };
 // 设置match
 Route.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps, nextContext) {
 this.setState({
 match: this.computeMatch(nextProps, nextContext.router)
 });
 };

 Route.prototype.render = function render() {
 var match = this.state.match;
 var _props = this.props,
 children = _props.children,
 component = _props.component,
 render = _props.render;
 var _context$router = this.context.router,
 history = _context$router.history,
 route = _context$router.route,
 staticContext = _context$router.staticContext;

 var location = this.props.location || route.location;
 var props = { match: match, location: location, history: history, staticContext: staticContext };
 //检查route 是否有component组
 if (component) return match ? React.createElement(component, props) : null; 
 // 检查是否包含render 组件
 if (render) return match ? render(props) : null;
 // withRouter 使用的方式
 if (typeof children === "function") return children(props);

 if (children && !isEmptyChildren(children)) return React.Children.only(children);

 return null;
 };

 return Route;
}(React.Component);

import Router from './Router'
import {createHistory} from 'history'
var HashRouter = function (_React$Component) {
 function HashRouter() {
 var _temp, _this, _ret;
 //参数转换为数组
 for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { 
 args[_key] = arguments[_key];
 }
 return _ret = (
 _temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this),
 _this.history = createHistory(_this.props), _temp), //创建history
 _possibleConstructorReturn(_this, _ret); //真正返回的东西 返回this
 }
 HashRouter.prototype.render = function render() {
 // 返回一个Router,并且把history，children传递给Router
 return React.createElement(Router, { history: this.history, children: this.props.children });
 };
 return HashRouter;
}(React.Component);

var Router = function (_React$Component) {
 function Router() {
 var _temp, _this, _ret;
 //获取参数，和其他组件一样
 for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
 args[_key] = arguments[_key];
 }
 return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
 match: _this.computeMatch(_this.props.history.location.pathname) //返回路由对象
 }, _temp), _possibleConstructorReturn(_this, _ret); //返回this
 }
 // 返回context
 Router.prototype.getChildContext = function getChildContext() {
 return {
 router: _extends({}, this.context.router, {
 history: this.props.history,
 route: {
 location: this.props.history.location,
 match: this.state.match
 }
 })
 };
 };
 
 Router.prototype.computeMatch = function computeMatch(pathname) {
 return {
 path: "/",
 url: "/",
 params: {},
 isExact: pathname === "/"
 };
 };

 Router.prototype.componentWillMount = function componentWillMount() {
 var _this2 = this;

 var _props = this.props,
 children = _props.children,
 history = _props.history;

 // 启动监听 当hash 改变是做一次检查，并返回unlisten 取消事件
 this.unlisten = history.listen(function () {
 _this2.setState({
 match: _this2.computeMatch(history.location.pathname)
 });
 });
 };
 //销毁前取消监听
 Router.prototype.componentWillUnmount = function componentWillUnmount() {
 this.unlisten();
 };
 // children是HashRouter 传递进来的
 Router.prototype.render = function render() {
 var children = this.props.children;
 return children ? React.Children.only(children) : null;
 };

 return Router;
}(React.Component);

var withRouter = function withRouter(Component) {
 var C = function C(props) {
 //获取props
 var wrappedComponentRef = props.wrappedComponentRef,
 remainingProps = _objectWithoutProperties(props, ["wrappedComponentRef"]);
 // Route 组件 children方式
 return React.createElement(Route, {
 children: function children(routeComponentProps) {
 // 这里使用的是route 组件 children(props)
 //routeComponentProps 实际等于 { match: match, location: location, history: history, staticContext: staticContext };
 return React.createElement(Component, _extends({}, remainingProps, routeComponentProps, {
 ref: wrappedComponentRef
 }));
 }
 });
 };

 C.displayName = "withRouter(" + (Component.displayName || Component.name) + ")";
 C.WrappedComponent = Component;
 // 该类似于object.assign(C,Component),得到的结果是C
 return hoistStatics(C, Component);
};