Most cases where you find String.substr() in the wild are to check if a given string begins with a certain other string. Be it checking for a prefix or sorting out zipcodes that begin with certain numbers. And because code readability is a good thing (really, it is important), it would be nice to have a String.beginsWith() method. Or, because of dojo love, a dojo.string.beginsWith() method.
Consider the following code:
var nearbyZipcodes = dojo.filter(givenZipcodes,function(zipcode){
return dojo.string.beginsWith(zipcode,'12');
});
No need to tell you what this does, right? So, let’s do this then! The only thing left is to think about performance: Is there a difference between String.substr() and String.substring()? And can we get faster than the two?
If we have very short needles to look for in our haystack, one could consider the following approach:
dojo.string.beginsWith = function(/* string */ needle, /* string */ haystack) {
var i,
len = needle.length;
if(needle.length > haystack.length) {
return false;
}
for(i = 0; i < len; i++) {
if(needle.charAt(i) !== haystack.charAt(i)) {
return false;
}
}
return true;
}
For very short needles, or when we expect close to no hits, this might be faster. So I set up a test page and let the different methods run against each other. The results clearly spoke against the char iteration method: On Firefox, iteration was always slower, even when the iteration method could return false after the first character. And when it had to iterate more often, times went up (I somehow had in mind Tracemonkey was perfect for simple iterations – but in this case it won’t help). Only on Safari the iteration method could compete with native substr() / substring() – but was never significantly faster. So, we’ll stick to the native methods (there was no real difference between the two).
More convenience?
Depending on your datasource, you might want to trim the input. No problem, as we use dojo, we can use it’s super fast trim and end up with the following:
dojo.string.beginsWith = function(/* string */ needle, /* string */ haystack, /* bool */ trimBefore) {
if(trimBefore) {
needle = dojo.string.trim(needle)
}
if(needle.length > haystack.length) {
return false;
}
return haystack.substr(0,needle.length) === needle;
}
So simple, so sweet.
You can run the tests for yourself, the page is located here: test_beginsWith.html
If you want to use beginsWith in your code, just put the lines above it anywhere in your code – but don’t forget to dojo.require(‘dojo.string’) before.
You can then, of course, use that method to augment the String prototype too:
String.prototype.beginsWith = function(term){
return dojo.string.beginsWith(this, term);
}
fun.
Why not just using:
function endsWith(string, suffix) { return new RegExp(suffix+”$”).test(string); }
and:
function startsWith(string, prefix) { return new RegExp(“^”+prefix).test(string); }
to test if a string ends or begins with a certain other string?
@Fabián: because it would be awfully slow. Regular Expressions are heavy-duty jobs and take lots of time and computing power – Javascript is no exception to this. And, the use of RegExp would grant us no benefit here compared to String.substr().