Javascript Guide: Basics of JS
Tags: javascript, webdev, programming, beginners
Published: 2023-01-20 13:04:53

Welcome 🙏 to the world of JavaScript, the backbone of the interactive web. From simple button clicks to complex web applications, JavaScript brings websites to life. In this blog post, we will explore the basics of JavaScript and learn how to use it to create interactive and dynamic websites. From variables and data types to control flow statements, functions, and arrays, we will cover it all. Get ready to learn how to make your websites come alive with JavaScript!

### 1\. Understanding the basics of variables and data types in JavaScript

JavaScript uses variables and data types as the building blocks for storing and manipulating information. Imagine variables as labeled boxes that can hold different types of values, while data types are the labels on those boxes indicating what kind of value they can hold.

JavaScript has several built-in data types to choose from, like:

<table><tbody><tr><td colspan="1" rowspan="1"><p><strong>Data Types</strong></p></td><td colspan="1" rowspan="1"><p><strong>Description</strong></p></td><td colspan="1" rowspan="1"><p><strong>Example</strong></p></td></tr><tr><td colspan="1" rowspan="1"><p><code>String</code></p></td><td colspan="1" rowspan="1"><p>represents textual data</p></td><td colspan="1" rowspan="1"><p><code>'hello'</code>, <code>"hello world!"</code> etc.</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>Number</code></p></td><td colspan="1" rowspan="1"><p>an integer or a floating-point number</p></td><td colspan="1" rowspan="1"><p><code>3</code>, <code>3.234</code>, <code>3e-2</code> etc.</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>BigInt</code></p></td><td colspan="1" rowspan="1"><p>an integer with arbitrary precision</p></td><td colspan="1" rowspan="1"><p><code>900719925124740999n</code> , <code>1n</code> etc.</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>Boolean</code></p></td><td colspan="1" rowspan="1"><p>Any of two values: true or false</p></td><td colspan="1" rowspan="1"><p><code>true</code> and <code>false</code></p></td></tr><tr><td colspan="1" rowspan="1"><p><code>undefined</code></p></td><td colspan="1" rowspan="1"><p>a data type whose variable is not initialized</p></td><td colspan="1" rowspan="1"><p><code>let a;</code></p></td></tr><tr><td colspan="1" rowspan="1"><p><code>null</code></p></td><td colspan="1" rowspan="1"><p>denotes a <code>null</code> value</p></td><td colspan="1" rowspan="1"><p><code>let a = null;</code></p></td></tr><tr><td colspan="1" rowspan="1"><p><code>Symbol</code></p></td><td colspan="1" rowspan="1"><p>data type whose instances are unique and immutable</p></td><td colspan="1" rowspan="1"><p><code>let value = Symbol('hello');</code></p></td></tr><tr><td colspan="1" rowspan="1"><p><code>Object</code></p></td><td colspan="1" rowspan="1"><p>key-value pairs of collection of data</p></td><td colspan="1" rowspan="1"><p><code>let student = { };</code></p></td></tr></tbody></table>

Here, all data types except `Object` are primitive data types, whereas `Object` is non-primitive.

> **Note:** The `Object` data type (non-primitive type) can store collections of data, whereas primitive data type can only store a single data.

To declare a variable in JavaScript, you use the `var`, `let`, or `const` keyword, followed by the variable name. For example:

```javascript
let name = "John";
const pi = 3.14;
var age;
```

In the example above, `name` is a variable that stores a string value "John", `pi` is a variable that stores a numeric value of 3.14, and `age` is a variable that has been declared but not assigned a value, so it will have an undefined value.

You can also use the `typeof` operator to check the data type of a variable.

```javascript
console.log(typeof name); // prints "string"
console.log(typeof pi); // prints "number"
console.log(typeof age); // prints "undefined"
```

It's important to keep in mind that JavaScript is a loosely typed language, which means that you don't have to specify the data type when declaring a variable. The data type is determined by the value that is assigned to the variable.

For example, the following code assigns a number to the variable `x`, but later reassigns it to a string:

```javascript
let x = 10;
console.log(typeof x); // prints "number"

x = "hello";
console.log(typeof x); // prints "string"
```

It's also important to use meaningful variable names, so it's easy to understand what the variable holds, it will help you and other developers who will read your code in the future.

### 2\. How to use control flow statements (if/else, for loops, while loops)

Control flow statements are used to control the flow of execution in a program. In JavaScript, the three main types of control flow statements are if/else, for loops, and while loops.

**If/Else Statement**: The if/else statement is used to test a condition and execute a block of code if the condition is true. If the condition is false, another block of code can be executed using the else statement.

Example:

```javascript
let x = 10;
if(x > 5){
    console.log("x is greater than 5");
} else {
    console.log("x is less than or equal to 5");
}
```

Output: *"x is greater than 5"*

**For Loop**: The for loop is used to execute a block of code a certain number of times. It consists of a loop variable, a stopping condition, and a way to update the loop variable at the end of each iteration.

Example:

```javascript
for(let i = 0; i < 5; i++){
    console.log(i);
}
```

Output: *0 1 2 3 4*

**While Loop**: The while loop is used to execute a block of code as long as a certain condition is true. It consists of a stopping condition and a way to update the loop variable at the end of each iteration.

Example:

```javascript
let i = 0;
while(i < 5){
    console.log(i);
    i++;
}
```

Output: *0 1 2 3 4*

In JavaScript, control flow statements are essential tools for creating dynamic and interactive web pages and are a fundamental part of programming in JavaScript.

### 3\. Understanding functions and how to create, call and pass them as arguments

In JavaScript, functions are a way to group a set of statements to perform a specific task. Functions are declared using the "function" keyword followed by the function name, a set of parentheses, and a pair of curly braces. The statements inside the curly braces are the body of the function.

**Creating a Function**:

```javascript
function greet() {
    console.log("Hello, World!");
}
```

Another way to create a function in JavaScript is by using an arrow function. An arrow function is a shorthand for a regular function expression and uses the "fat arrow" (=&gt;) syntax.

Here's an example of how to create an arrow function that takes in a parameter, multiplies it by 2, and returns the result:

```javascript
let double = (num) => {
  return num * 2;
}
console.log(double(5)); //output: 10
```

In this example, the function `double` takes in a single parameter `num` and then returns the result of `num * 2`. The function is invoked by passing an argument of 5 to it which is then passed as a parameter `num` and the result is logged which is 10.

You can also make the function more concise by omitting the curly braces and the `return` keyword if the function only has one line of code like this:

```javascript
let double = num => num * 2;
console.log(double(5)); //output: 10
```

It's not only shorter to write but also easier to read, making it a popular choice among developers.

You can also use the arrow function as a callback function like this:

```javascript
let nums = [1, 2, 3, 4, 5];
nums.forEach(num => console.log(num*2));
```

In this example, the arrow function `num => console.log(num*2)` is passed as a callback to the `forEach()` method, which is used to iterate over an array. The function is executed for each element in the array, multiplying it by 2 and then logging the result to the console.

It is to be noted that, arrow functions do not have their own `this` keyword, they inherit it from the surrounding context so it's important to keep it in mind while using it in certain situations.

**Calling a Function**: To call a function, simply use the function name followed by a set of parentheses.

Example:

```javascript
greet();
```

Output: *"Hello, World!"*

**Passing Arguments**: Functions can also accept arguments, which are values that are passed into the function when it is called. Arguments are defined within the parentheses of the function declaration and are separated by commas.

Example:

```javascript
function greet(name) {
    console.log("Hello, " + name + "!");
}
```

Here, the function "greet" takes an argument "name" and prints "Hello, name!".

Function Arguments can be passed by calling the function and providing the values for the arguments within the parentheses.

Example:

```javascript
greet("John");
```

Output: *"Hello, John!"*

Functions can also return values using the "return" keyword. This allows you to pass the result of a function to a variable or use it in another function.

Example:

```javascript
function add(a, b) {
    return a + b;
}
let result = add(2, 3);
console.log(result);
```

Output: *5*

In JavaScript, functions are a powerful tool that allows you to organize and reuse code, making it more readable and maintainable. Understanding how to create, call and pass functions as arguments is a fundamental part of programming in JavaScript.

### 4\. An introduction to arrays and how to manipulate them using built-in methods

In JavaScript, an array is a collection of values that are stored in a single variable. Arrays are defined using square brackets and each value is separated by a comma.

**Creating an Array**:

```javascript
let fruits = ["apple", "banana", "orange"];
```

**Accessing Elements**: You can access an element of an array by using the index number in square brackets. The index of the first element is 0, the second element is 1, and so on.

Example:

```javascript
console.log(fruits[0]);
```

Output: *"apple"*

**Manipulating Arrays**: JavaScript provides several built-in methods for manipulating arrays, such as .push() to add an element to the end of an array, .pop() to remove the last element from an array, .shift() to remove the first element from an array, and .unshift() to add an element to the beginning of an array.

Example:

```javascript
fruits.push("mango"); // add "mango" to the end of the array
console.log(fruits);
fruits.pop(); // remove the last element of the array
console.log(fruits);
fruits.unshift("kiwi"); // add "kiwi" to the beginning of the array
console.log(fruits);
fruits.shift(); // remove the first element of the array
console.log(fruits);
```

Output: *\["apple", "banana", "orange", "mango"\] \["apple", "banana", "orange"\] \["kiwi", "apple", "banana", "orange"\] \["apple", "banana", "orange"\]*

Other methods like `.slice()`, `.splice()`, and `.concat()` can also be used for manipulating arrays.

Example:

```javascript
let vegetables = ["potato", "carrot", "onion"];
let allItems = fruits.concat(vegetables); // combine two arrays
console.log(allItems);
let subItems = allItems.slice(1, 3); // extract elements from index 1 to 3
console.log(subItems);
allItems.splice(1, 2, "tomato", "cucumber"); // remove 2 elements from index 1 and add "tomato" and "cucumber"
console.log(allItems);
```

Output: *\["apple", "banana", "orange", "potato", "carrot", "onion"\] \["banana", "orange"\] \["apple", "tomato", "cucumber", "potato", "carrot", "onion"\]*

Arrays are a fundamental data structure in JavaScript and the built-in methods make it easy to manipulate and modify arrays. Understanding how to create and manipulate arrays using these built-in methods is an essential part of programming in JavaScript.

### 5\. Understanding JavaScript's built-in objects (Math, Date, String, etc.)

JavaScript has several built-in objects that can be used to perform common tasks, such as mathematical calculations, date and time manipulation, and string manipulation. In this blog post, we will take a closer look at some of these built-in objects and provide examples of how to use them in your code.

The Math object is a built-in object that provides mathematical constants and functions. For example, you can use the `Math.PI` constant to get the value of pi and the `Math.round()` function to round a number to the nearest integer. Here's an example of how to use the Math object to calculate the area of a circle:

```javascript
let radius = 5;
let area = Math.PI * Math.pow(radius, 2);
console.log(area); // 78.53981633974483
```

The Date object is another built-in object that can be used to work with date and time values. You can create a new date object by calling the `Date()` constructor, and then use various methods to retrieve or manipulate the date and time values. For example, you can use the `getFullYear()` method to get the current year and the `setFullYear()` method to set the year. Here's an example of how to use the Date object to get the current date and time:

```javascript
let now = new Date();
console.log(now); // Wed Jan 19 2022 16:35:20 GMT+0530 (India Standard Time)
```

The String object is a built-in object that provides various methods for working with strings. For example, you can use the `length` property to get the number of characters in a string, and the `toUpperCase()` method to convert a string to uppercase. Here's an example of how to use the String object to convert a string to uppercase:

```javascript
let message = "Hello, World!";
let upperCaseMessage = message.toUpperCase();
console.log(upperCaseMessage); // "HELLO, WORLD!"
```

These are just a few examples of how to use some of JavaScript's built-in objects. There are many more objects and methods available, and by mastering them, you can write more efficient and effective code.

### 6\. DOM manipulation: Adding and removing elements from a webpage and handling events

The Document Object Model (DOM) is a programming interface for HTML and XML documents. It allows developers to manipulate the structure and content of a webpage using JavaScript. In this blog post, we will take a closer look at how to manipulate the DOM by adding and removing elements from a webpage and handling events.

To add an element to a webpage, you can use the `createElement()` method to create a new element and the `appendChild()` method to add it to an existing element. For example, you can use the following code to create a new `<p>` element with the text "Hello, World!" and add it to the `<body>` element:

```javascript
let newP = document.createElement("p");
let newPContent = document.createTextNode("Hello, World!");
newP.appendChild(newPContent);
document.body.appendChild(newP);
```

To remove an element from a webpage, you can use the `removeChild()` method to remove it from its parent element, or the `remove()` method to remove it from the DOM entirely. Here's an example of how to remove the first `<p>` element from the `<body>` element:

```javascript
let firstP = document.body.getElementsByTagName("p")[0];
document.body.removeChild(firstP);
```

JavaScript also provides a way to handle events, such as clicks, hover, key presses, etc. You can use the `addEventListener()` method to attach an event handler to an element, and the `removeEventListener()` method to remove it. Here's an example of how to handle a click event on a button element:

```javascript
let btn = document.getElementById("myBtn");
btn.addEventListener("click", function(){
    alert("Button clicked");
});
```

These are just a few examples of how to use JavaScript to manipulate the DOM. By understanding the basics of adding and removing elements, and handling events, you can create dynamic and interactive web pages. With the help of DOM manipulation, you can make the web page more responsive, without the need for refreshing the page.

### 7\. Understanding the basics of JavaScript's object-oriented programming concepts (constructors, prototypes, etc)

JavaScript is a versatile programming language that supports several programming paradigms, including object-oriented programming (OOP). OOP is a programming methodology that allows developers to model real-world objects and their interactions with each other. In this blog post, we will take a closer look at some of the basics of JavaScript's OOP concepts and provide examples of how to use them in your code.

One of the key concepts in OOP is the constructor, which is a special method that is used to create and initialize an object. A constructor is defined using the "constructor" keyword, and it is automatically called when a new object is created using the "new" keyword. Here's an example of how to define a constructor for a "Person" object:

```javascript
function Person(name, age) {
  this.name = name;
  this.age = age;
}

let person1 = new Person("John", 30);
console.log(person1.name); // "John"
console.log(person1.age); // 30
```

Another important concept in OOP is the prototype, which is an object that is shared among all instances of a given constructor. The prototype allows you to add methods and properties to an object, without having to define them inside the constructor. Here's an example of how to add a method to the "Person" object using the prototype:

```javascript
Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

person1.sayHello(); // "Hello, my name is John"
```

JavaScript also provides a way to define classes, which is a more modern way to create objects and constructors.

```javascript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

let person1 = new Person("John", 30);
console.log(person1.name); // "John"
console.log(person1.age); // 30
person1.sayHello(); // "Hello, my name is John"
```

These are just a few examples of how to use some of JavaScript's OOP concepts. By understanding the basics of constructors, prototypes, and classes, you can write more organized and maintainable code, and model real-world objects and their interactions with each other in a more efficient way.

### 8\. Debugging and troubleshooting techniques

Debugging and troubleshooting are essential skills for any developer. They allow you to identify and fix errors in your code, so you can ensure that your program works as expected. In this blog post, we will take a closer look at some of the most common debugging and troubleshooting techniques and provide examples of how to use them in your code.

One of the most basic debugging techniques is the use of `console.log()` statements. This method allows you to print out the value of a variable, or the result of an expression, to the browser's console. For example, you can use the following code to print out the value of a variable named `myVar`:

```javascript
console.log(myVar);
```

Another useful debugging technique is the use of the browser's developer tools. Most modern web browsers have built-in developer tools that allow you to inspect and debug your code, including the ability to set breakpoints and step through your code line by line. For example, in Chrome, you can use `F12` and in Firefox you can use `Ctrl + Shift + I` to open the developer tools.

A useful troubleshooting technique is the use of a `try-catch` block. This method allows you to handle errors in your code by specifying a block of code to be executed when an error occurs. For example, you can use the following code to handle an error that occurs when trying to access an array element that does not exist:

```javascript
try {
   console.log(myArray[5]);
} catch (error) {
   console.log(error);
}
```

Another technique that can be used to troubleshoot issues is using the `debugger` statement. It's a JavaScript statement that stops the execution of JavaScript, and calls (if available) the debugging function. When the execution of JavaScript is stopped at a breakpoint, the code execution is paused, and you can inspect the call stack, variables, and source code in the browser's developer tools.

```javascript
function myFunction() {
   let x = 5;
   let y = 10;
   debugger;
   let result = x * y;
   return result;
}
```

These are just a few examples of debugging and troubleshooting techniques. By understanding and mastering these techniques, you can quickly and efficiently identify and fix errors in your code, and ensure that your program works as expected.

### Conclusion

JavaScript is the backbone of the modern web, enabling developers to create dynamic and interactive experiences for users. From manipulating the Document Object Model (DOM) to implementing object-oriented concepts, this powerful language offers endless possibilities for building engaging and responsive websites. But, the true beauty of JavaScript lies in its versatility. Not only is it a fundamental building block for web development, but it also powers a wide range of applications and technologies, from server-side programming to mobile app development.

As you delve deeper into the world of JavaScript, you'll discover that it's a never-ending journey of learning and experimentation. From mastering built-in objects and debugging techniques to exploring advanced frameworks and libraries, there's always something new to discover and conquer. But, with each concept and technique you master, you'll be able to write more efficient and effective code and build increasingly complex and sophisticated applications.

So, whether you're a beginner just starting or an experienced developer looking to expand your skills, JavaScript offers a thrilling and rewarding experience. With its endless possibilities, it's a language that will keep you on your toes and constantly pushing the boundaries of what's possible on the web.