Basics of JavaScript 1

** Basics of JavaScript**

JavaScript’s official name is ECMAScript.

JavaScript → The Programming Language (Trademark held by Sun which now is Oracle)

ECMAScript → The name used by the language specification. JavaScript is the name of the actual implementation that runs in browsers and environments like Node.js

Statements vs Expressions
Statements perform action. A program is a sequence of statements. E.g. var x;

Expressions produce a result value. They can be function arguments, assigned to variable, etc. E.g. 5*7

if-else as a statement :

var a;
if (b > 0) {
    a = 0;
}
else {
    b = 10;
}

as a expression :

var a = b > 0 ? 0 : 10;

The latter (ternary operator) can be used as a function argument since it always produces a value, unlike the former (traditional if-else), which does not.

Expression Statement : An expression used where a statement is being expected. The expression will be calculated but the result will be omitted. Used when the purpose is related to fulfil something else rather then getting a value.

E.g.

var x = 10;

function f(){
    x = 20;
    return x;
}

f(); // standalone statement

Explanation : Remember one thing that function calls are always expressions in JavaScript. So here the function call f() is an expression. The side effect of the function call i.e. changing the value of x to 20 occurs. The result of the expression f() is discarded, but the function's purpose is still achieved (changing the value of x).

Note : Functions in JS always return a value with no exception. If there is no return statement or the function does not return a value, in both cases, the function will return undefined.

var x = 10;

function f(){
    x = 20;
    return;
}

var result = f();
console.log(result); // will give undefined

Semicolons

Semicolons in JS are optional but it is always recommended to include them because the ASI (Automatic Semicolon Insertion) in JavaScript can sometimes guess wrong about the statement’s end. I will discuss about the ambiguous cases of ASI in future article.

Variables & Assignment

// Declaring a variable
var x;

// Declaring a variable and assigning a value at the same time
var x = 10;

// Assigning value to existing variables
x = 20;

// Compound Assignment Operators
x += 1;

Identifiers

Identifiers are names (sequence of characters) used to identify a variable, function or property.

Rule :  The first character of an identifier can be any Unicode letter, a dollar sign ($), or an underscore (_). Subsequent characters can additionally be any Unicode digit.

The reserve words cannot be used as identifiers. You can check the full list of reserved words in JavaScript here.

Infinity, NaN, undefined : They are not keywords but we must treat them as if they were.

Values

JavaScript just like other programming languages has many data types: booleans, numbers, strings, arrays, etc. All of these values have properties. These properties are in the form of key-value pairs. You can use the dot (.) operator to access properties of objects.

value.propertyKey

For e.g. length property of string

var a;
if (b > 0) {
    a = 0;
}
else {
    b = 10;
}

The dot operator can is also used to assign a value to a property.

var a = b > 0 ? 0 : 10;

It can also be used to invoke methods. One such example of a built-in string method:

var x = 10;

function f(){
    x = 20;
    return x;
}

f(); // standalone statement

Primitive Values vs Objects

In JavaScript, there is a specific distinction between the primitive values and the objects.

Each object is compared by reference and is strictly equal to itself.

E.g.

var x = 10;

function f(){
    x = 20;
    return;
}

var result = f();
console.log(result); // will give undefined

This is opposite to the nature of primitive values:

// Declaring a variable
var x;

// Declaring a variable and assigning a value at the same time
var x = 10;

// Assigning value to existing variables
x = 20;

// Compound Assignment Operators
x += 1;

Primitive Values : booleans, numbers, strings, undefined and null.

Characteristics of primitive values:

• 1. The value(content) matters.

var str = "Sahil"
console.log (str.length); // 5

// can also be calculated as 'Sahil'.length()

• 2. Their properties are immutable

var bike = {};
bike.cc = 200;

console.log(bike.cc); // 200

Accessing a property which does not exists will return undefined

'SAHIL'.toLowerCase()

*Objects *

All the non primitive values are considered objects in JavaScript.

• 1. Plain Objects : Simple objects made using curly braces. E.g.

var bike = {};
var car = {};
console.log (bike === car); // false

• 2. Arrays : Arrays help us in storing in collection of multiple items under a single variable name. E.g.

var a = 20;
var b = 20;
console.log(a === b); // true

• 3. **Regular Expressions : **I will make a separate article on this. For now you can refer here to know more about Regular Expressions.

Characteristics of Objects

• 1. They are compared by reference rather than by value which they hold.

> 1 === 1
true

• 2. Mutable properties

> var st = “sahil”
> str.length()
5

The above is the detailed content of Basics of JavaScript 1. For more information, please follow other related articles on the PHP Chinese website!