I have created three (very) simple JavaScript methods for working with strings. Any competent JavaScript programmer could whip these up in 5 minutes; nonetheless, they are useful so I shall share them with you:
"use strict";
if (typeof String.prototype.sort !== "function") {
String.prototype.sort = function (funct) {
return this.split("").sort(funct).join("");
};
}
if (typeof String.prototype.splice !== "function") {
String.prototype.splice = function (index, length, add) {
var text = this.split("");
text.splice(index, length, add);
return text.join("");
};
}
if (typeof String.prototype.reverse !== "function") {
String.prototype.reverse = function () {
return this.split("").reverse().join("");
};
}
Let's examine them. All three make use of the string.split()
and array.join()
methods. These convert a string to an array and an array to a string, respectively.
By passing an empty string ""
as the single argument, it creates an array where each index holds a single character of the string. Thus:
var text = "Hi!";
text = text.split("");
// text[0] == "H"
// text[1] == "i"
// text[2] == "!"
text = text.join("");
// text == "Hi!"
Useless? Not so! This allows us to treat a string as an array of characters, and thus pretend that strings are mutable. As a simple example:
var text = "Testing";
text = text.split("");
text[0] = "a";
text[1] = "b";
text[2] = "c";
text = text.join("");
// text == "abcting"
You can also use this to delete characters at specific indices by setting the index to null
or ""
. In this way, you can manipulate strings.
This is very useful, but my methods go a step further by using the built-in Array
methods. After adding the above three methods to your program, you can do stuff like this:
var text = "Testing";
text = text.reverse();
// text == "gnitseT"
Or you can use the powerful array.splice()
method on strings:
var text = "Testing";
text = text.splice(3, 2).splice(0, 1, "A");
// text == "Aesng"
The first splice removes the characters at index 3
and 4
(remember, the second argument is the length, not the index!). The second splice removes the first index and inserts the string "A"
, producing the final result. Because all three methods return strings, you can chain them together, as shown above.
There are two differences between string.splice()
and array.splice()
:
-
string.splice()
returns a string, which is the source string with the splice method applied. On the other hand, array.splice()
returns an array of the removed values.
-
string.splice()
accepts up to 3 arguments. It ignores any arguments beyond the 3rd. array.splice()
accepts an unlimited number of arguments.
This is not a bug. These two lines are the same:
string.splice(0, 0, "a", "b", "c");
string.splice(0, 0, "a" + "b" + "c");
Because extra arguments are unnecessary, I snipped them out for performance reasons.
Beyond those two differences, string.splice()
performs identically to array.splice()
.
The third method is string.sort()
. This performs identically to array.sort()
, so please consult your favorite JavaScript manual for information on how to use it.
Note: I did not include the other Array
methods because they are either useless (like array.concat()
), can be simulated with array.splice()
(array.pop()
, array.push()
, etc.), or already have a String
equivalent (array.slice()
).
Note: Beyond the two differences listed for string.splice()
, all three methods perform identically to their Array
counterparts.
[LINK] The unit tests.
References:
[MDC] [w3] array.sort()
[MDC] [w3] array.splice()
[MDC] [w3] array.reverse()