一、物料准备
1.克隆react源码， github 地址：https://github.com/facebook/react.git
2.安装gulp
3.在react源码根目录下:
$npm install
$gulp default
(建议使用node 6.0+)
gulp将文件处理在根目录下的build文件夹中，打开build查看react的源码，结构清晰，引用路径明了
二、从生成 virtual dom 开始
react 生成一个组件有多种写法：
es 5下：var Cp=React.createClass({...})
es 6下：class Cp extends React.Component{...}
下面打开./build/node_modules/react/lib 文件夹,找到React.js 可以看到如下关键代码：
var React = {
// Modern
Children: {
map: ReactChildren.map,
forEach: ReactChildren.forEach,
count: ReactChildren.count,
toArray: ReactChildren.toArray,
only: onlyChild
},
Component: ReactComponent,
PureComponent: ReactPureComponent,
createElement: createElement,
cloneElement: cloneElement,
isValidElement: ReactElement.isValidElement,
// Classic
PropTypes: ReactPropTypes,
createClass: ReactClass.createClass,
createFactory: createFactory,
createMixin: function (mixin) {
// Currently a noop. Will be used to validate and trace mixins.
return mixin;
},
// This looks DOM specific but these are actually isomorphic helpers
// since they are just generating DOM strings.
DOM: ReactDOMFactories,
version: ReactVersion,
// Deprecated hook for JSX spread, don't use this for anything.
__spread: __spread
};
由此得知：React.createClass => ReactClass.createClass
React.component => ReactComponent
1.ReactClass.createClass
下面还是在当前的目录下寻找ReactClass.js文件，查看到如下关键代码段：
var ReactClass = {
createClass: function (spec) {
var Constructor = function (props, context, updater) {
//如果不是生产环境 输出信息类警告 目前忽略
if (process.env.NODE_ENV !== 'production') {...}
// 自动绑定相关方法 目前忽略
if (this.__reactAutoBindPairs.length) {...}
//为组件绑定props context refs updater属性
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
//初始组件state为null
this.state = null;
//如果有getInitialState则执行
var initialState = this.getInitialState ? this.getInitialState() : null;
//在非生产环境下为配合mock 设置initialState为null 目前忽略
if (process.env.NODE_ENV !== 'production') {...}
//其他情况下的兼容性处理，目前忽略
...
//将初始化的state赋值给组件state
this.state = initialState;
};
//设置Constructor的原型
Constructor.prototype = new ReactClassComponent();
Constructor.prototype.constructor = Constructor;
Constructor.prototype.__reactAutoBindPairs = [];
//合并研发同学写入的createClass({中的东西})
mixSpecIntoComponent(Constructor, spec);
//如果存在getDefaultProps则执行
if (Constructor.getDefaultProps) {
Constructor.defaultProps = Constructor.getDefaultProps();
}
...省略一些无关主逻辑的操作
return Constructor;
}
};
通过上面的代码我们可以知道：
a.createClass生成一个constructor并return它,这个constructor就是我们的组件
b.这个constructor继承自ReactClassComponent
c.了解react组件声明周期的同学应该知道React组件在整个生命周期中getDefaultProps只执行一次了吧
d.研发组件的同学在createClass({中写的东西})是通过mixSpecIntoComponent方法融合进constructor中的
下面请看mixSpecIntoComponent代码
function mixSpecIntoComponent(Constructor, spec) {
if (!spec) {
//当spec不存在时 即研发同学没有写createClass中的东西
...省略警告文本
return;
}
...省略spec类型容错处理
var proto = Constructor.prototype;
var autoBindPairs = proto.__reactAutoBindPairs;
//关于mixins的相关处理 其实就是递归调用mixSpecIntoComponent
//MIXINS_KEY="mixins"
if (spec.hasOwnProperty(MIXINS_KEY)) {
RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
}
//循环遍历spec
for (var name in spec) {
...省略容错处理
var property = spec[name];
var isAlreadyDefined = proto.hasOwnProperty(name);
//覆写constructor.prototype中的方法
validateMethodOverride(isAlreadyDefined, name);
//对特定的属性名做特殊处理
if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
RESERVED_SPEC_KEYS[name](Constructor, property);
} else {
...省略特殊处理
if (shouldAutoBind) {
...省略自动绑定相关处理
} else {
if (isAlreadyDefined) {
...省略已定义容错处理
} else {
//关键点 将property赋值给Contructor
proto[name] = property;
}
}
}
}
}
通过以上代码就可以大致了解其工作原理了
而ReactClassComponent函数生成代码如下：
var ReactClassComponent = function () {};
_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
它的原型是由ReactComponent.prototype及ReactClassMixin复合而成（_assing在根目录 node_modules/fbjs目录下,为facebook工具库中封装的函数，相当于es6 的 Object.assign）
ReactClassMixin源码如下：
var ReactClassMixin = {
replaceState: function (newState, callback) {
this.updater.enqueueReplaceState(this, newState);
if (callback) {
this.updater.enqueueCallback(this, callback, 'replaceState');
}
},
isMounted: function () {
return this.updater.isMounted(this);
}
};
定义了 replaceState及 isMounted两个方法
至于ReactComponent在./ReactComponent.js文件中，prototype源码如下
ReactComponent.prototype.isReactComponent = {};
//setState方法
ReactComponent.prototype.setState = function (partialState, callback) {
...省略报警信息
this.updater.enqueueSetState(this, partialState);
if (callback) {
this.updater.enqueueCallback(this, callback, 'setState');
}
};
ReactComponent.prototype.forceUpdate = function (callback) {
this.updater.enqueueForceUpdate(this);
if (callback) {
this.updater.enqueueCallback(this, callback, 'forceUpdate');
}
};
2.ReactComponent
ReactComponent的原型请参见上面的代码，其构造函数如下
function ReactComponent(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
}
对于extends 关键字的使用，可以参看babel上对于extends的转换，以了解其运行机制
简单点说，extends转换成ES5有以下两个步骤：
1.Object.create方法去生成对象，即：Cp.prototype=Object.create(ReactComponent.prototpe,{配置对象}) 实现原型继承的目的
2.通过ReactComponent.apply(this,arguments)的方法实现构造函数的继承
实际转换加上属性的验证十分繁杂，有兴趣的同学请亲自实践
这种通过extends方式生成的组件，没有createClass中对getInitialState及getDefaultProps的显示管理
需要研发同学在constructor中进行处理，至于其背后有何机制，以后再做讨论
三、将jsx object变成 DOMComponent
在react中，组件是用jsx语法书写的，jsx语法在编译成正常js语法时，早期使用的是react官方自身的JSTransform,后来因为其功能与babel jsx编译器功能重复，所以被官方抛弃，现今使用第三方的babel作为jsx编译器。jsx语法编译不在本文范畴之内。
不过通过编码实践以及编译后文件查看我们可以得知，jsx语法的组件被编译器编译成如下格式js语句：
_react2.default.createElement(
"div",
{ className: "bookmenu" },
_react2.default.createElement(_Header2.default, { pageTitle: "xxx" }),
_react2.default.createElement(_Title2.default, { title: "xxx" })
);
这其中由于使用ES6 import的缘故，引入模块时会为模块自动添加default作为输出，所以_react2.default其实就是React对象，而在ES5下，则相对清晰：
我们用babel编译器编译jsx文件结果如下：
var HelloBox = React.createClass({
render: function () {
return React.createElement(
"div",
{ className: "someClass" },
"hello world"
);
}
});
ReactDOM.render(React.createElement(HelloBox, null), document.getElementById("app"));
由此可知一个组件的实质是React.createElement方法返回的内容，下面我们将追寻源码中的createElement的调用栈
在react源码中引用的createElement其实是 var createElement = ReactElement.createElement;
找到ReactElement文件：
//示例：React.createElement("div",{ className: "name" },"hello world");
ReactElement.createElement = function (type, config, children) {
var propName;
// 属性初始化
var props = {};
var key = null;
var ref = null;
var self = null;
var source = null;
//如果配置对象存在则验证并赋值给属性
if (config != null) {
if (hasValidRef(config)) {
ref = config.ref;
}
if (hasValidKey(config)) {
key = '' + config.key;
}
self = config.__self === undefined ? null : config.__self;
source = config.__source === undefined ? null : config.__source;
for (propName in config) {
if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
}
//获得组件的children，并缓存childArray数组中
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
if (process.env.NODE_ENV !== 'production') {
if (Object.freeze) {
Object.freeze(childArray);
}
}
props.children = childArray;
}
// 设置props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for (propName in defaultProps) {
if (props[propName] === undefined) {
props[propName] = defaultProps[propName];
}
}
}
//省略非生产环境下的配置
//返回ReactElement函数的返回值
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
};
我们追踪到实际的返回值是ReactElement的执行结果，继续：
ReactElement函数如下：
var ReactElement = function (type, key, ref, self, source, owner, props) {
var element = {
// 保存react node type
$$typeof: REACT_ELEMENT_TYPE,
// dom type
type: type,
key: key,
ref: ref,
props: props,
// 记录负责创建该元素的组件.
_owner: owner
};
//去除非生产环境的配置
//返回这个element
return element;
};
由此我们得知组件的实质是一个结构大致如下的Object
var element = {
$$typeof: REACT_ELEMENT_TYPE,
type: type,
key: key,
ref: ref,
props: props,
_owner: owner,
};
数据类型大致了解，而将组件变成浏览器可预览的dom元素需要使用ReactDOM.render方法
下面就来寻找render方法的实质
在之前提到的build文件夹下的react-dom/lib目录下可以找到ReactDOM.js一窥究竟：
var ReactDOM = {
findDOMNode: findDOMNode,
render: ReactMount.render,
unmountComponentAtNode: ReactMount.unmountComponentAtNode,
version: ReactVersion,
/* eslint-disable camelcase */
unstable_batchedUpdates: ReactUpdates.batchedUpdates,
unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
};
原来render方法是ReactMount.render方法的引用，还是在react-dom目录下，找到ReactMount.js
ReactMount关键源码如下：
var ReactMount = {
//调用顺序 3
_renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
//此步骤跳向instantiateReactComponent
var componentInstance = instantiateReactComponent(nextElement, false);
//批量更新 后面会提到
ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);
//为dom节点添加相关ID
var wrapperID = componentInstance._instance.rootID;
instancesByReactRootID[wrapperID] = componentInstance;
//返回已经成为能够被浏览器识别的dom节点
return componentInstance;
},
//调用顺序 2
_renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
//省略生产环境的适配及相关处理
var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();
if (callback) {
callback.call(component);
}
return component;
},
//调用顺序 1
//并没有做什么，直接调用ReactMount._renderSubtreeIntoContainer
render: function (nextElement, container, callback) {
return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);
},
};
在步骤3的时候又转入到instantiateReactComponent中去处理，这里是将对象转变为DOMComponent的关键所在
function instantiateReactComponent(node, shouldHaveDebugID) {
var instance;
if (node === null || node === false) {
//如果传入的对象为空，则创建空的节点
instance = ReactEmptyComponent.create(instantiateReactComponent);
} else if (typeof node === 'object') {
var element = node;
//去掉生产环境相关检测
// 大多数情况下element.type都会是字符串，因此重点查看此内容
if (typeof element.type === 'string') {
instance = ReactHostComponent.createInternalComponent(element);
} else if (isInternalComponentType(element.type)) {
//如果element.type为函数且prototype不为undefined
instance = new element.type(element);
if (!instance.getHostNode) {
instance.getHostNode = instance.getNativeNode;
}
} else {
//以上两种情况都不是
instance = new ReactCompositeComponentWrapper(element);
}
} else if (typeof node === 'string' || typeof node === 'number') {
//如果是纯文字则创建文本节点
instance = ReactHostComponent.createInstanceForText(node);
} else {
//忽略兼容性处理 大致是不进行任何操作
}
// 用于diff操作的两个属性
instance._mountIndex = 0;
instance._mountImage = null;
return instance;
}
//针对element.type既不是函数也不是字符串，则使用ReactCompositeComponent去生成组件
var ReactCompositeComponentWrapper = function (element) {
this.construct(element);
};
_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent, {
_instantiateReactComponent: instantiateReactComponent
});
//ReactCompositeComponent源码如下
var ReactCompositeComponent = {
//提供construct，以element为参数，为生成的对象附加各种属性
construct: function (element) {
this._currentElement = element;
this._rootNodeID = 0;
this._compositeType = null;
this._instance = null;
this._hostParent = null;
this._hostContainerInfo = null;
// See ReactUpdateQueue
this._updateBatchNumber = null;
this._pendingElement = null;
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
this._renderedNodeType = null;
this._renderedComponent = null;
this._context = null;
this._mountOrder = 0;
this._topLevelWrapper = null;
// See ReactUpdates and ReactUpdateQueue.
this._pendingCallbacks = null;
// ComponentWillUnmount shall only be called once
this._calledComponentWillUnmount = false;
if (process.env.NODE_ENV !== 'production') {
this._warnedAboutRefsInRender = false;
}
},
instantiateReactComponent中针对传入的element对象的不同做出不同的处理，关键核心的是调用：
ReactHostComponent.createInternalComponent
ReactHostComponent.createInstanceForText
这两个方法将会把element转化成DOMComponent对象，二者的源码如下：
var genericComponentClass=null;
var textComponentClass=null;
var ReactHostComponentInjection = {
//接收一个参数作为构造函数
injectGenericComponentClass: function (componentClass) {
genericComponentClass = componentClass;
},
//接收生成文本节点的构造函数
injectTextComponentClass: function (componentClass) {
textComponentClass = componentClass;
},
// This accepts a keyed object with classes as values. Each key represents a
// tag. That particular tag will use this class instead of the generic one.
injectComponentClasses: function (componentClasses) {
_assign(tagToComponentClass, componentClasses);
}
};
//生成dom节点
function createInternalComponent(element) {
//省略对genericComponentClass在特殊情况下的验证
//返回由genericComponentClass构造的节点
return new genericComponentClass(element);
}
//生成文本节点
function createInstanceForText(text) {
return new textComponentClass(text);
}
//检测是否为文本节点
function isTextComponent(component) {
return component instanceof textComponentClass;
}
看到这里整个逻辑似乎是断掉了，两个构造函数都是null,那么它们是如何生成React DOMComponent节点的呢
这还要从ReactDOM.js说起
var ReactDefaultInjection = require('./ReactDefaultInjection');
//执行inject
ReactDefaultInjection.inject();
var ReactDOM = {...};
在ReactDOM文件的开始位置引入了ReactDefaultInjection模块，并执行了它的inject方法
var ReactDOMComponentTree = require('./ReactDOMComponentTree');
var ReactDOMTextComponent = require('./ReactDOMTextComponent');
var ReactInjection = require('./ReactInjection');
function inject() {
.....
ReactInjection.HostComponent.injectGenericComponentClass(ReactDOMComponent);
ReactInjection.HostComponent.injectTextComponentClass(ReactDOMTextComponent);
.....
}
//ReactInjection模块简版代码如下：
var ReactHostComponent = require('./ReactHostComponent');
var ReactInjection = {
....
HostComponent: ReactHostComponent.injection
....
};
//ReactHostComponent.injection如下
var ReactHostComponentInjection = {
injectGenericComponentClass: function (componentClass) {
genericComponentClass = componentClass;
},
injectTextComponentClass: function (componentClass) {
textComponentClass = componentClass;
},
injectComponentClasses: function (componentClasses) {
_assign(tagToComponentClass, componentClasses);
}
};
var ReactHostComponent = {
createInternalComponent: createInternalComponent,
createInstanceForText: createInstanceForText,
isTextComponent: isTextComponent,
injection: ReactHostComponentInjection
};
现在我们通过上面的代码分析，node节点构造函数及text节点构造函数是由ReactDOMComponent、ReactDOMTextComponent这两个构造函数构造的
ReactDOMComponent源码如下：
function ReactDOMComponent(element) {
var tag = element.type;
validateDangerousTag(tag);
this._currentElement = element;
this._tag = tag.toLowerCase();
this._namespaceURI = null;
this._renderedChildren = null;
this._previousStyle = null;
this._previousStyleCopy = null;
this._hostNode = null;
this._hostParent = null;
this._rootNodeID = 0;
this._domID = 0;
this._hostContainerInfo = null;
this._wrapperState = null;
this._topLevelWrapper = null;
this._flags = 0;
if (process.env.NODE_ENV !== 'production') {
this._ancestorInfo = null;
setAndValidateContentChildDev.call(this, null);
}
}
ReactDOMComponent.displayName = 'ReactDOMComponent';
ReactDOMComponent.Mixin = {
....
};
_assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild);
ReactDomComponent的构造函数非常简单，同时原型为 ReactDOMComponent.Mixin 和 ReactMultiChild的复合产物
ReactDOMTextComponent的源码如下：
var ReactDOMTextComponent = function (text) {
// TODO: This is really a ReactText (ReactNode), not a ReactElement
this._currentElement = text;
this._stringText = '' + text;
// ReactDOMComponentTree uses these:
this._hostNode = null;
this._hostParent = null;
// Properties
this._domID = 0;
this._mountIndex = 0;
this._closingComment = null;
this._commentNodes = null;
};
_assign(ReactDOMTextComponent.prototype, {
/**
* Creates the markup for this text node. This node is not intended to have
* any features besides containing text content.
*
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @return {string} Markup for this text node.
* @internal
*/
mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
if (process.env.NODE_ENV !== 'production') {
var parentInfo;
if (hostParent != null) {
parentInfo = hostParent._ancestorInfo;
} else if (hostContainerInfo != null) {
parentInfo = hostContainerInfo._ancestorInfo;
}
if (parentInfo) {
// parentInfo should always be present except for the top-level
// component when server rendering
validateDOMNesting(null, this._stringText, this, parentInfo);
}
}
var domID = hostContainerInfo._idCounter++;
var openingValue = ' react-text: ' + domID + ' ';
var closingValue = ' /react-text ';
this._domID = domID;
this._hostParent = hostParent;
if (transaction.useCreateElement) {
var ownerDocument = hostContainerInfo._ownerDocument;
var openingComment = ownerDocument.createComment(openingValue);
var closingComment = ownerDocument.createComment(closingValue);
var lazyTree = DOMLazyTree(ownerDocument.createDocumentFragment());
DOMLazyTree.queueChild(lazyTree, DOMLazyTree(openingComment));
if (this._stringText) {
DOMLazyTree.queueChild(lazyTree, DOMLazyTree(ownerDocument.createTextNode(this._stringText)));
}
DOMLazyTree.queueChild(lazyTree, DOMLazyTree(closingComment));
ReactDOMComponentTree.precacheNode(this, openingComment);
this._closingComment = closingComment;
return lazyTree;
} else {
var escapedText = escapeTextContentForBrowser(this._stringText);
if (transaction.renderToStaticMarkup) {
// Normally we'd wrap this between comment nodes for the reasons stated
// above, but since this is a situation where React won't take over
// (static pages), we can simply return the text as it is.
return escapedText;
}
return '<!--' + openingValue + '-->' + escapedText + '<!--' + closingValue + '-->';
}
},
/**
* Updates this component by updating the text content.
*
* @param {ReactText} nextText The next text content
* @param {ReactReconcileTransaction} transaction
* @internal
*/
receiveComponent: function (nextText, transaction) {
if (nextText !== this._currentElement) {
this._currentElement = nextText;
var nextStringText = '' + nextText;
if (nextStringText !== this._stringText) {
// TODO: Save this as pending props and use performUpdateIfNecessary
// and/or updateComponent to do the actual update for consistency with
// other component types?
this._stringText = nextStringText;
var commentNodes = this.getHostNode();
DOMChildrenOperations.replaceDelimitedText(commentNodes[0], commentNodes[1], nextStringText);
}
}
},
getHostNode: function () {
var hostNode = this._commentNodes;
if (hostNode) {
return hostNode;
}
if (!this._closingComment) {
var openingComment = ReactDOMComponentTree.getNodeFromInstance(this);
var node = openingComment.nextSibling;
while (true) {
!(node != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing closing comment for text component %s', this._domID) : _prodInvariant('67', this._domID) : void 0;
if (node.nodeType === 8 && node.nodeValue === ' /react-text ') {
this._closingComment = node;
break;
}
node = node.nextSibling;
}
}
hostNode = [this._hostNode, this._closingComment];
this._commentNodes = hostNode;
return hostNode;
},
unmountComponent: function () {
this._closingComment = null;
this._commentNodes = null;
ReactDOMComponentTree.uncacheNode(this);
}
});
和ReactDOMComponent一样，同样是简单的构造函数和较为复杂的prototype
至此React将一个jsx语法书写的virtual dom 转变成了能够被js解析的React DOMComponent
四、将DOMComponent变成DOM
回到之前的ReactMount.js文件，那里还有最重要的一点，在上面我们知道_renderNewRootComponent是处理virtual dom 对象的最后一环，在这个方法里：
_renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
//省略环境校验
ReactBrowserEventEmitter.ensureScrollValueMonitoring();
//此步骤为上面提到的将jsx变成DOMComponent
var componentInstance = instantiateReactComponent(nextElement, false);
//在拿到DOMComponent后，进行批量更新处理，其中参数中的container就是在ReactDOM.render中传入的 容器dom元素
ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);
var wrapperID = componentInstance._instance.rootID;
instancesByReactRootID[wrapperID] = componentInstance;
return componentInstance;
},
下面就来看看ReactUpdates.batchedUpdates方法做了什么
//其中参数b是插入组件的dom元素，参数a为DOMComponent
function batchedUpdates(callback, a, b, c, d, e) {
//组件注入检测
ensureInjected();
return batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
}
关键方法转移到了batchingStrategy.batchedUpdates方法中,和ReactDOMComponent被绑定到ReactHostComponent.createInternalComponent的方式一样，可以查找到batchingStrategy.batchedUpdates其实源于ReactDefaultBatchingStrategy.js中的batchedUpdates方法：
var ReactDefaultBatchingStrategy = {
isBatchingUpdates: false,
batchedUpdates: function (callback, a, b, c, d, e) {
var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
ReactDefaultBatchingStrategy.isBatchingUpdates = true;
if (alreadyBatchingUpdates) {
//如果已经更新过则只执行一次callback
return callback(a, b, c, d, e);
} else {
//否则跳转到transaction.perform 其中 a为DOMComponent b为被注入的DOM
return transaction.perform(callback, null, a, b, c, d, e);
}
}
};
由此我们可以追查到transaction.perform方法中去继续查看：
function ReactDefaultBatchingStrategyTransaction() {
this.reinitializeTransaction();
}
//原型复合了Transaction模块
_assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
}
});
var transaction = new ReactDefaultBatchingStrategyTransaction();
这段代码里用到了callback,该回调函数是在ReactMount.js中传入的：
function batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {
var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(!shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);
transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);
ReactUpdates.ReactReconcileTransaction.release(transaction);
}
//追溯到ReactUpdates.ReactReconcileTransaction
_assign(ReactReconcileTransaction.prototype, Transaction, Mixin);
//并为其附加上面用到的getPooled方法
PooledClass.addPoolingTo(ReactReconcileTransaction);
//addPoolingTo方法如下
var addPoolingTo = function (CopyConstructor, pooler) {
var NewKlass = CopyConstructor;
NewKlass.instancePool = [];
//默认的getPooled方法其实就是DEFAULT_POOLER
NewKlass.getPooled = pooler || DEFAULT_POOLER;
//还附加了poolSize属性 默认是10
if (!NewKlass.poolSize) {
NewKlass.poolSize = DEFAULT_POOL_SIZE;
}
NewKlass.release = standardReleaser;
return NewKlass;
};
var DEFAULT_POOL_SIZE = 10;
var DEFAULT_POOLER = oneArgumentPooler;
var oneArgumentPooler = function (copyFieldsFrom) {
//this 其实就是ReactReconcileTransaction
var Klass = this;
//管理instancePool,并通过执行this以生成ReactReconcileTransaction的实例
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, copyFieldsFrom);
return instance;
} else {
return new Klass(copyFieldsFrom);
}
};
callback也同样执行了Transaction的platform方法，只是参数不同
由此可知重头戏是当前目录下的Transaction.js模块，阅读源码前先看此流程图：
/**
* <pre>
* wrappers (injected at creation time)
* + +
* | |
* +-----------------|--------|--------------+
* | v | |
* | +---------------+ | |
* | +--| wrapper1 |---|----+ |
* | | +---------------+ v | |
* | | +-------------+ | |
* | | +----| wrapper2 |--------+ |
* | | | +-------------+ | | |
* | | | | | |
* | v v v v | wrapper
* | +---+ +---+ +---------+ +---+ +---+ | invariants
* perform(anyMethod) | | | | | | | | | | | | maintained
* +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | +---+ +---+ +---------+ +---+ +---+ |
* | initialize close |
* +-----------------------------------------+
* </pre>
/**
通过这个示意图可以推测出Transaction方法其实就是黑箱，通过perform将需要执行的方法导入，然后通过wrapper（也就是this）执行初始化方法，然后执行导入的方法，最后统一执行close方法，而wrapper最终保持不变
perform方法如下所示：
perform: function (method, scope, a, b, c, d, e, f) {
var errorThrown;
var ret;
try {
this._isInTransaction = true;
errorThrown = true;
//执行initalizeAll
this.initializeAll(0);
//执行函数
ret = method.call(scope, a, b, c, d, e, f);
errorThrown = false;
} finally {
try {
//如果执行出错则close
if (errorThrown) {
try {
this.closeAll(0);
} catch (err) {}
} else {
//总之最后都会执行close
this.closeAll(0);
}
} finally {
this._isInTransaction = false;
}
}
return ret;
}
Transaction会在后面详细介绍
通过Transaction的运作实质上是执行了callback函数，其实就是执行batchedMountComponentIntoNode函数，而其中主要又执行了
mountComponentIntoNode函数，源码如下：
function mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {
var markerName;
//省略兼容处理
var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */
);
//省略兼容处理
wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;
//调用_mountImageIntoNode实现元素的插入
ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);
}
其中返回的markup对象，经过在ReactDOMComponent中的Mixin.mountComponent方法，将DOMComponent转换为包含dom属性的对象。
Mixin.mountComponent 在生成DOMComponent时作为其构造函数的原型得来的方法
mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
//this 为DOMComponent对象
//设置其属性值
this._rootNodeID = globalIdCounter++;
this._domID = hostContainerInfo._idCounter++;
this._hostParent = hostParent;
this._hostContainerInfo = hostContainerInfo;
//提取props
var props = this._currentElement.props;
//根据标签种类设置其_wrapperState
switch (this._tag) {
case 'audio':
case 'form':
case 'iframe':
case 'img':
case 'link':
case 'object':
case 'source':
case 'video':
this._wrapperState = {
listeners: null
};
//省略transaction操作
......
assertValidProps(this, props);
//根据不同情况设置namespaceURI
var namespaceURI;
var parentTag;
if (hostParent != null) {
namespaceURI = hostParent._namespaceURI;
parentTag = hostParent._tag;
} else if (hostContainerInfo._tag) {
namespaceURI = hostContainerInfo._namespaceURI;
parentTag = hostContainerInfo._tag;
}
if (namespaceURI == null || namespaceURI === DOMNamespaces.svg && parentTag === 'foreignobject') {
namespaceURI = DOMNamespaces.html;
}
if (namespaceURI === DOMNamespaces.html) {
if (this._tag === 'svg') {
namespaceURI = DOMNamespaces.svg;
} else if (this._tag === 'math') {
namespaceURI = DOMNamespaces.mathml;
}
}
this._namespaceURI = namespaceURI;
//省略关于生产环境的处理
....
var mountImage;
//根据 useCreateElement这个标识的取值决定生成什么样的markup对象
if (transaction.useCreateElement) {
var ownerDocument = hostContainerInfo._ownerDocument;
var el;
if (namespaceURI === DOMNamespaces.html) {
if (this._tag === 'script') {
var div = ownerDocument.createElement('div');
var type = this._currentElement.type;
div.innerHTML = '<' + type + '></' + type + '>';
el = div.removeChild(div.firstChild);
} else if (props.is) {
el = ownerDocument.createElement(this._currentElement.type, props.is);
} else {
ownerDocument.createElement(this._currentElement.type);
}
} else {
el = ownerDocument.createElementNS(namespaceURI, this._currentElement.type);
}
ReactDOMComponentTree.precacheNode(this, el);
this._flags |= Flags.hasCachedChildNodes;
if (!this._hostParent) {
DOMPropertyOperations.setAttributeForRoot(el);
}
this._updateDOMProperties(null, props, transaction);
var lazyTree = DOMLazyTree(el);
this._createInitialChildren(transaction, props, context, lazyTree);
mountImage = lazyTree;
} else {
var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props);
var tagContent = this._createContentMarkup(transaction, props, context);
if (!tagContent && omittedCloseTags[this._tag]) {
mountImage = tagOpen + '/>';
} else {
mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>';
}
}
switch (this._tag) {
case 'input':
transaction.getReactMountReady().enqueue(inputPostMount, this);
if (props.autoFocus) {
transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
}
break;
case 'textarea':
transaction.getReactMountReady().enqueue(textareaPostMount, this);
if (props.autoFocus) {
transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
}
break;
case 'select':
if (props.autoFocus) {
transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
}
break;
case 'button':
if (props.autoFocus) {
transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
}
break;
case 'option':
transaction.getReactMountReady().enqueue(optionPostMount, this);
break;
}
//mountImage就是最后得到markup对象
return mountImage;
}
然后回到ReactMount中的mountComponentIntoNode函数，最后通过_mountImageIntoNode函数将markup插入到目标DOM元素中去
_mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {
if (shouldReuseMarkup) {
var rootElement = getReactRootElementInContainer(container);
if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {
ReactDOMComponentTree.precacheNode(instance, rootElement);
return;
} else {
var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
var rootMarkup = rootElement.outerHTML;
rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);
var normalizedMarkup = markup;
var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);
var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);
if (transaction.useCreateElement) {
while (container.lastChild) {
container.removeChild(container.lastChild);
}
DOMLazyTree.insertTreeBefore(container, markup, null);
} else {
setInnerHTML(container, markup);
ReactDOMComponentTree.precacheNode(instance, container.firstChild);
}
}
};
这个函数里面进行diff运算以及插入操作，将markup对象变为真正的dom元素
文章到此结束