About Me

Having 12 years experience in Microsoft technologies.Since more than 7 years working in SharePoint technologies. Expert in providing consultation for SharePoint projects. Hands on with development and administration.

Tuesday, 25 November 2014

SharePoint 2013 Apps - java script/jquery coding standards

It is required to know & understand coding standards of java script & jquery, because it is mandatory when you develop SharePoint 2013 apps.
1.1               Naming Conventions
·         Terminology and Definitions:
·         Camel Case (camelCase): The first letter of the word is lower case and then each first letter of the part of the word is upper case;
·         Pascal Case (PascalCase): The first letter of the word is upper case and then each first letter of the part of the word is upper case;
·         Underscode Prefix (_underscore): The word begins with underscore char and for the rest of the word use camelCase rule;
1.2               General Rules
·         Use Pascal Case for Class names:
Ex: public class HelloWorld { ... };
·         Use Pascal Case for Method names:
Ex: public void SayHello(string name) { ... };
·         Use Camel Case for variables and method parameters:
int totalCount = 0;
void SayHello(string name)
string fullMessage = "Hello " + name;
·         Avoid all upper case or all lower case names;
Do not use Hungarian notation:
Example of Hungarian Notation:
string m_sName; (the prefix m_ means that is a member variable and s means that is a string data type);
·         Code Commenting
Adding comments to your work is without doubt one of the most important factor in team working. More than that, it also represents the best technique for keeping the code maintainable in time. Have a look at rules below:
·         General Rules
All comments should be written in the same language, be grammatically correct and contain appropriate punctuation;
Use // or /// but not /* … */;
Do not use flower box comments
// flower box
Use inline comments to explain assumptions, known issues and algorithm insights;
Do not use inline comments to explain obvious code. Well written code is self-documenting; Always apply comment-blocks (///) to public, protected and internal
1.3               JavaScript Files
·         JavaScript programs should be stored in and delivered as .js files.
·         JavaScript code should not be embedded in HTML files unless the code is specific to a single session. Code in HTML adds significantly to page weight with no opportunity for mitigation by caching and compression.
·         <script src=filename.js> tags should be placed as late in the body as possible. This reduces the effects of delays imposed by script loading on other page components. There is no need to use the language or type attributes. It is the server, not the script tag, that determines the MIME type.
1.4               Indentation
·         The unit of indentation is four spaces. Use of tabs should be avoided because there still is not a standard for the placement of tab stops.
1.5               Line Length
·         Avoid lines longer than 80 characters. When a statement will not fit on a single line, it may be necessary to break it. Place the break after an operator, ideally after a comma. A break after an operator decreases the likelihood that a copy-paste error will be masked by semicolon insertion. The next line should be indented 8 spaces.
·         Be generous with comments. It is useful to leave information that will be read at a later time by people (possibly yourself) who will need to understand what you have done. The comments should be well-written and clear, just like the code they are annotating.
·         It is important that comments be kept up-to-date. Erroneous comments can make programs even harder to read and understand.
·         Make comments meaningful. Focus on what is not immediately visible. Don't waste the reader's time with stuff like
·             i = 0; // Set i to zero.
·         Generally use line comments. Save block comments for formal documentation and for commenting out.
1.7               Variable Declarations
·         All variables should be declared before used. JavaScript does not require this, but doing so makes the program easier to read and makes it easier to detect undeclared variables that may become implied global. Implied global variables should never be used.
·         The var statements should be the first statements in the function body.
·         It is preferred that each variable be given its own line and comment. They should be listed in alphabetical order.
    var currentEntry; // currently selected table entry
    var level;        // indentation level
    var size;         // size of table
·         JavaScript does not have block scope, so defining variables in blocks can confuse programmers who are experienced with other C family languages. Define all variables at the top of the function.
·         Use of global variables should be minimized. Implied global variables should never be used.
·         Use strict mode. The rules for declaring variables in JavaScript are fairly relaxed. If you omit the var keyword in a variable declaration, the variable is implicitly given global scope. This means you can accidentally declare a new global variable without realizing it, as illustrated in the following example:
function someFunction() {
   var errorCode = 100; // Declares a local variable named errorCode.
   count = 0; // Implicitly declares a global variable named count;
To avoid accidentally declaring global variables by omitting the var keyword, you can use strict mode as follows:
function someFunction() {
   "use strict";
    // Other statements.
When you use strict mode, you will get an error if you try to declare a variable without using var;
JavaScript will not automatically promote the variable to global scope.
·         Because JavaScript is very loose with rules concerning variable and object definitions, you should be sure to always use strict JavaScript in your apps. Strict JavaScript is an improved version of JavaScript. You can enable it by adding the line “use strict” at the top of any library or function. Strict JavaScript will prevent you from making many common mistakes in your code. The following lists some of the key restrictions enabled by strict JavaScript:
·         Cannot use a variable without declaring it
·         Cannot write to a read-only property
·         Cannot add properties to non-extensible objects
·         Cannot illegally delete functions and variables
·         Cannot define a property more than once in an object literal
·         Cannot use a parameter name more than once in a function
·         Cannot use reserved words, eval, or arguments, as names for functions and variables
·         The value of this in a function is no longer the window object
·         Cannot declare functions inside of statements
·         Cannot change the members of the arguments array
1.9               Function Declarations
·         All functions should be declared before they are used. Inner functions should follow the var statement. This helps make it clear what variables are included in its scope.
·         There should be no space between the name of a function and the ( (left parenthesis) of its parameter list. There should be one space between the ) (right parenthesis) and the { (left curly brace) that begins the statement body. The body itself is indented four spaces. The } (right curly brace) is aligned with the line containing the beginning of the declaration of the function.
    function outer(c, d) {
        var e = c * d;
        function inner(a, b) {
            return (e * a) + b;
        return inner(0, 1);
·         This convention works well with JavaScript because in JavaScript, functions and object literals can be placed anywhere that an expression is allowed. It provides the best readability with inline functions and complex structures.
    function getElementsByClassName(className) {
        var results = [];
        walkTheDOM(document.body, function (node) {
            var a;                  // array of class names
            var c = node.className; // the node's classname
            var i;                  // loop counter
// If the node has a class name, then split it into a list of simple names.
// If any of them match the requested name, then append the node to the set of results.
            if (c) {
                a = c.split(' ');
                for (i = 0; i < a.length; i += 1) {
                    if (a[i] === className) {
        return results;
·         If a function literal is anonymous, there should be one space between the word function and the ( (left parenthesis). If the space is omited, then it can appear that the function's name is function, which is an incorrect reading.
    div.onclick = function (e) {
        return false;
    that = {
        method: function () {
            return this.datum;
        datum: 0
·         Use of global functions should be minimized.
·         When a function is to be invoked immediately, the entire invocation expression should be wrapped in parens so that it is clear that the value being produced is the result of the function and not the function itself.
var collection = (function () {
    var keys = [], values = [];
    return {
        get: function (key) {
            var at = keys.indexOf(key);
            if (at >= 0) {
                return values[at];
        set: function (key, value) {
               var at = keys.indexOf(key);
               if (at < 0) {
                               at = keys.length;
                keys[at] = key;
                values[at] = value;
                                 remove: function (key) {
                var at = keys.indexOf(key);
                if (at >= 0) {
                                keys.splice(at, 1);
                               values.splice(at, 1);
1.10            Names
·         Names should be formed from the 26 upper and lower case letters (A .. Z, a .. z), the 10 digits (0 .. 9), and _ (underbar). Avoid use of international characters because they may not read well or be understood everywhere. Do not use $ (dollar sign) or \ (backslash) in names.
·         Most variables and functions should start with a lower case letter.
·         Constructor functions which must be used with the new prefix should start with a capital letter. JavaScript issues neither a compile-time warning nor a run-time warning if a required new is omitted. Bad things can happen if new is not used, so the capitalization convention is the only defense we have.
·         Global variables should be in all caps. (JavaScript does not have macros or constants, so there isn't much point in using all caps to signify features that JavaScript doesn't have.)
1.11            Statements
    Simple Statements
·         Each line should contain at most one statement. Put a ; (semicolon) at the end of every simple statement. Note that an assignment statement which is assigning a function literal or object literal is still an assignment statement and must end with a semicolon.
·         JavaScript allows any expression to be used as a statement. This can mask some errors, particularly in the presence of semicolon insertion. The only expressions that should be used as statements are assignments and invocations.
     Compound Statements
·         Compound statements are statements that contain lists of statements enclosed in { } (curly braces).
·         The enclosed statements should be indented four more spaces.
·         The { (left curly brace) should be at the end of the line that begins the compound statement.
·         The } (right curly brace) should begin a line and be indented to align with the beginning of the line containing the matching { (left curly brace).
·         Braces should be used around all statements, even single statements, when they are part of a control structure, such as an if or for statement. This makes it easier to add statements without accidentally introducing bugs.
·         Blank lines improve readability by setting off sections of code that are logically related.
·         Blank spaces should be used in the following circumstances:
·         A keyword followed by ( (left parenthesis) should be separated by a space.
while (true) {
·         A blank space should not be used between a function value and its ( (left parenthesis). This helps to distinguish between keywords and function invocations.
·         All binary operators except . (period) and ( (left parenthesis) and [ (left bracket) should be separated from their operands by a space.
·         No space should separate a unary operator and its operand except when the operator is a word such as typeof.
·         Each ; (semicolon) in the control part of a for statement should be followed with a space.
·         Whitespace should follow every , (comma).
1.12            for-in loops
These loops are to be used only for iterating over keys in an object/map/hash. They are often incorrectly used to loop over the elements in an Array. This is however very error prone because it does not loop from 0 to length - 1 but over all the present keys in the object and its prototype chain. Here are a few cases where it fails:

function printArray(arr) {

  for (var key in arr) {




printArray([0,1,2,3]);  // This works.

var a = new Array(10);

printArray(a);  // This is wrong.

a = document.getElementsByTagName('*');

printArray(a);  // This is wrong.

a = [0,1,2,3];

a.buhu = 'wine';

printArray(a);  // This is wrong again.

a = new Array;

a[3] = 3;

printArray(a);  // This is wrong again.
Always use normal for loops when using arrays.

function printArray(arr) {

  var l = arr.length;

  for (var i = 0; i < l; i++) {



1.13            Associative arrays
Array should never be used as a map/hash/associative array.  Associative Arrays are not allowed - more precisely you are not allowed to use non number indexes for arrays. If a map/hash is required Object should be used instead of Array since the features that are required are actually features of Object and not of ArrayArray just happens to extend Object (like any other object in JS and therefore you might as well have used DateRegExp or String).
1.14            Multi-line strings
Slashes should not be used:
var myString = 'A rather long string of English text, an error message \
                actually that just keeps going and going -- an error \
                message to make the Energizer bunny blush (right through \
                those Schwarzenegger shades)! Where was I? Oh yes, \
                you\'ve got an error and all the extraneous whitespace is \
                just gravy.  Have a nice day.';
The whitespace at the beginning of each line can't be safely stripped at compile time; whitespace after the slash will result in tricky errors; and while most script engines support this, it is not part of ECMAScript.
String concatenation should be used instead:
var myString = 'A rather long string of English text, an error message ' +
    'actually that just keeps going and going -- an error ' +
    'message to make the Energizer bunny blush (right through ' +
    'those Schwarzenegger shades)! Where was I? Oh yes, ' +
    'you\'ve got an error and all the extraneous whitespace is ' +
    'just gravy.  Have a nice day.';
1.15            Array & Object Literals
Array and Object literals should be used instead of Array and Object constructors.  Array constructors are error-prone due to their arguments.

// Length is 3.

var a1 = new Array(x1, x2, x3);

// Length is 2.

var a2 = new Array(x1, x2);

// If x1 is a number and it is a natural number the length will be x1.

// If x1 is a number but not a natural number this will throw an exception.

// Otherwise the array will have one element with x1 as its value.

var a3 = new Array(x1);

// Length is 0.

var a4 = new Array();
Because of this, if someone changes the code to pass 1 argument instead of 2 arguments, the array might not have the expected length.
To avoid these kinds of weird cases, the more readable array literal should always be used.

var a = [x1, x2, x3];

var a2 = [x1, x2];

var a3 = [x1];

var a4 = [];
Object constructors don't have the same problems, but for readability and consistency object literals should be used.

var o = new Object();

var o2 = new Object();

o2.a = 0;

o2.b = 1;

o2.c = 2;

o2['strange key'] = 3;
Should be written as:

var o = {};

var o2 = {

  a: 0,

  b: 1,

  c: 2,

  'strange key': 3


1.16            Method and property definitions
While there are several ways to attach methods and properties to an object created via new, the preferred style for methods is:

Foo.prototype.bar = function() {

  /* ... */

The preferred style for other properties is to initialize the field in the constructor:

/** @constructor */

function Foo() {

  this.bar = value;

1.17            Browser-specific code / IE hacks
Browser-specific javascript objects or functions should not be used.
var f = function () {
    /*@cc_on if (@_jscript) { return 2* @*/  3; /*@ } @*/
Conditional Comments hinder automated tools as they can vary the JavaScript syntax tree at runtime.
1.18            Javascript Tips & Tricks
True and False Boolean Expressions
The following are all false in boolean expressions:
·         null
·         undefined
·         '' the empty string
·         0 the number
But be careful, because these are all true:
·         '0' the string
·         [] the empty array
·         {} the empty object

                    This means that instead of this:

while (x != null) {
                 you can write this shorter code (as long as you don't expect x to be 0, or the 
                 empty string, or false):

while (x) {
                   And if you want to check a string to see if it is null or empty, you could do this:

if (y != null && y != '') {
                    But this is shorter and nicer:

if (y) {
                 Caution: There are many unintuitive things about boolean expressions. Here are 
                 some of them:
·         Boolean('0') == true
'0' != true
·         0 != null
0 == []
0 == false
·         Boolean(null) == false
null != true
null != false
·         Boolean(undefined) == false
undefined != true
undefined != false
·         Boolean([]) == true
[] != true
[] == false
·         Boolean({}) == true
{} != true
{} != false
                  Instead of this:

if (val) {

  return foo();

} else {

  return bar();


                  you can write this:

return val ? foo() : bar();
                 The ternary conditional is also useful when generating HTML:

var html = '<input type="checkbox"' +

    (isChecked ? ' checked' : '') +

    (isEnabled ? '' : ' disabled') +

    ' name="foo">';

&& and ||
These binary boolean operators are short-circuited, and evaluate to the last evaluated term.
"||" has been called the 'default' operator, because instead of writing this:

/** @param {*=} opt_win */

function foo(opt_win) {

  var win;

  if (opt_win) {

    win = opt_win;

  } else {

    win = window;


  // ...


                you can write this:

/** @param {*=} opt_win */

function foo(opt_win) {

  var win = opt_win || window;

  // ...


              "&&" is also useful for shortening code. For instance, instead of this:

if (node) {

  if (node.kids) {

    if (node.kids[index]) {





              this could be used:

if (node && node.kids && node.kids[index]) {



              or this:

var kid = node && node.kids && node.kids[index];

if (kid) {


Iterating over Node Lists
Node lists are often implemented as node iterators with a filter. This means that getting a property like length is O(n), and iterating over the list by re-checking the length will be O(n^2).

var paragraphs = document.getElementsByTagName('p');

for (var i = 0; i < paragraphs.length; i++) {


          It is better to do this instead:

var paragraphs = document.getElementsByTagName('p');

for (var i = 0, paragraph; paragraph = paragraphs[i]; i++) {


This works well for all collections and arrays as long as the array does not contain things that are treated as boolean false.
In cases of iterating over the childNodes, the firstChild and nextSibling properties can be used.

var parentNode = document.getElementById('foo');

for (var child = parentNode.firstChild; child; child = child.nextSibling) {


1.20            Other common suggestions
             {} and []
·         Use {} instead of new Object (). Use [] instead of new Array ().
·         Use arrays when the member names would be sequential integers. Use objects when the member names are arbitrary strings or names.
             , (comma) Operator
·         Avoid the use of the comma operator except for very disciplined use in the control part of for statements. (This does not apply to the comma separator, which is used in object literals, array literals, var statements, and parameter lists.)
             Block Scope
·         In JavaScript blocks do not have scope. Only functions have scope. Do not use blocks except as required by the compound statements.
             Assignment Expressions
·         Avoid doing assignments in the condition part of if and while statements.
if (a = b) {
a correct statement? Or was
  if (a == b) {
intended? Avoid constructs that cannot easily be determined to be correct.
=== and !== Operators.
·         It is almost always better to use the === and !== operators. The == and != operators do type coercion. In particular, do not use == to compare against falsy values.
             Confusing Pluses and Minuses
·         Be careful to not follow a + with + or ++. This pattern can be confusing. Insert parens between them to make your intention clear.
total = subtotal + +myInput.value;
is better written as
total = subtotal + (+myInput.value);
so that the + + is not misread as ++.
eval is Evil
·         The eval function is the most misused feature of JavaScript. Avoid it.
·         eval has aliases. Do not use the Function constructor. Do not pass strings to setTimeout or setInterval.
1.21            Exception Handling
             Error Objects
·         When an exception occurs, an object representing the error is created and thrown.  The JavaScript language defines seven types of built-in error objects.  These error types are the foundation for exception handling.  Each of the error types is described in detail below.
·         The “Error” type is used to represent generic exceptions.  This type of exception is most often used for implementing user defined exceptions.  ”Error” objects are instantiated by calling their constructor as shown in the following example.
var error = new Error("error message");
·         “Error” objects contain two properties, “name” and “message”.  The “name” property specifies the type of exception (in this case “Error”).  The “message” property provides a more detailed description of the exception.  The “message” gets its value from the string passed to the exception’s constructor.  The remaining exception types represent more specific types of errors, but they are all used in the same fashion as the generic “Error” type.
·         “RangeError” exceptions are generated by numbers that fall outside of a specified range.  For example, JavaScript numbers have a toFixed() method which takes a “digits” argument representing the number of digits to appear after a decimal point.  This argument is expected to be between 0 and 20 (although some browsers support a wider range).  If the value of “digits” is outside of this range, then a “RangeError” is thrown.  This scenario is shown in the following example.
var pi = 3.14159;
pi.toFixed(100000);  // RangeError
·         A “ReferenceError” exception is thrown when a non-existent variable is accessed.  These exceptions commonly occur when an existing variable name is misspelled.  In the example below, a “ReferenceError” occurs when “bar” is accessed.  Note that this example assumes that “bar” does not exist in any active scope when the increment operation is attempted.
function foo() {
bar++;  // ReferenceError
·         A “SyntaxError” is thrown when the rules of the JavaScript language are broken.  Developers who are familiar with languages such as C and Java are used to encountering syntax errors during the compilation process.  However, because JavaScript is an interpreted language, syntax errors are not identified until the code is executed.  Syntax errors are unique as they are the only type of exception that cannot be recovered from.  The following example generates a syntax error because the “if” statement is missing a closing curly brace.
if (foo) {  // SyntaxError
// the closing curly brace is missing
·         A “TypeError” exception occurs when a value is not of the expected type.  Attempting to call a non-existent object method is a common cause of this type of exception.  The following example creates an empty object named “foo” and then attempts to invoke its bar() method.  Since bar() is not defined, a “TypeError” is thrown upon the attempted invocation.
var foo = {};
foo.bar(); // TypeError
·         A “URIError” exception is thrown by methods such as encodeURI () and decodeURI () when they encounter a malformed URI.  The following example generates a “URIError” while attempting to decode the string “%”.  The “%” character represents the beginning of a URI escape sequence.  Since nothing follows the “%” in this example, the string is an invalid escape sequence, and therefore a malformed URI component.
decodeURIComponent ("%"); // URIError

·         “EvalError” exceptions are thrown when the eval() function is used improperly.  These exceptions are not used in the most recent version of the EcmaScript standard.  However, they are still supported in order to maintain backwards compatibility with older versions of the standard.
1.22            Handling Exceptions
·         Now that we know what exceptions are, it’s time to learn how to stop them from crashing our programs.  JavaScript handles exceptions via the “try…catch…finally” statement.  A generic example statement is shown below.
try {
// attempt to execute this code
} catch (exception) {
// this code handles exceptions
} finally {
// this code always gets executed
·         The first part of a “try…catch…finally” statement is the “try” clause.  The “try” clause is mandatory, and is used to delimit a block of code that the programmer suspects could generate an exception.  The “try” clause must be followed by one or both of the “catch” and “finally” clauses.
                   The “catch” Clause
·         The second part of “try…catch…finally” is the “catch” clause.  The “catch” clause is a block of code that is only executed if an exception occurs in the “try” clause.  Although the “catch” clause is optional, it isn’t possible to truly handle an exception without one.  This is because the “catch” clause stops the exception from propagating through the call stack, allowing the program to recover.  If an exception occurs within the “try” block, then control is immediately passed to the “catch” clause.  The exception that occurred is also passed to the “catch” block for processing.  The following example shows how a “catch” clause is used to handle a “ReferenceError”.  Note that the “ReferenceError” object is available in the “catch” clause via the “exception” variable.
try {
foo++;  // ReferenceError
} catch (exception) {
var message = exception.message;

 // handle the exception
·         Complex applications can generate a variety of exceptions.  In such cases, the “instanceof” operator can be used to differentiate between the various types of exceptions.  In the following example, assume that the “try” clause can generate several types of exceptions.  The corresponding “catch” clause uses “instanceof” to handle “TypeError” and “ReferenceError” exceptions separately from all other types of errors.
try {
// assume an exception occurs
} catch (exception) {
 if (exception instanceof TypeError) {
// Handle TypeError exceptions
 } else if (exception instanceof ReferenceError) {
 // Handle ReferenceError exceptions
} else {
 // Handle all other types of exceptions
             The “finally” Clause
·         The last component of the “try…catch…finally” statement is the optional “finally” clause.  The “finally” clause is a block of code that is executed after the “try” and “catch” clauses, regardless of any errors.  The “finally” clause is useful for including clean up code (closing files, etc.) that needs to be executed no matter what.  Note that the “finally” clause is even executed if an exception occurs that is not caught.  In such a scenario, the “finally” clause is executed and then the thrown exception proceeds normally.
·         One interesting note about the “finally” clause is that it will be executed even if the “try” or “catch” clause executes a “return” statement.  For example, the following function returns false because the “finally” clause is the last thing to execute.
function foo() {
 try {
 return true;
 } finally {
return false;
         Throwing Exceptions
·         JavaScript allows programmers to throw their own exceptions via the appropriately named “throw” statement.  This concept can be somewhat confusing to inexperienced developers.  After all, developers strive to write code that is free of errors, yet the “throw” statement intentionally introduces them.  However, intentionally throwing exceptions can actually lead to code that is easier to debug and maintain.  For example, by creating meaningful error messages it becomes easier to identify and resolve problems.
·         Several examples of the “throw” statement are shown below.  There is no restriction on the type of data that can be thrown as an exception.  There is also no limit on the number of times that the same data can be caught and thrown.  In other words, an exception can be thrown, caught, and then thrown again.
throw true;
throw 5;
throw "error message";
throw null;
throw undefined;
throw {};
throw new SyntaxError("useful error message");
·         While the “throw” statement can be used with any data type, there are certain benefits to using the built-in exception types.  Firefox, for example, gives special treatment to those objects by adding debugging information such as the filename and line number where the exception occurred.
·         As an example scenario, assume that a division operation occurs somewhere in your application.  Division can be a nuisance because of the possibility of division by zero.  In JavaScript, such an operation results in “NaN”.  This can lead to confusing results that are tricky to debug.  Things would be much simpler if the application complained loudly about the division by zero.  The following “if” statement accomplishes this for us by throwing an exception.
if (denominator === 0)
  throw new Error("Attempted division by zero!");
Of course, it might be more appropriate to use a “RangeError” as shown below.
if (denominator === 0)
  throw new RangeError("Attempted division by zero!");
Custom Exception Objects
·         We’ve just learned how to generate customized error messages using the built-in exception types.  However, another approach is to create new exception types by extending the existing “Error” type.  Because the new type inherits from “Error”, it can be used like the other built-in exception types.  While the topic of inheritance in JavaScript is beyond the scope of this article, a simple technique is covered here.
·         The following example returns to the problem of dealing with division by zero.  Instead of using an “Error” or “RangeError” object as we did earlier, we are going to create our own type of exception.  In this example, we are creating the “DivisionByZeroError” exception type.  The function in the example acts as the constructor for our new type.  The constructor takes care of assigning the “name” and “message” properties.  The final two lines of the example cause the new type to inherit from the “Error” object.
function DivisionByZeroError(message) {
  this.name = "DivisionByZeroError";
  this.message = (message || "");
DivisionByZeroError.prototype = new Error();
DivisionByZeroError.prototype.constructor = DivisionByZeroError;
·         The power of jQuery, however, lies in the fact that the selector syntax is identical to that used in cascading style sheets (CSS). This means that you can use a rich, familiar selector syntax to reference any part of the DOM, which becomes a powerful and efficient way to manipulate the DOM elements.
·         Once you have selected DOM elements, you will want to manipulate them. This is where jQuery methods come into play. The jQuery library has a tremendous number of methods that perform all kinds of useful DOM manipulations. These manipulations are always performed on the collection of elements returned from the jQuery global function.
·         jQuery supports many methods for manipulating DOM elements beyond what is shown in Table 2-3. The complete reference of supported methods is available at http://api.jquery.com/category/manipulation. Furthermore, jQuery methods can be chained together so that you can perform several operations in a single line of code. The following code changes the inner HTML of an element, adds a class, and then displays the result, all in a single line:

Happy programming....


No comments:

Post a Comment