DEV Community: Denismacharia

Recursion in Programming

Denismacharia — Tue, 14 Feb 2023 03:13:38 +0000

As a programmer, you must have or will come across tasks that lead to the need for new similar lines of code. The new tasks may appear smaller or may need the repetition of smaller similar commands to handle them. They may require adding other lines of code to terminate them, which leads to increase in the size of the codebase. You can eliminate all this by implementing recursion in your programs. Let's dive into recursion and see what it's all about.

What is Recursion

Recursion is the process where a function calls itself directly or indirectly. Recursive functions solves problems by calling itself and breaking down original problems into smaller subproblems. When using recursion, you need to define an exit condition to prevent the functions from being called infinitely. The condition that when met terminates the function is known as the base condition.
Recursion is a concept rooted in a number of programming languages as we'll see.

Why choose recursion?

One of the main advantages of using recursion is that it reduces the complexity of different tasks and reduces the time spent writing and debugging. It leads to code that is easy on the eye, looks elegant and allows faster completion of tasks. Code that uses recursive functions is significantly less bulky than code that doesn't use it. However, it uses more memory since there is an extensive overhead since the function constantly updates and maintains the stack.

Implementing recursion in different programming languages.

Recursion basically works in a similar manner in different languages. However, since each language is unique, there are differences in how recursion is applied. Let's look at how each language implements it using a similar example.

Recursion in JavaScript

In JavaScript, the syntax for a recursive function is as shown below;

function recurse() {
if(condition) {
// stop calling itself
} else {recurse();
}
}

Let's see it in a practical example. The program is designed to count down numbers to 1.

function countDown(number) {
console.log(number);
// displays the number

const newNumber = number - 1;
// subtracts one from the number

if (newNumber > 0) {
countDown(newNumber);
}
}
// the base case

CountDown (4);
// output is
// 4
// 3
// 2
// 1

In the above JavaScript program, you pass the number as an argument when calling the function. The value of the number reduces by 1. The function countdown() is called until the base function newNumber > 0 reaches 0 and terminates the function.

Recursion in Python

Python also uses recursion to write efficient and mathematically elegant code. The syntax for Python recursive functions is as shown;

def func():
 if condition: 
# stop calling itself

else: 
# recurse

func=

Below is a Python program for the example we are using.

def tri_recursion (k):
if (k>0): 
result = k+tri_recursion(k-1)
print(result)
else:
result=0
return result

print("\n\nRecursion Example Results")
tri_recursion(4)

# Output will be
# 4
# 3
# 2
# 1

The function runs itself until the number gets to zero and terminates the program.

Recursion in C++

Similar to other programming languages, recursion in C++ works by calling itself over and over again. Its syntax is as shown below;

void recurse()
{ if (condition) {
# base case

return;
}
else {
}}
# recursive case

Now let's see it in a practical example;

#include <iostream>

void display(int n) {
  if (n == 0) {
    return;
  }
  std::cout << n << std::endl;
  display(n - 1);
}

int main() {
  display(5);
  return 0;
}

# The output is
# 5
# 4
# 3
# 2
# 1

Conclusion

Recursion is an essential skill that assists in reducing the bulk of the codebase while increasing the ease of writing and reading code. However, you need to be careful when using recursion since there is a risk of infinite loops and programs that use too much memory and processing power.

I hope you have learnt something from the article. Find me on twitter @devdenis_. Thanks for reading.

JavaScript Functions

Denismacharia — Wed, 08 Feb 2023 14:35:09 +0000

In JavaScript, functions are subprograms in the code that can be called by other code that is either internal or external to the function. A function comprises of a sequence of statements called the function body. Values can be fed to a function as parameters and the feedback given is a value. Functions can be forwarded to other functions, given as feedback by other functions, and can be assigned to variables. Their difference from objects is that they can be called.

Let's decipher functions.

Functions occur in different forms. They include;

Function declarations.
Function expressions.
Arrow Functions.

Function Declarations.

Function declarations are function statements that consist of;

The function keyword.
The function's name
The list of parameters to the function in parentheses and separated by commas.
JavaScript statements that define the function, placed in curly brackets {}.

Here is an example of a simple function named area:

function area(number)
 {return number*number};}

The function is used to calculate the area of a square. It takes only one parameter, which is the length of one side called number The function is made up of one statements that returns the parameter of the statement which is the number multiplied by itself. The return statement shows the value to be returned by the function.

You can pass parameters to other functions by value. It means that once a new value is assigned to a parameter that was passed to a function, the change is not reflected in the code that called that function. On the other hand, when you pass an object as a parameter, the change can be seen outside the function. When you pass arrays as parameters, a change in values is also visible outside the functions.

Note that you can quote function declarations before declaring them.

function calcAge (yearofBirth) 
{return 2023 - yearofBirth;}
const age = calcAge (1980);
console.log(age);
// returns 43

In the example above you should note that the function declaration creates a variable that uses the same name as the function. It shows that function declarations can be referred to by their name in the scope of code that they are defined in, and also in their own body.

It is recommended that you use strict mode when using function declarations. In strict mode, block-level function declarations are scoped to the block and are hoisted to the top of the block hence allowing their use before declaration.

Function Expression

A function expression differs from a function declaration in that the function name can be omitted creating anonymous functions. They can be used as Immediately Invoked Function Expressions which run immediately they are defined. You can use function expressions to define functions inside expressions. On the other hand, you can define function expressions by using the function constructor and a function declaration. Function expressions cannot be referred to before they are created since they do not support hoisting.

When referring to the current function inside the function body, you must create a named function expression. The name used is local to the function's scope. It doesn't change its name is allocated to a variable. If you choose to omit the function name, it uses the variable (implicit) name. If you name the function, it will use the function (explicit) name.

const age = function () {};
age.name; 
// "age"

const age0 = age;
age0.name; 
// "age"

const age1 = function newAge () {};
age1.age; 
// "newAge"

console.log(age === age0); 
// true
console.log(typeof newAge); 
// undefined
console.log(age1 === newAge)
// false (error since newAge == undefined)

The examples above show you how you can name function expressions at different positions and their differences in output.

You can create anonymous functions that are unnamed. In the example given below, the function is assigned to const. The function returns the age after inputting the person's yearofBirth.

const calcAge0 = function (yearofBirth)
{return 2023 - yearofBirth;}
const age0 = calcAge0 (1980);
console.log(age0);
// output; 43

Arrow Function Expressions

Arrow functions are a more advanced alternative to function expressions. To better understand it, let's start with an example of how you can change a function expression into an arrow function.

// an anonymous function expression
(function) (age) {return 2021-yearofBirth;});

// Replace the Keyword "function" with an arrow placed
// between the argument and the opening body bracket

(age) => {return 2023 - yearofBirth;};

// Eliminate the body braces and the keyword "return". 

(age) => 2023 - yearofBirth;

// eliminate the parameter parentheses

age => 2023 - yearofBirth;

The example above is an illustration of instances where both parentheses around the parameter and the braces can be omitted. They can only be omitted if the function has only one simple parameter. If there are multiple parameters, no parameters, or default parameters, the parentheses around the parameter list are required. If the function is used to return an expression, braces can be omitted. When the body has additional lines of processing, the return keyword and the braces are required since arrow functions cannot decide whether you want to return or not.

// Anonymous function
(function (x, y) 
{const unit = 8;
return x + y + unit;
});

// Arrow function
(x, y) => {
const unit = 8;
return x + y + unit;
};

Note that arrow functions are always unnamed. If an arrow function needs to call itself, you should use a named function expression or the arrow function can be assigned to a variable so it has a name.

Calling functions

When you define a function, you specify what it does once it is called. Calling a function performs the instructed actions with the given parameters.

area (9);

The example above calls the area function with the argument that the length of one side is 9. The function is executed and returns the value 81. You must place functions in scope when they are called, but remember that function declarations can be hoisted.

Conclusion

You need to understand how functions work to be a good JavaScript programmer since it is essential in writing efficient code. I hope you have learnt something from the article. If you would like to contact me directly, find me on twitter @devdenis_.

Fundamentals of JavaScript (Part 1)

Denismacharia — Sat, 04 Feb 2023 07:23:52 +0000

Whenever you access the internet, most of the sites you access are powered by JavaScript. This article will show you how to write your first JavaScript code and introduce you to JavaScript datatypes.

Getting started with JavaScript

JavaScript is the most popular programming language in the world. It is the programming language that powers the internet. In this article, you will learn the basics of JavaScript language.

Check this out to learn how to link a JavaScript file to a HTML file.

Logging 'Hello World" to the console.

To link a JavaScript file to a HTML file, one needs to add the following to the HTML file. <script src="myscripts.js"></script>. The .js file needs to be in the same folder as the HTML file for the code to work. To ascertain that the JavaScript file is properly linked, you will print hello world as shown;

console.log('Hello World');
// The console displays 'Hello World"

JavaScript Datatypes

JavaScript has 8 Datatypes.

String
Number
Bigint
Boolean
Undefined
Null
Object

1. Strings

Strings are a series of characters written with either single or double quotes. They include special characters, numbers, letters, or a combination of any of them. Strings are immutable and any strings created hold value that cannot be changed. Any operations that appear to change create new strings with the desired modifications. Here are examples of strings;

"John"
"Car"
Let owner1 = "John"
let machine1 = "car"

In all instances the words "car" and "John" are used as strings.

Number

In JavaScript, Number data type is used to represent floating-point numbers and integers. JavaScript uses 64-bit floating-point representation for numbers enabling it to represent small and large numbers with high accuracy. However, it limits its ability to represent some numbers accurately leading to approximate values when used in a calculation.

let a=10;
let b=23;
let c=a+b;
console.log (Z)

The variables involved in the above example are numbers and can be used to make arithmetic calculations.

Bigint

Bigint data type in JavaScript is an numeric primitive that is used to represent integers with arbitrary magnitude. It allows storing integers that are larger than the maximum safe integer limit for Numbers data types. To create a BigInt, you append n to the end of an integer or call BigInt():

Let x = 555555555555555
Let y = 555555555555555n
let z = BigInt(555555555555555)

X is a number, while both y and x are BigInt data types.

Boolean

When programming, you will make a lot of decisions that are either true or false. To achieve this, you will need to use Boolean values where you choose from one of two values. They include YES / NO, ON/OFF, and TRUE/FALSE.

let isTrue = true;
let isFalse = false;

Booleans can be used in comparisons and conditions where the value of Boolean expressions is their basis.

let age = 20;
If (age>=18) {console.log (`You are an adult`) else {Console.log (`You are not yet an adult`)
// Output: You are an adult

If the condition is true, the console displays that the person is an adult, if it's false, it shows that the person is yet to be an adult.
When using Boolean as functions, everything with a value is true while anything without is false. False values include empty strings, undefined, null, false, and NaN.

let x = 10 / "year";
Boolean(x);
// Output : NaN

Year is not a number hence its output will be NaN which is false in functions.
Booleans can be used as objects but it is not recommended since they can produce unexpected results. Additionally, the new keyword used to define them complicates code and reduces its efficiency.

Undefined

It is a primitive data type that is a variable in the global scope. It represents a variable that has not been assigned a value. A statement can also return undefined if the variable being evaluated lacks an assigned value. A function returns undefined if a value was not returned. Although you can use undefined as a variable name it is not recommended since it will maintaining and debugging code difficult.

let x;
typeof x === "undefined"

Null

The null value is used to represent intentional absence of any object value. It is treated a falsy for Boolean operations. null expresses a lack of identification indicating that the variable used lacks identification showing that it does not point to any object.

boy;

The value boy is not identified hence its type is displayed as null.

Variables and Values

Variables are containers used to store data values. In JavaScript, variables are declared using Var, Let, and Const.
The Const variable is used to declare general rules that are fixed. For example:

const carPrice = 100000;
const extras = 20000;
Let total = carprice + extras;
console.log (total)

The code above shows that the price of the car and extras is constant. On the other hand, the let variable used to reference the total is not constant.

The Var variable is also used to declare variables that are modifiable.

var carType = Audi;
var carModel = Sports;
console.log (carType +" "+ carModel)

Variables are often declared without a value. A value ranges from something that will be provided later or one that requires calculating. Variables declared without a value are given the value Undefined. In the example given above, the value of the variables used above will change to undefined after the command is executed.

Thanks for reading, I hope you have learnt something.

Datatypes in JavaScript

Denismacharia — Mon, 23 Jan 2023 04:28:45 +0000

What are data types in Javascript?

In Javascript, a data type is a classification of data that determines the type of values a variable can hold. Being a dynamic language, the data type in a variable can change at any point in the execution of instructions. This article will improve your knowledge in javascript data types.

The datatypes include;

Number
String
Boolean
Undefined
Null
Object

Number

In JavaScript, the Number data type is used to represent both integers and floating-point numbers. Numbers can be written with or without a decimal point. For example, both 3 and 3.0 are considered to be numbers in JavaScript.

JavaScript uses a 64-bit floating-point representation for numbers, which means that it can represent large and small numbers with high precision. However, it also means that JavaScript may not be able to represent some numbers exactly. For example, the number 0.1 cannot be represented exactly in 64-bit floating-point format, and may be approximated when used in calculations.

JavaScript also has several special numeric values that are considered to be of the Number type. These include:

NaN (not a number): represents the result of a undefined or unrepresentable mathematical operation.
Infinity: represents positive infinity and negative infinity.
Infinity: represents negative infinity.

JavaScript also has several built-in methods and properties for working with numbers. These include:

The Number.isInteger() method can be used to check if a value is an integer.
The Number.isSafeInteger() method can be used to check if a value is a safe integer (a number that can be exactly represented by the built-in 'Number' type).
The Number.isNaN() method can be used to check if a value is NaN.
The Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER properties can be used to get the largest and smallest safe integers, respectively.
The Number.parseInt() and Number.parseFloat() methods can be used to parse a string and return an integer or floating-point number, respectively.
The Number.toFixed() method can be used to convert a number to a string with a specified number of decimal places.

There are potential limitations and behavior of numbers in JavaScript when performing mathematical operations, especially with decimals, and when dealing with large numbers where there is a possibility for error due to poor precision, overflow and underflow, and type coercion.

String

In JavaScript, the String data type represents a sequence of characters. Strings can be written with single or double quotes, and can contain any combination of letters, numbers, and special characters. For example, the following are all valid strings in JavaScript:

'hello world'

"hello world"

"123"

"Special characters: !@#"

JavaScript provides several built-in methods for working with strings. These include:

The length property can be used to get the number of characters in a string.
The charAt() method can be used to get a specific character from a string by its index.
The indexOf() method can be used to find the first occurrence of a specified string within another string.
The lastIndexOf() method can be used to find the last occurrence of a specified string within another string.
The substring() method can be used to extract a portion of a string.
The slice() method can be used to extract a portion of a string, similar to substring
The split() method can be used to split a string into an array of substrings.
The replace() method can be used to replace a specified string or regular expression with another string.
The toUpperCase() and toLowerCase() methods can be used to convert a string to uppercase or lowercase, respectively.

It is important to keep in mind that strings in JavaScript are immutable, which means that once a string is created, its value cannot be changed. Any operations that appear to change a string actually create a new string with the desired modifications.

JavaScript also has a built-in object called String, which provides additional functionality for working with strings. For example, the String.prototype.concat() can be used to concatenate two or more strings together.

Boolean

In JavaScript, the Boolean data type is used to represent true or false values. A Boolean value can be either true or false, and is commonly used in conditional statements to check if a certain condition is true or false.

JavaScript provides several ways to create Boolean values. The simplest way is to use the keywords true and false, like so:

let isTrue = true;
let isFalse = false;

You can also use logical operators to create Boolean values by combining multiple conditions. For example:

let result = (2 > 1) && (3 < 4);  
// result = true
let result2 = (2 > 1) || (3 < 2);  
// result2 = true

You can also use comparison operators to create Boolean values by comparing two values. For example:

let isEqual = (2 == 2);  
// isEqual = true
let isNotEqual = (2 != 3);  
// isNotEqual = true

JavaScript also provides several built-in methods and properties for working with Boolean values. These include:

The Boolean() function can be used to convert a value to a Boolean.
The ! operator can be used to negate a Boolean value, turning true into false and vice versa.
The && operator can be used to perform a logical "and" operation between two Boolean values.
The || operator can be used to perform a logical "or" operation between two Boolean values.

It is important to keep in mind that any value can be converted to a Boolean in JavaScript, even if it is not technically a Boolean value. For example, any number that is not 0 is considered to be true, and 0 is considered to be false.

Boolean values are commonly used in control flow statements such as if-else statements to represent true or false data.

Undefined

The undefined data type is used to represent the absence of an object or value.
In JavaScript, a variable can be declared without being assigned a value. In such cases, the variable is of type "undefined". For example:

let car;
console.log(typeof car);
 // Output: "undefined"

It's also possible for a function to not return a value. In such cases, the return value of the function will be "undefined". For example:

function example() 
 // This function does not return a value
let result = example();
console.log(typeof result); 
// Output: "undefined"

If you try to access the value of an undefined variable, a ReferenceError will be thrown. To avoid this, it's a good practice to check if a variable is undefined before attempting to access its value. You can use the typeof operator to check the data type of a variable, which will return "undefined" if the variable is of type "undefined". For example:

let car;
if (typeof car === "undefined") {console.log("car is undefined");
}
// Output: car is undefined

It's important to note that undefined is a distinct value from null. null is used to represent an intentional non-value, while undefined is used to represent an absence of value or object.

Variables that have been declared but have not been assigned a value are of type undefined. To avoid errors, it's a good practice to check if a variable is undefined before accessing its value.

Null

The null datatype is used to represent intentional lack of a value. It can be assigned to a variable or used as the value of an object property.

let a = null;
console.log(typeof a); 
// Output: "object"

It's important to note that, although typeof returns object for null, null is not an object. It is a special value that represents the absence of an object.

You can use the null value to explicitly set the value of an object property to an intentional non-value. For example:

let employee = {
  name: "Kendrick",
  age: 20,
  occupation: null
};
console.log(employee.occupation); 
// Output: null

When checking for the absence of a value or object, it is recommended to use null instead of undefined. This is because undefined can have different meanings in different situations, such as:

When a variable has been declared but not assigned a value
When a function does not return a value
When an object property does not exist null always represents an intentional non-value, making it a more reliable and meaningful value to use when checking for the absence of a value or object.

Object

In JavaScript, the "object" data type is a collection of properties, each of which can hold a value of any data type, including primitive data types and other objects. An object is an instance of the Object class and can be created using the object literal notation or the Object constructor.

Object Literal Notation:

let employee = {
  name: "Kendrick",
  age: 20,
  occupation: "Developer"
};

Object Constructor:

let employee = new Object();
employee.name = "Kendrick";
employee.age = 30;
employee.occupation = "Developer";

In an object, properties are identified by keys, which are strings, and values, which can be of any data type. Properties can be added, modified, or removed using the dot notation or the square bracket notation.

Dot Notation:

employee.address = "1234 mstreet";
console.log(employee.address); 
// Output: "1234 mstreet"

Square Bracket Notation:

employee["phoneNumber"] = "555-555-5555";
console.log(employee["phoneNumber"]); 
// Output: "555-555-5555"

Objects can also have methods, which are functions that are properties of an object. For example:

let employee = {
  name: "Kendrick",
  age: 20,
  occupation: "Developer",
  sayHello: function() {
    console.log(`Hello, my name is ${this.name}.`)
;}
};

employee.sayHello(); 
// Output: "Hello, my name is John Doe."

In JavaScript, objects can also be used as associative arrays, where the keys can be used as indices to access the values. This can be useful for storing collections of data where the keys are unique identifiers.

Javascript is an interesting language that has a lot of capabilities. Developers looking to perfect their javacript skills need to understand Javascript datatypes and make sure they avoid issues that are associated with each datatype for fast, reliable and easily debuggable code.