Getting started in Software development: A Path to a rewarding career (Part 3C, Control structures)
Tags: webdev, beginners, career, tutorial
Published: 2023-07-22 21:18:57

## Hello and welcome
Thanks for stopping by yet again.

## Table of Content
Full table of content for the entire series is [here](https://dev.to/jdonq/getting-started-in-software-development-a-path-to-a-rewarding-career-16ik)

Today, we will continue the following
- **Getting started (cont'd)**
    - **Learn Programming concepts (cont'd)**


## Programming Concepts
Here again to learn some more basic programming concepts. 

![emotional damage](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/le3r31uqnv87r0n3iic8.gif)
 
### Control Structures
Control structures in programming are a fancy name for ways to make decisions, repeat actions, and execute specific blocks of code based on certain conditions being true or false (Boolean). 

Say for example you want to display a different message to a person depending on their age or gender, then you can use control structures to execute the code that handles each scenario.

Say you want the same block of code to run multiple times like print from 1 to 10 or continue to display the current time every second then control structures are for you.


![controller](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xqtw4cc478duhpiu3xq4.gif)
 
We are JavaScript developers here so we will look at some control structures in JavaScript below. For ease of understanding we will broadly categorize them into 2 sub-groups; the Decision Control Structures and the Repetition Control Structures

#### Decision Control Structures
These are used to decide if to execute some block of code instead of others depending on a given condition and they include:
-	if...else statement: This allows you to execute different blocks of code based on a given condition. It allows you to say ‘if’ a condition is true then do some code ‘else’ do another thing.

```
if (someConditionIsTrue) {
  // Code to execute if the condition is true
  // do something in your application
} else {
  // Code to execute if the condition is false
  // do something else in your application
}
```

It is important to note that any block of code whose condition is not true will not be executed

```
if (1 + 1 > 3){
  // 1 + 1 > 3 is true
}
else{
  // 1 + 1 > 3 is not true
}
```

From the example above, we see that the code `1 + 1 > 3` is true will not run because `1 + 1 > 3` will return false.
The code that will run in this case is `1 + 1 > 3` is not true

So the logic of the if else is: 
if condition is true, do what is in the block of code in between the curly braces `{}` and jump to the code after the `if…else` block.

Otherwise, do what is in the curly braces `{}` in the else block and then continue 

-	if…else if...else statement: This here is the same as the if else statement, but it gives you the option of checking for multiple conditions instead of just 2

Say you want to do something different on each weekday, you can say

```
if (today === ‘Monday’){
  // do the Monday thing
}

else if(today === ‘Tuesday’){
  // do the Tuesday thing
}

else if(today === ‘Wednesday’){
  // do the Wednesday thing
}

else if(today === ‘Thursday’){
  // do the Thursday thing
}

else if(today === ‘Friday’){
  // do the Friday thing
}

else{
  // do nothing because it the weekend!!!
}
```
We can see that we are handling multiple cases in the `if` and `else if` blocks and if none of them meet the criteria set then the `else` block serves as a kind of catch all for any case that is not handled.

The final `else` block is not required but if it will be used then it must come last in the list

We will take more examples in the weeks to come. This is just to aid basic understanding and so we have a starting point when demos begin because we are here to help.

 
![Iron legion](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/oy2bxfhn3svz3ip6dvx2.png)

-	switch statement: This allows you to pass an expression and then execute a block of code depending on the outcome of that expression. 

```
switch (expression) {

  case value1:
    // Code to execute if expression is equal to value1
    break;
  case value2:
    // Code to execute if expression is equal to value2
    break;
  case value3:
    // Code to execute if expression is equal to value3
    break;

  // Add as many cases as needed

  default:
    // Code to execute if expression does not match any case
}
```

From the above, we see that what the computer does is dependent on if the expression that was given to the `switch` block matches any of the cases.

If no case is matched, there is the `default` block that serves as a catch all. 

It is also important to note that the `break` is needed otherwise the code of the next case will be executed as well. The `break` is like saying move on to the next line of code outside the `switch` block so it must come after whatever you want to do for each case.
Example:

```
switch (dayOfTheWeek) {

  case ‘Monday’:
    // Code to execute if dayOfTheWeek is equal to ‘Monday’
    break;
  case ‘Tuesday’:
    // Code to execute if dayOfTheWeek is equal to ‘Tuesday’
    break;
  case ‘Wednesday’:
    // Code to execute if dayOfTheWeek is equal to ‘Wednesday’
    break;
  case ‘Thursday’:
    // Code to execute if dayOfTheWeek is equal to ‘Thursday’
    break;
  case ‘Friday’:
    // Code to execute if dayOfTheWeek is equal to ‘Friday’
    break;
  default:
    // Code to execute if dayOfTheWeek does not match any weekday 
    // So it may be weekend or some other value not matched above
}
```

If the condition you want to check for is based on the same unchanging expression like weekday above then `switch` statement can be a more concise replacement for `if…else if…else` statement.

#### Repetition Control Structures
These are used to execute the same block of code repeatedly until a condition is met or not met. They are sometimes referred to as **loops** because the code is run in a loop until something **breaks** the loop or ends it. And they are:

![loop](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f3bz03oyvalf5822pidg.gif)
 
-	while loop: This loop executes a block of code repeatedly as long as the specified condition is true. The syntax is
```
while (someCondition) {
  // Code to execute repeatedly as long as the someCondition is true
}
```

So lets say we have an integer or number variable called `count` and its value is 100. We can write a `while` loop to do something until the value of `count` is 0.

```
count = 100
while(count > 0){
  // do something interesting
  // or just print count
}
``` 

This code here will repeat everything in the code block until the value of count is 0.

In the code we have above, the code will run forever because the value of count is 100 and so, every time it runs the code block and then goes back to check again, `count > 0` will still be true, so it will run again.

A loop that runs forever is called an infinite loop, it is a loop whose condition can never be false so it will continue to run until you manually stop it or the machine crashes or some other stopping event happens.

Infinite loops should be avoided unless you know what you are doing, and you want the code to keep repeating endlessly.

Since we do not want that here, we need to fix the above code by reducing the value of count in each iteration of the loop like so:

```
count = 100
while(count > 0){
  // do something interesting
  // or just print count
  count = count – 1
  // or count-- 
  // to reduce the value of count by 1
}
``` 
Now, the value of `count` will be reduced by 1 on each iteration of the loop and once `count` is no long greater than 0, the loop will break and move on to the next line of code after the loop block.

In the example above, the loop will run 100 times because the counter variable which we named `count` here is 100 and it is decremented by 1 each iteration. 

There is no law that says we must only decrement by 1 so we can decrement by 2 or 5 or 10 in each iteration and the loop will adjust accordingly.

There is also no law that says we must start our counter from 100, it can be anything. We can start from 0 and count upwards and set the condition to be when `count` is up to a certain value like 1000. We can even use other data types as the ‘counter’. So long as we alter them in the loop until the at some point in the future, the loop ends (if we want it to). The counter is simply the controller of the loop that determines if the loop will break or continue.

-	do…while loop: Almost the same as the `while` loop, but the code block is executed at least once before checking the condition. So the instruction is `do` what is in the code block `while` a given condition is true. But because you encounter the `do` block first then the code in it will run at least once before the while condition is checked and then repeated (or not) depending on the condition of the condition. Get it?. No?. Ok moving on.
Example:
```
do {
  // Code to execute at least once then repeatedly 
  // as long as the condition is true
} while (condition);
```

-	for loop: This is a more concise way of writing the other loops. It allows you put the counter, condition and the change on each iteration in one line. Syntax is as follows.
```
for (initialization; condition; change) {
  // Code to execute repeatedly as long as the condition is true
}
```

let us revisit out while loop from above. It now prints the `count` and uses the decrement operator to (well) decrement the value of `count` on each iteration

```
count = 100
while(count > 0){
  // just print count
  print(count)
  count-- 
  // to reduce the value of count by 1
}
``` 

Now let us do the same thing using the `for` loop.
```
for (count = 100; count > 0; count--) {
  // just print count
  print(count)
}

```
The 2 snippets above do the exact same thing but the `for` loop is more concise and cleaner too if you ask me but then what do I know right. 

There are other ways to loop in Javascript like the `for…in`, `for…of` and some others that allow looping through certain data structures but we are here to do the basics and we will get into those when we start coding demos.

This is it for today. Stay frosty guys.

 
![till next time](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sa5ei96jq5dzhp4kpdwa.gif)


Previous post is [here](https://dev.to/jdonq/getting-started-in-software-development-a-path-to-a-rewarding-career-part-3b-ooj)

Next post is [here](https://dev.to/jdonq/getting-started-in-software-development-a-path-to-a-rewarding-career-part-3d-functions-data-structures-and-debugging-2ei0)