【Redux】ReactのComponentとの連携について

Reduxを学び始めたばかりの時、ReduxのチュートリアルのReactのComponentと連携しているコードが何をやっているかわからなかったのだが、コードを書いているうちに少しずつわかってきたので、自分の考えの整理のためと同じところで躓いている人のために順序立てて説明していきたい。

まず、Fluxの処理の流れを再確認しておきたい。Fluxの概念図はググれば色々出てくるが、まずAction,Store,Componentで以下のように表してみる。

Action —–> Store —–> Component (—–> Action…)

ここで、Componentに目を向けてみるが、ComponentはStoreからstateを得て、必要に応じてActionを発行する。(実際にActionを発行するのはActionCreaterなのでComponentはそれを呼ぶということになる。)

さて、Actionは{type: 'addTodo'}のようなただのオブジェクトだが、この発行されたActionをどのようにStoreに伝えるのか。それはDispatcherの役割である。つまり、発行したActionをDispatcherに渡さないといけない。実装ではこれもComponentに書く。つまり、ComponentはActionを発行するだけでなく、その発行したActionをDispatcherに渡す処理を書く。

さて、ReduxではそのDispatcherはどこにあるのか。

実はReduxにはDispatcherが無い。その代わりStoreにdispatchというメソッドが用意されている。これはReduxがStoreを単一として設計しているからだろう。そのようなわけで、store.dispatch(action)というような処理をComponent内に書けば、

Component —–> Action —–> Store

と流すことができる。

では、どのようにComponentは単一storeを得るのか。それは親コンポーネント(ルートコンポーネント)からもらうしかない。

チュートリアルを見るとReduxとReactの連携にReactReduxというライブラリが使われている。このライブラリは必須ではない。しかし、このライブラリを使うことにっよて、親から子へstoreを渡すというような先に述べた処理を書かずに済む。一方、初めてReduxとReactの連携しているコードを見た時、何をやっているのか混乱しやすい。

さて、Reduxは単一storeなのでそのstoreはまずルートコンポーネントに渡され、子に渡されていく。チュートリアルのindex.js

render(
	<Provider store={store}>
		<App />
	</Provider>,
	document.getElementById('root')
)

とあるが、これはルートコンポーネントにstoreを渡している。このProviderというのはReactReduxのコンポーネントである。なぜこれで子のコンポーネントがstoreを得られるようになるか。それは、Reactが提供する機能には、propsのようにいちいち子のコンポーネントに明示的に値を渡す必要のないcontextというのがあり、ReactReduxも内部でそれを使っているからだ。そのため<App store={store} />と書く必要がないのである。この機能を知らないと子のコンポーネントがどのようにstoreを得ているのかわかりづらい。

では次に子のコンポーネントがstoreを得る方法、本題のReactとComponentの連携している部分を説明していく。

Reduxと連携するComponentはContainerComponentと呼ばれる。Reduxと連携と言っているが、Componentがstoreを得られるようになることを連携と言っているのである。ただ、ReactReduxを利用した場合、ReactReduxがstoreを得て、そこから必要な機能だけがComponentに渡される。

ReduxとComponentを連携しているコードを見ると、ReactRedux.connect()(Component)のような記述があるが、これを実行することにより、Componentのpropsにdispatchという関数が渡される。このdispatch関数にActionを渡すことによって

Component —–> Action —–> Store

と処理を流すことができるのである。以下、具体的なコードである。

import React from 'react'
import Redux from 'redux'
import * as actions from '../actions/index.js'

class MyComponent extends React.Component {

	handleClick() {
		//propsにdispatch関数がある
		this.props.dispatch(actions.addTodo);
	}

	render() {
		return (
			<div>
				<button
					onClick={this.handleClick.bind(this)}
				/>
			</div>
		);
	}
}

export default Redux.connect()(MyComponent);

さて、これでComponent —–> Action —–> Storeと処理を流すことができた。では、Componentはstoreからどのようにstateを得るのか。つまりStore —–> Componentについてである。

これはRedux.connectの第一引数に渡す関数で得ることができる。チュートリアルではmapStateToPropsと命名されている関数のことだ。このmapStateToPropsの第一引数にstoreのstateが渡される。mapStateToPropsの返り値はObjectで、このObjectのプロパティがそのままComponentのpropsに渡される。state全部を渡したいなら返り値にstateを指定する。

import React from 'react'
import Redux from 'redux'
import * as actions from '../actions/index.js'

class MyComponent extends React.Component {
	render() {
		//stateが全て入っている
		console.log(this.props);
		
		return (<div />);
	}
}

const mapStateToProps = (state) => {
	return state;
}

export default Redux.connect()(MyComponent);

stateの中の一部を取り出したいなら以下のように返り値を指定する。

const mapStateToProps = (state) => {
	return {
		partOfState: state.partOfState
	};
}

こうしてComponentはstateを得ることができ、dispatchも得ることができたので、

Action —–> Store —–> Component( —–> Action…)

の流れに忠実な実装にできるということが理解できたと思う。

ReduxとReactの連携ではReactReduxが何をやっているか概観を理解することが重要である。QiitaにReactReduxを使ったときと使わなかったときの比較が載っていたので参照してほしい。

ReactReduxの役割を整理

少し冗長な説明になってしまったが、もしわからなくても、実際にコードを書いているうちに理解できる範囲だと思われる。自身もまだ学んでいる途中なのでもし変な部分があれば指摘していただければ嬉しい。

【JavaScript】privateなプロパティやメソッドを定義する

JavaScriptでprivateなプロパティやメソッド(以下メンバ)を定義する方法を書いていく。

ES6未満では、privateなメンバを定義するために色々な工夫が重ねられていた。それでも全くprivateなプロパティを作るのは難しかった。しかし、ES6ではWeakMapというオブジェクトが使えるようになり、完全にprivateなメンバを定義できるようになった。

ここではまず、ES6未満でprivateなメンバを定義するための工夫の数々を紹介し、その後、WeakMapを使ったprivateなメンバを定義する方法を書く。そして、最後にES6でのClass定義の自分の書き方パターンを紹介したい。

ES6未満でのprivateなメンバの定義方法

まず、1つの工夫としてprivateなメンバには先頭に_(アンダーバー)をつけるという方法があるが、これは外部からアクセスできるためprivateでもなんでもない。

もう1つの方法としてメンバを全てconstructor内に記述するという方法もある。

function Foo() {
	this.prop = 1;
	this.method = function() {};
	var privateProp = 2;
	privateMethod = function() {};
}

これは確かにprivateなメンバを作れるが、PrototypeベースというJavaScriptの利点をなくしてしまう他、インスタンス化する度にpublicなメソッドも定義するためメモリも余計に食う。

現実的な方法としては、以下のような書き方がある。

var Foo = (function() {
	var privates = {};
	var privateId = 0;

	function Foo() {
		Object.defineProperty(this, '_id', { value: privateId++ });
		privates[this._id] = {};

		privates[this._id].prop = 1;
	}

	Foo.prototype.method = function() { return privates[this._id].prop };

	return Foo;
})();

この方法はthis._idというプロパティを作ってしまうことさえ許容できれば、かなりgoodな方法である。しかし、WeakMapを使えばこのようなプロパティを作る必要もなくなる。

ES6のWeakMapを使ってprivateなメンバを定義する

まず、WeakMapを知らない方へWeakMapとは何なのか簡単に説明するが、普通のObjectはkeyに文字列を使うのに対して、WeakMapはkeyにオブジェクトを使う。つまり、プリミティブ型でなければObjectでもArrayでもFunctionでも何でもkeyにできる

var a = {};
var b = [];
var c = () => {};

var weakmap = new WeakMap();
weakmap.set(a, 1);
weakmap.set(b, 2);
weakmap.set(c, 3);

console.log(weakmap.get(b)); // -> 2;

このようにオブジェクトをkeyとして使えるため、Classをインスタンス化する際、そのインスタンス(this)をWeakMapにsetすればWeakMap.get(this)でメンバにアクセスできるのだ。百聞は一見にしかずなので例示する。

var Foo = (function() {
	var privates = new WeakMap();

	function Foo() {
		privates.set(this, {});

		privates.get(this).prop = 1;
	}

	Foo.prototype.method = function() { return privates.get(this).prop };

	return Foo;
})();

ES6のClass定義パターン

上のように、WeakMapの中のプロパティにアクセスするためにはgetやsetというメソッドを使う必要があり、それは面倒なので以下のようなnamespaceという関数を作る。

'use strict';
export default function namespace() {
	let map = new WeakMap();

	return function(object) {
		if(! map.has(object)) {
			map.set(object, {});
		}
		return map.get(object);
	};
};

これをClassファイルにimportしてprivateなメンバを定義する方法を以下に例示する。

'use strict';
import ns from './namespace';

const Foo = (() => {
	let privates = ns();

	return class Foo {
		constructor() {
			let self = privates(this);
			self.privateProp = 1;
			this.prop = 2;

			self.privateMethod1 = privateMethod1.bind(this);
			self.privateMethod2 = privateMethod2.bind(this);
		}

		method() {
			let self = privates(this);
			return self.privateMethod1();
		}
	}

	function privateMethod1() {
		let self = privates(this);
		return self.privateProp + this.prop;
	}
	function privateMethod2() {
		return this.method();
	}
})();

ここでは、privates(this)で返ってくるオブジェクトにprivateなメンバをセットする。取得するときもprivates(this)から取得できる。privates(this)をいちいち呼び出すより、selfなどの変数に入れておくほうがよい。

また、privateなメソッドはclassの外でfunction文で宣言して(ホイスティング)、constructor内でprivates(this)にthisをbindして代入したほうがネストも浅くて済む。

もし、モジュール化でexportなどを使う場合、privateなメンバのアクセスをファイル全体まで許すこともできる。それは、即時関数でclassを囲うか囲わないかによる。

また、browserifyなどを使って複数のファイルを1つのファイルにあらかじめコンパイルしているのであれば、それらのファイル内のみメンバのアクセスを許可するといったような名前空間を作ることも可能である。

import ns from ./namespace;
export default ns();
import internal from './internal'
export default class Foo {
	conctructor() {
		internal(this).prop = 1;
	}
}
import internal from './internal'
import Foo from ./Foo
let foo = new Foo();
console.log(internal(foo).prop); // -> 1;

1つの方法として覚えておくと使える時がくるかもしれない。

終わりに

今回は、JavaScriptでprivateなメンバを定義する方法を書いてきた。特に、WeakMapを使った方法はかなり有用性があり、途中で示したnamespace.jsと合わせて使うとJavaScriptでもprivateなメンバを簡単に書けるようになる。今後、デフォでJavaScriptでもprivateなメンバを定義できるようになるかもしれないが、それまでは、このWeakMapを使った方法で定義することを推奨したい。

document.getElementsByText()

ユーザースクリプト用に書いた

"use strict";

(function () {
	function walkDOM(node, callback) {
		if (node === null) return;
		callback(node);

		walkDOM(node.firstChild, callback);
		walkDOM(node.nextSibling, callback);
	}

	function getElementsByText(text) {
		var set = new Set();
		walkDOM(this, function (node) {
			if (node.nodeType !== 3) return;
			if (node.nodeValue.indexOf(text) === -1) return;
			set.add(node.parentNode);
		});
		var ret = [];
		set.forEach(function (value) {
			ret.push(value);
		});
		return ret.length === 0 ? null : ret;
	}

	document.getElementsByText = getElementsByText;
	Element.prototype.getElementsByText = getElementsByText;
})();

使い方はこのスクリプトを読み込んで、document.getElementsByText(text)を実行するかElement.getElementsByText(text)を実行する。

引数のtextが含まれている親のエレメント達が配列で返ってくる。何もなければnullを返す。

GitHubに例を載せている。

再帰を使っているためスタックオーバーフローする可能性がある。

document.evaluateでXPathを使ったほうが早い。

あくまでもユーザースクリプト用に書いてみた。