In this post i am going to talk about the capabilities available in JavaScript for strings.

Strings

Strings are bunch of characters or spaces grouped together. Strings can be represented placing these characters inside single quotes (‘ ’) or double quotes (“ ”). Inside these single and double quotes we could use zero or more characters.

Strings are the most used datatype in Javascript.
They are used within the client side JavaScript code.
When making an ajax call to the server.
Serializing the JavaScript objects passed over the wire.
The ToString method is available on the JavaScript objects and it returns the string representation of the object in serialized format.
One of the JavaScript primitive types (number, Boolean, null and undefined). It can be an object as well.
Strings are JavaScript literal format for number, Boolean, arrays, objects and regex.

Note – A literal is a notation for representing fixed value in the source code.

Represented by single quotes (‘I am a String’) or double quotes (“I am a String”).
If we want to include quotes (‘, ’, “, ”), slashes (/, ), backspace (b), formfeed (f), newline (n), carriage return (I) or tab (t) inside our string then we need to follow those quotes via backslash (). All charades in JavaScript are 16-bits wide.
There is no character type in JavaScript so we need to use string with one character.
The length property of string can be used to find out the number of characters in the string.
Strings are immutable. This means that once created they cannot be modified, so whenever we modify a string a new string is created with a new value.
Two strings are same if they have same characters in the same order.
We can convert a number to a string by using the .ToString() method.

Strings are value type

Strings are a value type in JS, so they can’t have any properties attached to them, no prototype, etc. Any attempt to access a property on them is technically performing the JS [[ToObject]] conversion (in essence new String).

function stringLiteral() {

a = “foo”

a.b = “bar”

alert(“a.b = ” + a.b); //Undefined

}

function stringObject() {

A = new String(“foo”);

A.b = “bar”;

alert(“A.b = ” + A.b); // bar

}

function compareLiteralToObject() {

alert(“Are ‘foo’ and new String(‘foo’) equal = ” + (“foo” === new String(“foo”))); //fail bcoz string type if not equal to object type.

}

String Methods

tolowerCase –> Converts the string to lower case.

function lowerCaseString() {

alert(“Lower case string for ‘Foo’ is ” + “FOO”.toLowerCase()); //foo

}

concat –> Concats the string/s passed as the parameter.

It is equivalent to using + or += except that it is easier when passing multiple strings to concat.

function stringConcatination() {

var str = “foo “;

console.log(str.concat(“is “, “not “, “bar.”)); // foo is not bar.

str = “foo “;

console.log(str + “bar.”); // foo bar.

str = “foo “;

console.log(str += “bar.”);

}

Using this method we can not only concatenate string values but we also concatenate other data types to string.

localeCompare à Returns a number (-1, 0 or 1) indicating whether a reference string comes before or after or is the same as the given string in sort order.

function stringLocaleCompare() {

console.log(“foo”.localeCompare(“bar”)); //1

console.log(“bar”.localeCompare(“foo”)); //-1

console.log(“foo”.localeCompare(“foo”)); //0

}

String comparison can also be done by using operators like

== –> equal

!= –> not equal

=== –> strict equal

!== –> strict not equal

> –> greater than

>= –> greater than or equal

< –> less than

<= –> less than or equal

indexOf –> Returns the index within the calling String object of the first occurrence of the specified value, or -1 if not found.

lastIndexOf –> Returns the index within the calling String object of the last occurrence of the specified value, or -1 if not found.

function indexOfSubstring() {

console.log(“The position of 1st ‘foo’ in the string is ” + “foo is the same as bar but foo is the same as foo”.indexOf(‘foo’)); //The position of 1st ‘foo’ in the string is 0

console.log(“The position of last ‘foo’ in the string is ” + “foo is the same as bar but foo is the same as foo”.lastIndexOf(‘foo’)); //The position of last ‘foo’ in the string is 46

}

In both these methods we can also pass the index from where we want to start the search.

substr –> Returns the characters in a string beginning at the specified location through the specified number of characters.

substring –> Returns the characters in a string between two indexes into the string.

function substringFunc() {

console.log(“eat, sleep and code!!”.substring(15, 4)); // returns characters between the two specified indices

// sleep and

console.log(“eat, sleep and code!!”.substr(15, 4)); // returns the characters starting at the specified index and till the number of characters specified

// code

}

valueOf –> Returns the primitive value of the specified object. It overrides the Object.prototype.valueOf method.

Note – This valueOf method is available on all JavaScript objects.

function valueOfObjects() {

var boolObj = true;

var numberObj = 4;

person = new Object();

person.firstname = “John”;

person.lastname = “Doe”;

person.age = 25;

person.eyecolor = “blue”;

var stringObj = “This is a string.”

console.log(boolObj.valueOf()); // true

console.log(numberObj.valueOf()); // 4

console.log(person.valueOf()); // Object {firstname: “John”, lastname: “Doe”, age: 25, eyecolor: “blue”}

console.log(stringObj.valueOf()); // This is a string.

}

split –> Splits a String object into an array of strings by separating the string into substrings.

function splitString() {

console.log(“eat,sleep,code”.split()); // [“eat,sleep,code”]

console.log(“eat,sleep,code”.split(‘,’)); // [“eat”, “sleep”, “code”]

console.log(“eat,sleep,code”.split(‘,’, 2)); // [“eat”, “sleep”]

// Regex split

console.log(“eat,sleep,code”.split(/e/)); //[“”, “at,sl”, “”, “p,cod”, “”]

}

Requires JavaScript 1.8.1

trim –> Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.

Requires JavaScript 1.8.1 Non-standard

trimLeft –> Trims whitespace from the left side of the string.

trimRight –> Trims whitespace from the right side of the string.

function trimString() {

console.log(” lsdjkflk “); // lsdjkflk

console.log(” lsdjkflk “.trim()); // lsdjkflk

console.log(” lsdjkflk “.trimLeft()); // lsdjkflk

console.log(” lsdjkflk “.trimRight()); // lsdjkflk

}

If we are running the version of JavaScript below the specified version then we need to write our own trim method. It could look something like below.

function trimming(str) {

return str.replace(/(^\s*)|(\s*$)/g, “”);

}

function trimString() {

console.log(trimming(” lsdjkflk “)); // lsdjkflk

}

Other String methods

Source – https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String

charAt –> Returns the character at the specified index.

charCodeAt –> Returns a number indicating the Unicode value of the character at the given index.

contains –>Determines whether one string may be found within another string.

endsWith –> Determines whether a string ends with the characters of another string.

match –> Used to match a regular expression against a string.

quote –> (Non-standard) Wraps the string in double quotes (“””).

replace –> Used to find a match between a regular expression and a string, and to replace the matched substring with a new substring.

search –> Executes the search for a match between a regular expression and a specified string.

slice –> Extracts a section of a string and returns a new string.

startsWith –> Determines whether a string begins with the characters of another string.

toLocaleLowerCase –> The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as toLowerCase.

toLocaleUpperCase –> The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as toUpperCase.

toLowerCase –> Returns the calling string value converted to lower case.

toSource –> (Non-standard) Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource method.

toString –> Returns a string representing the specified object. Overrides the Object.prototype.toString method.

toUpperCase –> Returns the calling string value converted to uppercase.

Bonus – Including special characters in the strings

To include special characters in the string we need to include the Unicode hexadecimal format of the characters. I have added a few below. To include these characters need to be prefixed by \ (escape sequence).

function specialCharacters() {

}

A detailed list of the hexadecimal code can be found here.

Bonus – Prompt for user input

This is useful when want to get some user input only at some event or condition and do not want to add a text input control.

function promptForUserInput() {

var userInput = prompt(“What’s your name?”, “”);

console.log(“You entered – ” + userInput);

}

Some of these functions are live here. You can go ahead and play with them. All of these have been implemented by using knockout data binding

The source code for this post can be downloaded here.

Abhishek Shukla

Tag: Knockout

Strings in JavaScript – Sample with knockout