Forem: Levon Yedigaryan

Functions in JavaScript

Levon Yedigaryan — Wed, 09 Nov 2022 18:13:41 +0000

In JavaScript, there is something called functions. In this post, I will explain what that "thing" does, how to use it, and why we need it.

What are Functions?

Functions are separate pieces of code inside the code used to do some operations. Functions are often used to avoid unnecessary repetitions inside the code.

For example, if we want to do some complicated mathematical computations 100 times, we don't have to write the code 100 times. In this case, all we need is 1 function that will contain the long code; after that, we simply use that function as many times as we wish.

How to Declare a Function?

To declare a function in JavaScript, we have to write.

function Name of the function (variables or parameters which are passed to the function)
{
The code which the function will
execute
}

For Example

function sum(a, b)
{
console.log(a+b)
}

Don't worry. I am going to explain what each of these means.

Variables or Parameters of the Function

The function might use parameters both from its scope and global scope. Still, whenever there are 2 variables with the same name in the function and in the global scope, the function will take the value of the one inside itself (for more about scopes and variables, check my post about variables).

So the function will recognize the variable declared outside of its body if and only if there is no other variable inside it with the same name.

Functions may receive some values from the outside (These are the values we put inside the () when we declare the function)

function sum(a, b)
{
console.log(a+b)
}

This means that whenever we use the function, we will give it 2 values which, inside the function, will be named a and b. So after this, it will know their values whenever the function finds a or b inside of itself.

So, How do We Use the Functions?

Programmers often use another term for "use"; instead, they say "call the function." Simply declaring the function is not enough; we must call it at some point. To do it, we write the function's name, put (), and, if the function requires, inside () write the values we want to pass to the function.

function sum(a, b)
{
console.log(a+b)
}
sum(5,6)

This will print 11.

From now on, we can call the function as many times as we wish, with any variables we want to.

function sum(a, b)
{
console.log(a+b)
}
sum(5,6)
sum(5,5)
sum(9,4)
sum(10,150)
sum(0,1)

This will print
11
10
13
160
1

Return

Some functions may return the values, but what does that mean?

Before understanding this, we must learn that functions can also be assigned to variables. If we Write

function sum(a, b)
{
debug.log(a+b)
}
var c = sum(5,6)

The function sum() will be called as c is declared, and c will get the value of sum(). The problem is that c is not equal to 11, as the function only prints the sum but does not send its value to the variable c. To send the value, we use return. When we write

return The value we want to send

Inside the function, it will send the value to the variable to which the function was assigned to.

function sum(a, b)
{
return a+b
}
var c = sum(5,6)
//Now c is 11

Note that after reaching the line with the return, the function stops until being called once again.

I hope you enjoyed this post, and I wish you good luck in your programming job ;)

Variables in JavaScript

Levon Yedigaryan — Wed, 09 Nov 2022 16:58:19 +0000

Before touching the point of variables in JavaScript, firstly, we must understand what variables are and why we need them.

Variables

The term variable comes from the Latin verb variable, which means to change. So this describes exactly what variables are; they are something that changes.

Variables in JavaScript

In javascript, as in every programming language, there are variables. While writing the code, sometimes we need to use some values or data throughout it and, from time to time, change them or do operations with them. These values and data are stored in variables which are like containers for the data.

JavaScript can understand many types of data, like numbers, texts (in programming languages are often called strings), boolean values (true or false), objects, and more. In this post, I will talk about numbers, strings, and boolean values, which are the most basic ones.

But before we proceed to the topic of the types of data, we have to understand how to create a variable in JavaScript.

To create a variable, we have to declare it, give it a name, and put inside it the data we want to preserve. In JavaScript, it is written like this.

var/let/const (The name you want to give) = (The value of the variable)

For example

var age = 15
let speed = 24
const length = 120

Declaration of Variables (let/var/const)

One might ask what var/let or char mean and the difference between them. Let, and var are basically the same; only let was introduced after var, so it fixed many problems var had. Nowadays, var is rarely used. When we declare a variable using var or let, JavaScript creates the variable, which, later in the code, it might be changed or mutated. A mutation is a process during which the variable changes its type. For example, it was a number, but after that, it became a string, and here is where the difference between var/let and const becomes obvious. When we declare the variable using const, it can never change its value. If it was, for example, 5, it would be born as 5, live as 5, and then die as 5.

The name of the variables

After declaring the variable using let/var/const, one has to give a name to it so that later, it would be easier to address the exact variable one needs (in one code, there may be hundreds of variables). The naming of the variables must meet the following 5 basic rules.

- Names can contain letters, digits, underscores, and dollar signs.
- Names must begin with a letter.
- Names can also begin with $ and _
- Names are case sensitive (x and X are different variables).
- Reserved words (like JavaScript keywords) cannot be used as names.

Examples of names

let price = 5
var kzdsjkbgssljk = 15 (legal but not recommended)

A Piece of Useful Advice

Try to use such names to hint at what sort of data is inside them.

The Values of Variables

As I previously mentioned, I will discuss 3 basic and most essential data types that variables can hold.

Numbers
Texts/strings
Boolean values

1) Numbers

In JavaScript, we can assign numbers to variables such that

var a = 1
var b = 2.5
var c = 15

In the example above, a and c are integers, and b is a float number. JavaScript allows mathematical operations on variables, so if we have 2 variables which are numbers, we can add them, multiply, subtract, divide, and perform other operations.

var a = 2
var b = 5
var c = a+b

In the example above, c would be 2+5, which is 7.

var a = 5
var b = 15
var c = a*b

c will be 75.
_
Note that JavaScript obeys all mathematical rules, so in the first place, it will do what is inside the parenthesis, then multiplication, division, and power operations, and only after that, addition and subtraction. _

Also note that if we add 2 numbers, one of which is an integer and the other a float number, JavaScript will return the result as a float number.

2) Strings

In JavaScript, we write strings in brackets like "" or '' both are equally true, and it depends solely on the text itself which kind of brackets would be better to use in this case.

var a = "kakadu"
var b = 'Sparrow'
var c = "ALbert Einstein said 'Hello'"

In the case of c, it was better to use "" because the text contained '' brackets, so JavaScript would not confuse them.

In JavaScript, strings can contain everything literally.

var a = "kfjbvnm jdfv 56864569+t28*23rui34g7y89-h237089gt 39=bgvb vfribvdfbui189-g1239- /c xzs\mBVY"

This is also a legit string, although a rather stupid one.

3) Boolean values

In JavaScript, there are values called boolean. If one is familiar with Boolean arithmetics, these values are either true or false and are mainly used for writing a condition (I am not going to discuss them in this post as it is an entirely different topic).

var AreThereCookiesLeft = False
var AreYouDrunk = True

Something More

In JavaScript, after declaring the variables one time, we can not redeclare them again; that will throw an error. All we have to do after declaring them is to use them in the code. Variables, if not const, can be reassigned so strings might become numbers, booleans become strings, etc.
To reassign the value of a variable, we have to write the name of the variable, then put =, and then write the new value.

Note that the new value might also be in the form of mathematical operations or even include other variables.

var a = 5
a = "No 5 anymore"

Now a is "No 5 anymore"

var b = 15
b = b + 1

Now b is 16.

var c = 50
var d = 100
d = c*2 + d - 12

Now d is 188.

Scopes

In JavaScript, scopes are the areas where the given variable is accessible or visible. In JavaScript, there are 3 types of scopes.

Block scope
Function scope
Global scope

1) Block scope

Variables in the blocks (Inside {}) are inside Block Scopes and are accessible only inside that same block.

{
var a = 56
//a is accesible here
}
//a is not accessible here

2) Function scope

Every function creates its function scope. Variables declared inside it will be born inside the function, never leave it and die in that exact function. They are not accessible outside the given function.

function a()
{
var k=0
//k is accesible here
}
//k is not accesible here

Note that if there are 2 variables with the same name, declared using let, one of which is inside the function and the other one outside, the function will prioritize the one inside of him. Also, here is where one of the problems with var comes in. If we declare 2 variables with the same name, one inside the function and the other one outside of it, it will throw an error..

3) Global scope

Variables in the global scope are accessible everywhere inside the code.

var a = "hello"
//a is accessible here
function createK()
{
var k = "K is created"
//a is accesible here
}
//a is accessible here

I hope you find this post helpful and wish you good luck in programming ;)

Binary Numbers

Levon Yedigaryan — Thu, 15 Sep 2022 19:40:51 +0000

By Levon Yedigaryan

What are binary numbers?

These are numbers which as every other number are used to represent an amount. These numbers are used in computers due to the peculiarities of the comupter's organisation.

How do Binary numbers work?

in everyday life people often use decimal system of representation of numbers because it is the method people got used to from the early life. Decimal system is a system where the basis is the number 10, which means that in decimal numbers every digit shows the amount of certain powers of 10 according to their position. If we look at a digit in a number, it shows the maximum amount of 10s in the power of n in the number where n is the position of the digit if we start counting from left to right starting with 0.
To better understand this here is an example with the number 35468991.

The same principle is true with binary numbers. Here every digit shows the amount of 2s in the power of n in the number. In binary systems the only digits are 1s and 0s. For illustration here is an example of number 10110011 in binary system which is then represented in decimal system.

So the transmission from binary to decimals is clear. No lets talk about transmission from decimals to binary. To convert decimal numbers into binary we have to divide the number by 2 and write down the remainders until the quotient becomes 0 and then we have to rewrite the remainders in the reverse order. here is an example with the convertion of number 54 in decimals.

How to add binary numbers?

The principle of addition of binary numbers is exactly the same as the for the decimals. We start from the digit at the very right and then go to the left. In case when we get 1+1 in binary it is 10 but as be can not write 10 as one gidit we write only 0 and then carry 1 part to the left. For a better visualization here is an example of an addition of 2 binary numbers.

How to multiply binary numbers?

The principle of multiplication is completely the same as with decimal numbers. We multiply one by one the digits from the lower factor each time writing the product one digit to the left and then summing all the product together. here is an example.

These were the sum and the multiplication of binary numbers. With this information one can easily do subtraction and division as the principles are exactly the same as for decimal numbers.

Wish you luck with your further studies of binary numbers)
I hope this information was useful.