+
+
+
+ JavaScript is a cross-platform, object-oriented scripting language.
+ It is a small and lightweight language. Inside a host environment
+ (for example, a web browser), JavaScript can be connected to the
+ objects of its environment to provide programmatic control over
+ them.
+
+
+
+ JavaScript contains a standard library of objects, such as Array,
+ Date, and Math, and a core set of language elements such as
+ operators, control structures, and statements. Core JavaScript can
+ be extended for a variety of purposes by supplementing it with
+ additional objects; for example:
+
+
+ -
+ Client-side JavaScript extends the core language by supplying
+ objects to control a browser and its Document Object Model (DOM).
+ For example, client-side extensions allow an application to place
+ elements on an HTML form and respond to user events such as mouse
+ clicks, form input, and page navigation.
+
+ -
+ Server-side JavaScript extends the core language by supplying
+ objects relevant to running JavaScript on a server. For example,
+ server-side extensions allow an application to communicate with a
+ database, provide continuity of information from one invocation to
+ another of the application, or perform file manipulations on a
+ server.
+
+
+
+
+
+ What you should already know
+
+ This guide assumes you have the following basic background:
+
+
+ -
+ A general understanding of the Internet and the World Wide Web
+ (WWW).
+
+ - Good working knowledge of HyperText Markup Language (HTML).
+ -
+ Some programming experience. If you are new to programming, try
+ one of the tutorials linked on the main page about JavaScript.
+
+
+
+
+
+
+
+
+ JavaScript and Java are similar in some ways but fundamentally
+ different in some others. The JavaScript language resembles Java but
+ does not have Java's static typing and strong type checking.
+ JavaScript follows most Java expression syntax, naming conventions
+ and basic control-flow constructs which was the reason why it was
+ renamed from LiveScript to JavaScript.
+
+
+
+ In contrast to Java's compile-time system of classes built by
+ declarations, JavaScript supports a runtime system based on a small
+ number of data types representing numeric, Boolean, and string
+ values. JavaScript has a prototype-based object model instead of the
+ more common class-based object model. The prototype-based model
+ provides dynamic inheritance; that is, what is inherited can vary
+ for individual objects. JavaScript also supports functions without
+ any special declarative requirements. Functions can be properties of
+ objects, executing as loosely typed methods.
+
+
+ JavaScript is a very free-form language compared to Java. You do not
+ have to declare all variables, classes, and methods. You do not have
+ to be concerned with whether methods are public, private, or
+ protected, and you do not have to implement interfaces. Variables,
+ parameters, and function return types are not explicitly typed.
+
+
+
+
+
+
+ You use variables as symbolic names for values in your application.
+ The names of variables, called identifiers, conform to certain rules.
+
+
+ A JavaScript identifier must start with a letter, underscore (_), or
+ dollar sign ($); subsequent characters can also be digits (0-9).
+ Because JavaScript is case sensitive, letters include the characters
+ "A" through "Z" (uppercase) and the characters "a" through "z"
+ (lowercase).
+
+
+ You can use ISO 8859-1 or Unicode letters such as å and ü in
+ identifiers. You can also use the Unicode escape sequences as
+ characters in identifiers. Some examples of legal names are
+ Number_hits, temp99, and _name.
+
+
+
+
+
+ You can declare a variable in three ways:
+
+ With the keyword var. For example, var x = 42. This
+ syntax can be used to declare both local and global variables.
+
+
+ By simply assigning it a value. For example,
+ x = 42. This always declares a global variable. It
+ generates a strict JavaScript warning. You shouldn't use this
+ variant.
+
+
+ With the keyword let. For example, let y = 13. This
+ syntax can be used to declare a block scope local variable. See
+ Variable scope below.
+
+
+
+
+
+
+
+ When you declare a variable outside of any function, it is called a
+ global variable, because it is available to any other code in the
+ current document. When you declare a variable within a function, it
+ is called a local variable, because it is available only within that
+ function.
+
+
+
+ JavaScript before ECMAScript 2015 does not have block statement
+ scope; rather, a variable declared within a block is local to the
+ function (or global scope) that the block resides within. For
+ example the following code will log 5, because the scope of x is the
+ function (or global context) within which x is declared, not the
+ block, which in this case is an if statement.
+
+ if (true) { var x = 5; } console.log(x); // 5
+
+ This behavior changes, when using the let declaration introduced in
+ ECMAScript 2015.
+
+
+ if (true) { let y = 5; } console.log(y); // ReferenceError: y is
+ not defined
+
+
+
+
+
+
+ Global variables are in fact properties of the global object. In web
+ pages the global object is window, so you can set and access global
+ variables using the window.variable syntax.
+
+
+
+ Consequently, you can access global variables declared in one window
+ or frame from another window or frame by specifying the window or
+ frame name. For example, if a variable called phoneNumber is
+ declared in a document, you can refer to this variable from an
+ iframe as parent.phoneNumber.
+
+
+
+
+
+
+
+ You can create a read-only, named constant with the const keyword.
+ The syntax of a constant identifier is the same as for a variable
+ identifier: it must start with a letter, underscore or dollar sign
+ and can contain alphabetic, numeric, or underscore characters.
+
+
+ const PI = 3.14;
+
+ A constant cannot change value through assignment or be re-declared
+ while the script is running. It has to be initialized to a value.
+
+
+
+ The scope rules for constants are the same as those for let block
+ scope variables. If the const keyword is omitted, the identifier is
+ assumed to represent a variable.
+
+
+
+ You cannot declare a constant with the same name as a function or
+ variable in the same scope. For example:
+
+
+ // THIS WILL CAUSE AN ERROR function f() {}; const f = 5; // THIS
+ WILL CAUSE AN ERROR ALSO function f() { const g = 5; var g;
+ //statements }
+ However, object attributes are not protected, so the following
+ statement is executed without problems.
+ const MY_OBJECT = {"key": "value"}; MY_OBJECT.key =
+ "otherValue";
+
+
+
+
+
+ The latest ECMAScript standard defines seven data types:
+
+ Although these data types are a relatively small amount, they enable
+ you to perform useful functions with your applications. Objects and
+ functions are the other fundamental elements in the language. You can
+ think of objects as named containers for values, and functions as
+ procedures that your application can perform.
+
+
+
+
+
+ Use the if statement to execute a statement if a logical condition is
+ true. Use the optional else clause to execute a statement if the
+ condition is false. An if statement looks as follows:
+
+ if (condition) { statement_1; } else { statement_2; }
+ condition can be any expression that evaluates to true or false. See
+ Boolean for an explanation of what evaluates to true and false. If
+ condition evaluates to true, statement_1 is executed; otherwise,
+ statement_2 is executed. statement_1 and statement_2 can be any
+ statement, including further nested if statements.
+
+ You may also compound the statements using else if to have multiple
+ conditions tested in sequence, as follows:
+
+ if (condition_1) { statement_1; } else if (condition_2) {
+ statement_2; } else if (condition_n) { statement_n; } else {
+ statement_last; }
+
+ In the case of multiple conditions only the first logical condition
+ which evaluates to true will be executed. To execute multiple
+ statements, group them within a block statement ({ ... }) . In
+ general, it's good practice to always use block statements, especially
+ when nesting if statements:
+
+ if (condition) { statement_1_runs_if_condition_is_true;
+ statement_2_runs_if_condition_is_true; } else {
+ statement_3_runs_if_condition_is_false;
+ statement_4_runs_if_condition_is_false; }
+ It is advisable to not use simple assignments in a conditional
+ expression, because the assignment can be confused with equality when
+ glancing over the code. For example, do not use the following code:
+ if (x = y) { /* statements here */ } If you need to use
+ an assignment in a conditional expression, a common practice is to put
+ additional parentheses around the assignment. For example:
+
+ if ((x = y)) { /* statements here */ }
+
+
+
+
+
+ A while statement executes its statements as long as a specified
+ condition evaluates to true. A while statement looks as follows:
+
+ while (condition) statement If the condition becomes
+ false, statement within the loop stops executing and control passes to
+ the statement following the loop.
+
+
+ The condition test occurs before statement in the loop is executed.
+ If the condition returns true, statement is executed and the
+ condition is tested again. If the condition returns false, execution
+ stops and control is passed to the statement following while.
+
+
+
+ To execute multiple statements, use a block statement ({ ... }) to
+ group those statements.
+
+
+ Example:
+
+
+ The following while loop iterates as long as n is less than three:
+
+
+ var n = 0; var x = 0; while (n < 3) { n++; x += n; }
+
+ With each iteration, the loop increments n and adds that value to x.
+ Therefore, x and n take on the following values:
+
+
+
+ - After the first pass: n = 1 and x = 1
+ - After the second pass: n = 2 and x = 3
+ - After the third pass: n = 3 and x = 6
+
+
+ After completing the third pass, the condition n < 3 is no longer
+ true, so the loop terminates.
+
+
+
+
+
+
+ A function definition (also called a function declaration, or function
+ statement) consists of the function keyword, followed by:
+
+
+ - The name of the function.
+ -
+ A list of arguments to the function, enclosed in parentheses and
+ separated by commas.
+
+ -
+ The JavaScript statements that define the function, enclosed in
+ curly brackets, { }.
+
+
+
+ For example, the following code defines a simple function named
+ square:
+
+
+ function square(number) { return number * number; }
+
+ The function square takes one argument, called number. The function
+ consists of one statement that says to return the argument of the
+ function (that is, number) multiplied by itself. The return
+ statement specifies the value returned by the function.
+
+ return number * number;
+
+ Primitive parameters (such as a number) are passed to functions by
+ value; the value is passed to the function, but if the function
+ changes the value of the parameter, this change is not reflected
+ globally or in the calling function.
+
+
+
+