Pattern matching on JSON using JavaScript (Part 2 - Implementation)_javascript skills

Notify & Capture
It is too easy to implement notify and capture. We only need to save the handlers passed in by capture, and then find the matching handler in notify.

Copy code The code is as follows:

var filterHandlerBundles = [];
Dispatch.capture = function(pattern, handler) {
var filter = createFilter(pattern);
filterHandlerBundles.push({
"filter": filter,
"handler": handler
});
};
Dispatcher.notify = function(json) {
for (var i = 0; i < filterHandlerBundles.length; i ) {
if (filterHandlerBundles[i].filter.apply (this, arguments)) {
filterHandlerBundles[i].handler(json);
}
}
};

The logic of this code is very clear. The key lies in the createFilter part. This function is responsible for converting a JSON describing the pattern into a function that determines whether the JSON matches.
Operators
We have designed a lot of algorithms, how to implement them? Remember, we don't want to switch case . Therefore, we use an associative array to save the mapping between operators and implementations.

Copy code The code is as follows:

var operators = {};
operators[" lt"] = function(testValue, value) {
return arguments.length == 2 && value < testValue;
};
operators["lte"] = function(testValue, value) {
return arguments.length == 2 && value <= testValue;
};
operators["gt"] = function(testValue, value) {
return arguments.length == 2 && value > testValue;
};
operators["gte"] = function(testValue, value) {
return arguments.length == 2 && value >= testValue;
};

In this way, as long as we extract the operator after "$", we can immediately find the corresponding judgment function. The above four are comparison operators. Since they are relatively easy to implement, they are included here as examples.
A more difficult function is eq because it requires a specific judgment method to be selected based on the data type. For String, Number, and Boolean, the meaning of eq is ==; for Array, the meaning of eq is that every element in it is eq, and the order is consistent; for Object, the meaning of eq is that every sub-condition is met, so we need Extract the operator string of each sub-condition, and then call the corresponding operator. Please refer to the complete code for details.
Other operators will be simpler. I will just give a hint here. You can use subsets or supersets of these operators according to your actual needs:

in - Traverse the array to see if you can find it. At least one eq.
all - Traverse the array to see if eq exists in each one.
ex - If a value is passed in, the child element exists.
re - Use regular expressions to determine whether a string matches.
ld - directly call the function for judgment.
Have you finished writing? Not sure if you wrote it correctly? This is what we'll discuss in our next article, so let's start by adding a default operator.

Copy code The code is as follows:

operators[""] = function(testValue, value) {
if (testValue instanceof Array) {
return operators["in"].apply(this, arguments);
} else if (testValue instanceof RegExp) {
return operators["re" ].apply(this, arguments);
} else if (testValue instanceof Function) {
return operators["ld"].apply(this, arguments);
} else {
return operators ["eq"].apply(this, arguments);
}
};

Why do you need a default operator? This is really just a shortcut. Most of the time, what we need is the eq operation. If the operator is written everywhere, the code will become very complicated and not beautiful. Compare the two JSONs, which one do you think is more natural?

Copy code The code is as follows:

Dispatcher.capture({
"status": 200,
"command": "message"
}, function(json) { /* display message */ });
Dispatcher.capture({
"status$eq": 200,
"command$eq": "message"
}, function(json) { /* display message */ });

Obviously, the first one is more intuitive. Therefore, we need a default operator, and when the operator string is "", we select an operator through the default operator.
Pattern to Filter
Finally, we need to connect operators and createFilter. This part of the work is actually not difficult, just call the default operator.

Copy code The code is as follows:

var createFilter = function(condition) {
return function(json) {
if (arguments.length > 0) {
return operators[""](condition, json);
} else {
return operators[""](condition );
}
};
};

Why do we need to consider that the json parameter is not passed in? I’ll tell you in the next article. It’s okay not to do this, it’s just a small problem.
When writing operators, the most important thing is rigor. Because Dispatcher is an encapsulated component, if the operator is not rigorous at all, the defects will be buried deep and difficult to find. Therefore, the next article we are going to discuss is unit testing, through which we can greatly improve the robustness of Dispatcher.