How to Use Regular Expressions in JavaScript

Regular expressions, often abbreviated as regex or regexp, are powerful tools used for pattern matching and manipulation of text data. They provide a concise and flexible way to search, extract, and modify text based on specific patterns or rules.

A regular expression is essentially a sequence of characters that defines a search pattern. The pattern can consist of various elements such as literal characters, metacharacters, and special symbols that have specific meanings. Regular expressions are widely used in programming languages, text editors, command-line tools, and other software applications.

Regular Expression Methods

Regular expressions are used with various methods in programming languages to perform operations like pattern matching, search, replace, and more. Here are some common methods and functions used with regular expressions, along with examples:

• test() method: This method tests whether a pattern matches a string and returns a boolean value indicating the result.

var text = "Hello, World!";
var regex = /Hello/;

var result = regex.test(text);
console.log(result); // Output: true

• match() method: This method searches a string for matches against a pattern and returns an array of the matched substrings.

var text = "The quick brown fox jumps over the lazy dog.";
var regex = /o\w+/g;

var matches = text.match(regex);
console.log(matches); // Output: ['own', 'ox', 'over']

• search() method: This method searches a string for the first occurrence of a pattern and returns the index of the match. If no match is found, it returns -1.

var text = "The quick brown fox jumps over the lazy dog.";
var regex = /fox/;

var index = text.search(regex);
console.log(index); // Output: 16

• replace() method: This method searches a string for matches against a pattern and replaces them with a specified replacement string.

var text = "Hello, World!";
var regex = /World/;

var result = text.replace(regex, "Universe");
console.log(result); // Output: "Hello, Universe!"

• split() method: This method splits a string into an array of substrings using a specified pattern as the delimiter.

var text = "apple,banana,grape,orange";
var regex = /,/;

var result = text.split(regex);
console.log(result); // Output: ['apple', 'banana', 'grape', 'orange']

These are just a few examples of methods commonly used with regular expressions. Different programming languages may have additional methods or variations of these methods, but the fundamental concepts remain similar. Regular expression methods allow you to perform operations based on patterns, matching, searching, replacing, or splitting strings using the power of regular expressions.

What are Regular Expression Flags?

Regular expression flags, also known as modifiers, are optional characters that can be added after the closing delimiter of a regular expression to modify its behavior. Flags allow you to control how the pattern is matched against the input string. Here are some commonly used regular expression flags in JavaScript:

1. g (global): This flag enables global matching, meaning the regular expression will search for all occurrences of the pattern within the input string, rather than stopping at the first match.
2. i (case-insensitive): With this flag enabled, the regular expression will perform a case-insensitive match. It means that uppercase and lowercase characters will be considered equivalent when matching.
3. m (multiline): The multiline flag changes the behavior of the ^ and $ anchors. By default, these anchors match the start and end of the entire input string. With the multiline flag, they also match the start and end of each line within the input string when using the ^ and $ anchors respectively.

Here’s an example that demonstrates the use of regular expression flags:

var text = "Hello, hello, Hello World!";
var regex = /hello/gi;

var matches = text.match(regex);
console.log(matches); // Output: [ 'Hello', 'hello' ]

In this example, the regular expression /hello/gi is created with the g and i flags. The g flag enables global matching, so it finds all occurrences of the word “hello” in the input string text. The i flag enables case-insensitive matching, so it matches both uppercase and lowercase versions of “hello”.

The match() method is then used to find all matches of the regular expression in the input string. The result is an array containing the matched substrings.

Regular expression flags are useful when you want to control the behavior of the pattern matching, such as finding multiple occurrences or ignoring case sensitivity. You can combine multiple flags together if needed, like /pattern/gim for a case-insensitive, global, multiline match.

How to Create A Regular Expression

Creating a regular expression involves defining the pattern you want to match or search for in a given text. Here are the steps to create a regular expression:

1. Determine the pattern: Start by understanding the pattern you want to match. It could be a specific sequence of characters, a range of characters, or a combination of both. For example, if you want to match email addresses, the pattern could be something like “^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$”.
2. Choose the appropriate metacharacters: Based on the pattern you want to match, select the appropriate metacharacters that will help define the pattern more precisely. Metacharacters like ‘.’, ‘*’, ‘+’, ‘?’, ‘|’, parentheses ‘()’, and character classes like ‘[abc]’ or ‘[0-9]’ can be used to build complex patterns.
3. Test and refine the regular expression: Use a regular expression tool or software that supports regular expressions to test and refine your expression. These tools often provide immediate feedback on whether the pattern matches or not. You can also use test cases and sample data to ensure that your regular expression behaves as expected.
4. Consider edge cases and escape special characters: Think about any special characters that might be part of your pattern and consider escaping them using the backslash () if you want to match them literally rather than treating them as metacharacters. For example, if your pattern includes a period (.), you need to escape it as ‘.’.
5. Iterate and refine: Regular expressions can be complex, and it may take some iterations to achieve the desired pattern. Don’t be discouraged if it doesn’t work perfectly on the first attempt. Keep refining and testing until you achieve the desired results.

Remember that regular expressions can vary slightly depending on the programming language or tool you are using, as different implementations may have slight differences in syntax or supported features. It’s important to consult the documentation or resources specific to the language or tool you are working with.

Additionally, online regular expression tools and resources can be immensely helpful in creating, testing, and understanding regular expressions. They often provide explanations and visualizations of the patterns, making it easier to grasp and modify them.

In JavaScript, you can create a regular expression using:

• A regular expression literal
• Using the RegExp constructor function

-> In JavaScript, regular expressions can also be created using regular expression literal syntax. The correct syntax for creating a regular expression using a regular expression literal is as follows:

// Creating a regular expression using regular expression literal syntax
var regex = /pattern/flags;

In the syntax above:

• pattern is a string that represents the pattern you want to match.
• flags (optional) are one or more characters that modify the behavior of the regular expression, as mentioned earlier.

In JavaScript, you can create a regular expression using a regular expression literal by enclosing the pattern between forward slashes (/). Here’s an example:

// Creating a regular expression to match a sequence of digits
var regex = /\d+/;

// Testing the regular expression against a string
var text = "I have 123 apples.";
var match = regex.exec(text);

// Outputting the matched result
console.log(match[0]); // Output: 123

In the code example above, we create a regular expression /d+/ using the regular expression literal syntax. This pattern matches one or more digits. We then use the exec() method of the regular expression object regex to search for a match in the string text. The result is stored in the match variable.

Finally, we output the matched result by accessing the first element (match[0]), which will contain the substring that matches the pattern. In this case, it will output “123” as the matched result.

Note that regular expressions created using regular expression literals have forward slashes (/) at the beginning and end to delimit the pattern. If you need to include a forward slash as part of your pattern, you can escape it using the backslash (). For example, to match a literal forward slash, you would use /\//.

-> You can also create a regular expression in JavaScript using the RegExp constructor function. The syntax for creating a regular expression with the RegExp constructor is as follows:

// Creating a regular expression using the RegExp constructor
var regex = new RegExp(pattern, flags);

In the syntax above:

• pattern is a string that represents the pattern you want to match.
• flags (optional) are one or more characters that modify the behavior of the regular expression. For example, the g flag enables global searching (matching all occurrences), the i flag enables case-insensitive searching, and the m flag enables multiline searching.

Here’s an example of creating a regular expression using the RegExp constructor:

// Creating a regular expression to match a sequence of digits
var regex = new RegExp("\\d+");

// Testing the regular expression against a string
var text = "I have 123 apples.";
var match = regex.exec(text);

// Outputting the matched result
console.log(match[0]); // Output: 123

In this example, we create a regular expression new RegExp("\\d+") using the RegExp constructor. The pattern \\d+ matches one or more digits. Note that we need to escape the backslash with an additional backslash (\\) because backslashes have special meaning in regular expression patterns and also in JavaScript string literals.

The rest of the code is similar to the previous example. We use the exec() method to search for a match in the string text, and then output the matched result.

Using the RegExp constructor allows you to create regular expressions dynamically, especially when the pattern or flags need to be determined at runtime.

How to use a regular expression literal

Using a regular expression literal in JavaScript is straightforward. You can create a regular expression by enclosing the pattern between forward slashes (/). Here’s how you can use a regular expression literal:

// Example 1: Matching a pattern
var regex = /pattern/;

// Example 2: Matching with flags
var regexWithFlags = /pattern/flags;

Let’s take a closer look at each example:

Example 1: Matching a pattern In this example, you create a regular expression literal by enclosing the pattern you want to match between forward slashes (/). For instance, if you want to match the word “hello” in a string, you can create the regular expression as /hello/. This pattern will match the first occurrence of “hello” in the string it is applied to.

var text = "Hello world!";
var regex = /hello/;

console.log(regex.test(text)); // Output: false (case-sensitive match)

In the code snippet, the regular expression /hello/ is used to match the word “hello” in the string text. Since the regular expression is case-sensitive, the test() method returns false because the string “hello” is not found in the input string.

Example 2: Matching with flags Regular expression literals can also include flags that modify the behavior of the pattern matching. Flags are added after the closing delimiter (/) of the regular expression. Here’s an example using the g (global) flag:

var text = "Hello hello Hello World!";
var regex = /hello/g;

var matches = text.match(regex);
console.log(matches); // Output: [ 'hello', 'hello' ]

In this example, the regular expression /hello/g is used to perform a global match for the word “hello” in the input string text. The match() method is then used to find all matches of the regular expression in the input string. The result is an array containing the matched substrings.

Regular expression literals provide a concise and readable way to define regular expressions directly in your code. They are convenient when you have a static pattern that doesn’t need to change dynamically.

How to use a regex constructor

To use the RegExp constructor in JavaScript, you can create a regular expression object dynamically with a string pattern and optional flags. Here’s how you can use the RegExp constructor:

// Example 1: Creating a regular expression
var regex = new RegExp("pattern");

// Example 2: Creating a regular expression with flags
var regexWithFlags = new RegExp("pattern", "flags");

Let’s explore each example in more detail:

Example 1: Creating a regular expression In this example, you create a regular expression object using the RegExp constructor. You pass the pattern as a string parameter to the constructor. For example, to create a regular expression that matches the word “hello”, you can use new RegExp("hello").

var text = "Hello world!";
var regex = new RegExp("hello");

console.log(regex.test(text)); // Output: true (case-sensitive match)

In the code snippet, the RegExp constructor is used to create a regular expression object regex with the pattern “hello”. The regular expression is then applied to the input string text using the test() method, which returns true because the string “hello” is found in the input string.

Example 2: Creating a regular expression with flags The RegExp constructor can also accept a second parameter, which is a string of flags that modify the behavior of the regular expression. Flags are optional but can be helpful in certain scenarios. For example, to perform a case-insensitive search, you can use new RegExp("hello", "i").

var text = "Hello world!";
var regex = new RegExp("hello", "i");

console.log(regex.test(text)); // Output: true (case-insensitive match)

In this example, the regular expression new RegExp("hello", "i") is created with the pattern “hello” and the flag "i" for case-insensitive matching. The test() method returns true because the regular expression matches the word “hello” in a case-insensitive manner.

Using the RegExp constructor allows you to create regular expressions dynamically, especially when the pattern or flags need to be determined at runtime. The constructor provides flexibility for more dynamic regular expressions compared to the regular expression literal syntax.

How to Use Regular Expression Special Characters

Regular expression special characters are characters that have special meaning within a regular expression pattern. They allow you to define more complex patterns and perform advanced matching operations. Here are some commonly used regular expression special characters and how to use them:

1. . (dot): Matches any single character except a newline. For example, the pattern /h.t/ would match “hat”, “hot”, “hit”, etc.
2. * (asterisk): Matches the preceding element zero or more times. For example, the pattern /ab*c/ would match “ac”, “abc”, “abbc”, “abbbc”, etc.
3. + (plus): Matches the preceding element one or more times. For example, the pattern /ab+c/ would match “abc”, “abbc”, “abbbc”, etc.
4. ? (question mark): Matches the preceding element zero or one time. For example, the pattern /ab?c/ would match “ac” or “abc”.
5. | (pipe): Acts as an OR operator, matching either the pattern on the left or the pattern on the right. For example, the pattern /apple|orange/ would match “apple” or “orange”.
6. () (parentheses): Groups multiple elements together. It can be used to apply quantifiers to a group or capture a matched substring. For example, the pattern /(\d+)-(\w+)/ would match and capture “123-abc” as two separate groups: “123” and “abc”.
7. [] (square brackets): Defines a character class, matching any single character within the brackets. For example, the pattern /[aeiou]/ would match any vowel character.
8. ^ (caret): Matches the beginning of a line or string. For example, the pattern /^Hello/ would match “Hello” at the start of a line or string.
9. $ (dollar sign): Matches the end of a line or string. For example, the pattern /World!$/ would match “World!” at the end of a line or string.

These are just a few examples of regular expression special characters. Regular expressions provide a rich set of special characters and metacharacters to define patterns for matching and manipulating text. It’s important to consider the context and syntax rules when using these special characters in your regular expressions.

Note that some special characters, such as ., *, +, ?, |, (, ), [, ], {, }, \, ^, $, and others, may have special meanings within regular expressions and need to be escaped using a backslash (\) if you want to match them literally.

Regular expression special characters can be powerful tools for pattern matching and text manipulation. Familiarizing yourself with their usage and understanding their behavior will enable you to create more robust regular expressions.

Shortcodes for Other Metacharacters

In regular expressions, metacharacters are special characters with a predefined meaning. To match these metacharacters literally, you can use backslashes () to escape them. Here are some common metacharacters and their corresponding shortcodes:

1. \.: Matches a literal dot (.)
2. \\: Matches a literal backslash ()
3. \*: Matches a literal asterisk (*)
4. \+: Matches a literal plus sign (+)
5. \?: Matches a literal question mark (?)
6. \|: Matches a literal pipe (|)
7. \(: Matches a literal opening parenthesis (()
8. \): Matches a literal closing parenthesis ())
9. \[: Matches a literal opening square bracket ([)
10. \]: Matches a literal closing square bracket (])
11. \{: Matches a literal opening curly brace ({)
12. \}: Matches a literal closing curly brace (})
13. \^: Matches a literal caret (^)
14. \$: Matches a literal dollar sign ($)
15. \/: Matches a literal forward slash (/)

Here’s an example that demonstrates the usage of shortcodes for metacharacters:

var text = "The regex metacharacters are: . * + ? | ( ) [ ] { } ^ $ /";
var regex = /\./;

console.log(regex.test(text)); // Output: true

In this example, the regular expression /\./ is used to match a literal dot (.) in the input string text. The dot is a metacharacter in regular expressions, so it needs to be escaped with a backslash to match it literally.

Using shortcodes for metacharacters allows you to include these characters in your regular expressions when they need to be matched literally. Remember to escape them with a backslash () to indicate their literal interpretation.

What is a Character Class?

A character class in regular expressions allows you to define a set of characters that you want to match. It is enclosed within square brackets ([]). The character class matches any single character that is present in the set. Here’s an example:

var text = "The quick brown fox jumps over the lazy dog.";
var regex = /[aeiou]/;

var matches = text.match(regex);
console.log(matches); // Output: [ 'e', 'u', 'i', 'o', 'o', 'u', 'e', 'o', 'e', 'a', 'o' ]

In this example, the character class [aeiou] is used in the regular expression. It matches any single character that is either “a”, “e”, “i”, “o”, or “u”. The match() method is then used to find all matches of the regular expression in the input string text. The result is an array containing the matched characters, which are all the vowels present in the string.

Character classes are versatile and can match a single character from a set of options. You can include any characters inside the square brackets, and the regular expression engine will match any one character from the defined set. For example, [abc] matches either “a”, “b”, or “c”, while [0-9] matches any digit from 0 to 9.

Character classes also support various shorthand notations to match common sets of characters, such as:

• \d matches any digit character (equivalent to [0-9]).
• \w matches any word character (alphanumeric and underscore).
• \s matches any whitespace character (space, tab, newline, etc.).
• \D matches any non-digit character (equivalent to [^0-9]).
• \W matches any non-word character.
• \S matches any non-whitespace character.

For example, the regular expression \d\s\w matches a digit, followed by a whitespace character, followed by a word character.

Character classes provide a powerful way to specify sets of characters you want to match in your regular expressions. They can be combined with other regular expression elements to create complex patterns for text matching and manipulation.

What is a Negated Character Class?

A negated character class in regular expressions allows you to define a set of characters that you do not want to match. It is created by placing a caret (^) immediately after the opening square bracket ([^…]). The negated character class matches any single character that is not present in the set. Here’s an example:

var text = "The quick brown fox jumps over the lazy dog.";
var regex = /[^aeiou]/;

var matches = text.match(regex);
console.log(matches); // Output: [ 'T', 'h', ' ', 'q', 'c', 'k', ' ', 'b', 'r', 'w', 'n', ' ', 'f', 'x', ' ', 'j', 'm', 'p', 's', ' ', 'v', 'r', ' ', 't', 'h', ' ', 'l', 'z', 'y', ' ', 'd', 'g', '.' ]

In this example, the negated character class [^aeiou] is used in the regular expression. It matches any single character that is not “a”, “e”, “i”, “o”, or “u”. The match() method is then used to find all matches of the regular expression in the input string text. The result is an array containing all the characters in the string that are not vowels.

The caret (^) at the beginning of the character class negates the set, making it match any character that is not listed within the brackets. It effectively excludes the specified characters from being matched.

Negated character classes can be used with any set of characters, not just individual characters. For example, the negated character class [^0-9] matches any character that is not a digit.

Negated character classes provide a convenient way to specify characters that should not be matched in a regular expression. They can be useful for filtering out specific characters or character ranges from the matching process.

What is a Range?

In regular expressions, a range is a way to specify a continuous sequence of characters. It allows you to define a set of consecutive characters that you want to match. Ranges are commonly used inside character classes (square brackets []) to simplify pattern definitions. Here’s an example:

var text = "The quick brown fox jumps over the lazy dog.";
var regex = /[a-z]/;

var matches = text.match(regex);
console.log(matches); // Output: ['h', 'e', 'q', 'u', 'i', 'c', 'k', 'b', 'r', 'o', 'w', 'n', 'f', 'o', 'x', 'j', 'u', 'm', 'p', 's', 'o', 'v', 'e', 'r', 't', 'h', 'e', 'l', 'a', 'z', 'y', 'd', 'o', 'g']

In this example, the range [a-z] is used inside the character class to match any lowercase alphabetic character from “a” to “z”. The match() method is then used to find all matches of the regular expression in the input string text. The result is an array containing all the lowercase alphabetic characters found in the string.

Ranges simplify pattern definitions by allowing you to specify a continuous sequence of characters without listing each character individually. For example, [0-9] matches any digit from 0 to 9, [A-Z] matches any uppercase letter from A to Z, and [a-zA-Z] matches any alphabetic character, regardless of case.

Ranges can also be used with other character types, such as \d (digits) and \w (word characters). For example, [\d-] matches any digit or hyphen character.

It’s important to note that ranges are based on the ASCII/Unicode character order. Therefore, when working with characters from non-English alphabets or Unicode characters, special care should be taken to ensure the range covers the desired characters.

Ranges provide a convenient way to define a sequence of characters in a concise manner within regular expressions. They help simplify pattern matching for character sequences that follow a specific order or pattern.

What is Alternation?

Alternation, denoted by the vertical bar (|) in regular expressions, allows you to specify multiple alternatives within a pattern. It behaves as an OR operator, matching either the pattern on the left or the pattern on the right. Here’s an example:

var text = "I love cats and dogs.";
var regex = /cats|dogs/;

var matches = text.match(regex);
console.log(matches); // Output: ['cats']

In this example, the alternation cats|dogs is used in the regular expression. It matches either the word “cats” or the word “dogs”. The match() method is then used to find the first match of the regular expression in the input string text. The result is an array containing the matched alternative, which is “cats” in this case.

The alternation operator allows you to define multiple options within a regular expression, and it will match the first occurrence of any of the alternatives. If there are multiple occurrences of the alternatives in the input string, only the first one will be matched.

Here’s another example with alternation:

var text = "I love apples and oranges.";
var regex = /apples|oranges/;

var matches = text.match(regex);
console.log(matches); // Output: ['apples']

In this case, the alternation apples|oranges matches either the word “apples” or the word “oranges”. The match() method returns an array with the first matched alternative, which is “apples”.

Alternation can be used with more complex patterns and can be combined with other regular expression elements to create more versatile matching conditions. It provides a way to specify multiple options within a regular expression and find the first occurrence of any of the alternatives.

What are Quantifiers and Greediness?

In regular expressions, quantifiers are used to specify the number of occurrences of a preceding element or group. They allow you to define how many times a character, group, or metacharacter should appear in order to form a match. Quantifiers help make regular expressions more flexible and powerful.

Here are some commonly used quantifiers:

1. * (asterisk): Matches the preceding element zero or more times. For example, /ab*c/ would match “ac”, “abc”, “abbc”, “abbbc”, and so on.
2. + (plus): Matches the preceding element one or more times. For example, /ab+c/ would match “abc”, “abbc”, “abbbc”, and so on.
3. ? (question mark): Matches the preceding element zero or one time. For example, /ab?c/ would match “ac” or “abc”.
4. {n}: Matches the preceding element exactly n times. For example, /a{3}/ would match “aaa”.
5. {n,}: Matches the preceding element n or more times. For example, /a{2,}/ would match “aa”, “aaa”, “aaaa”, and so on.
6. {n,m}: Matches the preceding element between n and m times (inclusive). For example, /a{2,4}/ would match “aa”, “aaa”, or “aaaa”.

Quantifiers can be applied to individual characters, character classes, groups, or metacharacters. They provide flexibility in defining the number of repetitions required to form a match.

Greediness is a behavior of quantifiers that determines how they match the input text. By default, quantifiers are greedy, which means they match as much as possible. Greedy quantifiers will match the longest possible sequence that satisfies the pattern.

For example, given the input string “aaaa”, the regular expression /a+/ with a greedy quantifier will match the entire string “aaaa” because it matches one or more “a” characters greedily.

To make quantifiers lazy or non-greedy, you can use the ? modifier immediately after the quantifier. This makes the quantifier match as little as possible.

For example, the regular expression /a+?/ with a lazy quantifier will match each individual “a” character separately in the input string “aaaa”.

Understanding quantifiers and their greediness is important when working with regular expressions, as it allows you to control the matching behavior and ensure you get the desired results. By using quantifiers effectively, you can create more flexible and precise regular expressions.

What are Grouping and Backreferencing?

Grouping and backreferencing are powerful features in regular expressions that allow you to group parts of a pattern together and refer to them later. They provide a way to capture and reuse matched substrings within a regular expression.

Grouping is done using parentheses ( and ). When you enclose a part of a regular expression pattern within parentheses, it creates a group. Here’s an example:

var text = "Hello, John!";
var regex = /(Hello), (John)!/;

var matches = text.match(regex);
console.log(matches); // Output: ['Hello, John!', 'Hello', 'John']

In this example, the pattern /(Hello), (John)!/ uses grouping to capture the words “Hello” and “John”. The match() method is then used to find all matches of the regular expression in the input string text. The result is an array containing the overall match and the captured groups.

Backreferencing allows you to refer to the captured groups within the same regular expression. It is done using backslashes followed by a number (\1, \2, etc.) corresponding to the group’s position. Here’s an example:

var text = "apple apple";
var regex = /(\w+)\s\1/;

var matches = text.match(regex);
console.log(matches); // Output: ['apple apple', 'apple']

In this example, the pattern (\w+)\s\1 uses grouping to capture a word (\w+) and then match the same word again using \1. The \1 is a backreference to the first captured group. The match() method returns an array containing the overall match and the captured group.

Grouping and backreferencing are useful when you need to capture and reuse parts of a matched string. They allow you to extract specific portions of interest and refer to them later in the regular expression. This can be helpful in tasks such as finding duplicate words, extracting specific patterns, or performing more complex replacements.

Conclusion

Regular expressions are a powerful tool for pattern matching and manipulating text. They allow you to define complex patterns and search for specific sequences of characters within strings. Regular expressions are supported in many programming languages and are widely used in tasks such as data validation, text parsing, search and replace operations, and more.

In this conversation, we covered the basics of regular expressions, including the syntax, flags, and the two common ways of creating regular expressions in JavaScript (literal syntax and constructor function). We explored various elements such as metacharacters, quantifiers, character classes, alternation, grouping, and backreferencing. We also discussed some common methods used with regular expressions, such as test(), match(), search(), replace(), and split().

Regular expressions provide a flexible and concise way to work with text patterns, allowing you to solve a wide range of text manipulation problems. While regular expressions can be complex and require practice to master, they are a valuable skill for any developer or data professional working with textual data. Regular expressions can significantly enhance your ability to process and manipulate text efficiently and effectively.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.