JavaScript is a case-sensitive language. Case sensitivity in JavaScript does not only apply to variable names but also to JavaScript keywords and JavaScript's event handlers. For example, if you have the firstname and firstName variables, then these will be two different variables. In JavaScript, while calling a function, you must write its name exactly the same way as it was defined, matching the letter case.

A popular convention also used in JavaScript's primitive methods is to use camel case, in which a phrase is written with the first letter of the first word in lowercase and every successive word has an uppercase first letter, which makes it easier to read.

Examples of some functions are as follows:

JavaScript has functions that are built into the language; they take strings and transform them to the uppercase or lowercase. This can make handling strings easier to manipulate when the input has varying cases. The following are the two parameters the functions can take:

The .toUppercase() function will convert letters into uppercase and the .toLowerCase() function will convert letters into lowercase. These are the built-in and case-sensitive functions of JavaScript.

Spaces, Tabs, New lines which are not a part of a string are called whitespaces. JavaScript removes whitespaces and line breaks between tokens in the programs, Spaces and Line breaks that are a part of a string are not removed when script is executed.

In any text, there are three types of line breaks: or as or .

These line breaks occur in different types of operating systems:

If you want to remove line breaks from any text, then we must deal with all types of line breaks because the text could be from these three sources Windows, Linux, and Mac.

We have several methods to remove line breaks from any text. For example, we have the following:

varabc = abc.replace(/(
|
|
)/gm,"");

In this code, we have used a regular expression for removing line breaks from our text. This will remove line breaks , then , and finally . We used the suffix gm at the end of the regular expression because m shows that line breaks should be removed from all the text and g shows that it should be done more than once.

Regular expressions are discussed in detail in Chapter 8, JavaScript Expressions, Operators, Statements, and Arrays.

Now, there are some spaces between texts; you can remove these whitespaces using JavaScript. There are different functions of JavaScript for removing all leading spaces from a string; you can use the following:

str = str.replace(/^s+|s+$/g,'');

This piece of code uses a regular expression, which checks multiple occurrences of white spaces at beginning and end of string.

The g in this regular expression shows that the global search should be performed while checking the text. There are more methods, such as the following:

The JavaScript Unicode escape sequence allows you to place special characters in a string. Browsers that support JavaScript can use the escape function.

To add the next line within the same string, we can use . Let's take a look at the following code:

alert("Welcome to JavaScript. 
 We hope you love it!")

To add quotes within a string, we can use something like this:

var myquote="Jinnah said "Impossible is a word unknown to me.""

This Unicode escape sequence starts with a backslash () followed by characters. This backslash is the escape sequence character. To insert a backslash itself, just add another backslash "" before the next one. Also called double backslash (\).

You can specify a Unicode character by uaaaa, where aaaa is a hexadecimal number. So a Unicode escape character can represent a 16-bit character.

A Unicode escape sequence represents a Unicode sequence, as follows:

For example, the word cat will be represented as u732b.

A Unicode escape sequence can also be used in comments and literals. Consider the following example:

var x = "http\u00253A\u00252F\u00252Fexample.com";

You can also represent an escape sequence to represent a Unicode character ["u03b1"] as ["a"].The Unicode escape for the character é, for example, is u00E9, and the following two JavaScript strings are identical:

"cafn" === "cafu00e9" // => true

The == operator tries to convert the values to the same type before testing if they're the same; whereas, === does not do this. It requires objects to be of the same type to be equal.

Here are some examples of the escape sequence for some characters:

Protected reserved words cannot be used as a variable or a function name. If we use these, then there will be a compilation error in it. Here are a few protected reserved words:

JavaScript also released new keywords, and these reserved words have a special meaning for the current version of JavaScript. These reserved keywords can also be used as identifiers. Once you declare it as an identifier, then it will forget that it was a keyword. Here are some examples of new reserved keywords:

Future reserved words are proposed for future extensions of JavaScript. These are also used as an identifier in the current version of JavaScript. When you choose a word as an identifier, it is also important to note whether it is already the name of JavaScript reserved keyword. Here are some examples of future reserved words:

We can write multiple lines between the comment boundaries; this block of code will not be executed:

/* this is a comment */

Adding two forward slashes in the beginning of the line comments it. The text between // and the end of the line is commented and will not be compiled. Double forward slash is used to comment one line at a time:

// this is comment

JavaScript treats the HTML comment's opening sequence, that is, <!-- as // comment. It does not recognize the closing sequence of HTML comment, that is, --> HTML styled comments are not usually used within JavaScript code blocks as // is much handy. It is recommended not to use HTML comments in JS as that was an old practice. They were used to hide incompatible JavaScript code from old browsers.

An object literal is used to hold values in an object.

varbookObj={
  bookName="The Kite Runner",
  CoverImage="KiteRunner1.png",
  Author="KhaledHoesenni",
  bookCategory ="Bestseller"
};

An array literal contains a list of expressions that represent an array element.

var Planets= ["Earth", "Neptune", "Saturn", "Mars"];

As the name suggests, a Boolean literal has Boolean values, so its value is either true or false.

Integer literals must contain values that are only integers.

A floating point literal is used to contain floating numbers—numbers that have a decimal point, fraction, or exponent.

22.56
-26.35689
18.4e2 //Equivalent to [18.4 x 10^2] 
-17.22E3 //Equivalent to [17.22 x 10^-3]

String literals, as the name suggests, hold only string values, that is, values placed inside a pair of quotation marks.

strFirstName= "Jamie";
strLastName="Down";
strMarksObtained="200";
strClassesJoined="Microprocessors, "+ "Microcontrollers";
strAddress= "Michigan University 
 United States";

As the name suggests, conditional statements are based on conditions and the if and then rule. For example, "if you work hard, you will get rewarded". Here, working hard is the condition of getting rewarded.

Consider the following example:

if (age < 20 && age > 12) {
  person = "Teen ager";
}
else {
  person = "Not a Teenager";
}

In a loop statement, a condition is provided within a set of parentheses. If the condition evaluates to true, then the loop will continue working, and if the condition equates to false, the program will jump to the next line after the loop. An exception is the do while loop, which will always execute at least once. There are different types of loops in programming languages; they are as follows:

Here is an example that shows how the while loop is used:

var number = "";
var n = 0;
while (n < 10) {
  number += "
The number is " + n;
  n++;
}
console.log(number);

Loops are covered in more detail in Chapter 8, JavaScript Expressions, Operators, Statements, and Arrays.

Object manipulation statements in JavaScript are used to access the object's properties and methods at runtime to perform certain functions. JavaScript uses the for…in and with statements to manipulate objects.

Here is an example that shows how the object car can be manipulated:

<script type="text/javascript">
  var x;
  var car = new Object();
  car.brand = "Porche";
  car.model = "2014";
  car.colour = "Black";
  for (x in car) {
    console,log(x + " --- " + car[x] + "<br />");
  }
</script>

Output:

brand — Porche
model — 2014
color — Black

The try, catch, throw, and finally statements are used in JavaScript exception handling. Let's take a look at the following description:

Here is an example showing how exceptions are handled using the try and catch block:

<!DOCTYPE html>
<html>

  <head>

    <script type="text/javascript">
      <!--
        function Calculate() {
          x = document.getElementById("Val1").value;
          y = document.getElementById("Val2").value;

          try{
            if ( x == 0 ||y==0 ) {
            throw("Divide by zero error." ); 
          }
          else {
            var a = x / y;
            alert("The answer is: " + a );
          }

          catch ( err ) {
            alert("Error: " + err );
          }
        }
      //-->
    </script>

  </head>

  <body>
    <form>
      <p>Enter first value</p>

      <input id="Val1" type="text">
      <p>Enter second value</p>

      <input id="Val2" type="text">
      <p><input type="button" value="Calculate" onclick="Calculate();" /></p>
    </form>

  </body>
</html>