A course to learn JavaScript programming for complete beginners! Jump right into action with this easy to follow and very hands-on course taught by NBK Tech World.

JavaScript for Complete Beginners

You can get started learning JavaScript in your favorite browser. For example: Brave, Chrome, Edge, Firefox, Opera, or Vivaldi. Pick one browser and open it.

The next thing you have to do is open the "DevTools", short for Developer Tools. On most browsers you can simply press the function key F12 and it will bring it up for you. Other ways to open the browser developer tools is right-clicking anywhere on a page and choosing to Inspect.

On Firefox for Windows, for example, you can click the hamburger icon (the three stacked lines) on the top-right corner. Then, choose More Tools, then choose Web Developer Tools.

On (Chromium-based) Edge, click the three-dots icon on the top-right corner, choose More Tools, then Developer tools.

Safari on macOS will require you go to the Advanced tab in the Preferences window and require you mark as checked "Show Develop menu in menu bar"


Introduction to JavaScript (Opening the Browser Console)

# Summary of JavaScript Course Introduction

Welcome to the **NBK Tech World** course on JavaScript for complete beginners. In this course, we will start programming in JavaScript from the very basics. 

## Key Points

- **Target Audience**: The course is designed for complete beginners. If you already have knowledge of JavaScript, it may be too slow for you, and you can choose to skip sections.
- **Requirements**: 
  - A computer
  - A web browser (Firefox, Chrome, Safari, or Edge)

## Importance of the Browser 

We need a web browser because it includes a JavaScript console, which is essential for executing JavaScript commands.

## How to Open the Web Console

### Firefox

1. For Mac users:
   - Navigate to **Tools → Web Developer → Web Console** 
   - Hotkey: `Option + Command + K`

### Chrome

1. For Mac users:
   - Navigate to **View → Developer → JavaScript Console**
   - Hotkey: `Command + Option + J`
  
### Safari

**Note**: Safari does not show the console by default.
1. Navigate to **Safari Menu → Preferences → Advanced**
2. Check the option for **Show Develop Menu in Menu Bar**
3. Once enabled, navigate to **Develop → Show JavaScript Console** 
   - Hotkey: `Command + Option + C`

## Conclusion

We have now covered how to open the browser console, marking our first step into learning JavaScript. In the next video, we will explore our first JavaScript statement.

**See you then!**

Hi everyone, welcome to NBK Tech World. This course will be about JavaScript for
complete beginners. We're gonna go from the start, we're gonna jump right into it,
into how to start programming in JavaScript. If you already know some
JavaScript, this course might be too slow for you. Well if you want to stick
around and have a look to see how it goes, feel free to do so. If you feel like
it goes too slow for you, I recommend that you skip it. Alright? So to start off,
all you're gonna need is your computer obviously and we're gonna need a web
browser. Web browser such as Firefox, Chrome, Safari or Edge. So any of these
major web browsers will do. And why do we need a browser? We need the browser
because each of these browsers has included a JavaScript console. So it's
very convenient for us to jump right into it right away. So here I have some, I
have Firefox, I have Chrome and Safari here open and I'll show you how to open
the web console. Okay? So for each of these browsers I'm gonna show you how to
open the web console. If you already know how to do this, you can skip this part of
the video. Okay? So let's start with Firefox. So here I'm in Firefox. Okay? So
I'm using Firefox Quantum version 61. All you have to do is if you want to go by
click, you can click on Tools, Web Developer and then Web Console. The hot
key is, in my case for Mac, is Option Command K. So if you type Option Command
K, there appears the web console here and we can type our commands here at the
bottom. Now let's do it for Chrome. I'm gonna open up Chrome. Here's my Chrome
window. Like in the same way for Chrome, in my case I can click View, Developer and
then I can see there's a JavaScript console option. You can click that. The
hot key by the way is Command Option J for Mac. Command Option J, bring it up,
Command Option J, close it. Okay? So you can type the commands here. Now for Safari,
since I'm on Mac, it's a little bit, we got to do a little extra
strap because it does not have the console enabled by default. So all you have
to do for Safari is you go to the Preferences, click on the Safari menu,
Preferences and Advanced and then at the bottom of the Advanced tab, you have to
select Show Develop Menu and Menu bar and that will allow you to see the
Develop Menu up there. If you go up there, in my case between bookmarks and
window, I'm using Safari 11.1.2 by the way. You can click Develop and it will
bring up a menu and you can just click Show JavaScript Console. The hot key is
Command Option C. Command Option C brings up the console in Safari and you
can type the commands here at the bottom. Okay? So we learned how to open up the
browser console and that's our very first step into learning JavaScript into
the world of JavaScript. Okay? So I will see you in the next video when we
start with our first JavaScript statement. So first command. See you then.


fff8-01 Introduction to JavaScript (Opening the Browser Console)

Opening the Browser Console in Microsoft Edge

# Opening the Browser Console in Microsoft Edge

In this lesson, we will learn how to open the browser console in Microsoft Edge.

1. **Open Microsoft Edge**: Start by launching the Microsoft Edge browser.
2. **Access the Developer Tools**:
   - Click on the **three dots** located in the menu on the right-hand side.
   - Scroll down and select **F12 Developer Tools**.
   - Alternatively, you can use the hotkey **F12** to open the developer tools directly.
3. **Navigate to the Console**:
   - Once the developer tools menu is open, click on the **Console** tab to access the console.

### Notes:
- The hotkey for opening the developer tools is **F12** on Windows (Windows 10 in this case).

Thank you for watching this video! Until next time, goodbye!

Welcome to NVK Tech World. In this lesson we're going to learn how to open the browser
console in Microsoft Edge. Here I have Microsoft Edge open. All you have to do is you go to
the three dots here in the menu on the right hand side and you scroll down to see F12 Developer
Tools. This is what you have to click. F12 is also the hotkey for this menu. Here's
the menu and from elements you can go to the console tab and there you have it. Here's
the console. Okay, so the hotkey is function 12. If you're using Windows, I'm using Windows
10 and that will bring up the developer tools menu and you click on the console tab. Alright,
thank you so much for watching this video and until the next time. Bye!


fff8-02 Opening the Browser Console in Microsoft Edge

Logging a Message to the Console using JavaScript in the Browser

```markdown
# JavaScript Introduction

## Overview
In this video, we begin our journey into JavaScript using the Firefox browser (though any browser will work). The focus is on using the JavaScript console.

## Steps Covered
1. **Open the JavaScript Console**: Access the console in your browser.
2. **Print a Message**:
   - Type `console.log('hello world');`
   - This command logs the message "hello world" to the console.

## Explanation of Concepts
- **String**: The text within quotes (e.g., 'hello world') is called a string. Strings can be enclosed in single quotes, double quotes, or backticks.
- **Function**: `console.log` is a function that takes an argument (the message) and performs an action (logging it to the console).
- **Arguments**: The input to the function (e.g., the message to log).

## Challenge
You are invited to print your name using the console. The command will be similar:
```javascript
console.log('your name');
```
Replace `'your name'` with your actual name.

## Closing
The video encourages viewers to explore JavaScript further, assuring them that terminology will become clearer with practice. 

See you in the next video!
```


Welcome back! So now let's jump into JavaScript. So for this video I'm gonna
be using Firefox. You can use any of the browsers we mentioned before. All we need
to do is open up the web console or JavaScript console or whatever it is
that your browser calls it. Okay so now we're here. Let me increase my font size
so you can see better. So we are here and we can type commands here and those
will be interpreted by the JavaScript interpreter here. So let's start with a
first command. We're gonna print a message to the screen, in this case this
white space area here. We're gonna type the following. Let's type with me. It's
console then you type a dot. Log. Okay so we're gonna log a message to the screen.
Now let's say hello world and you place the hello world between two single quotes.
Okay so you say console.log and you open parenthesis, single quote, whatever
message you want to say. In my case I just said hello world. Close the single quote
here. Don't forget then you close the parenthesis. Okay now we're gonna type
this. Enter and there you go. It printed the message hello world to the
JavaScript console. Okay so that's our first statement in JavaScript. So I'm
gonna explain a little bit what's going on here with this statement. Don't, you
don't have to understand everything right away. I just want you to learn and
hear this terminology that I'll be discussing. Okay so what we have here is
the message right hello world or whatever you typed. This message here is
placed under single quotes. So this guy right here is called the string. So in the
world of programming if you have like some sort of text you know you
call them strings like strings of characters. If you think of these
characters together forming a sentence forming some text they're called
strings. Okay so strings typically appear in quotes. Okay so we have hello
world in this case single quotes. There are other kinds of quotes you could use
double quotes, back tick in the world of JavaScript but I'll stick with the
convention for now of using always single quotes. Okay so we have a string
and this string has the text hello world and then we do this thing called
console log. Console log, so what are you doing here is you're calling a function.
This function is called log and it does what it says it does. It logs a message
to the screen to the console in this case. Okay so log is a function. So to the
function you're passing an argument. In this case is the message. You're passing
the function this argument and the function will do something with that
argument. In this case it's taking this message and printing it to the console.
So that's what functions do. Function will take some input, some arguments not
necessarily just one it could be multiple and then it's going to do some
processing and ultimately you're going to get an output. You're going to get
something back. In this case what it did was just print the message to the
console here. You see the second line that's the purpose of the console log
function. It does log. Okay now log functions are part of the console objects
and that's a little bit more complicated but you don't have to worry about
these terms. Like I said before I just want you to get started here in these
terms so you can internalize and better understand them along this road, this
journey that you're learning JavaScript. So all these terms will become clear as
you go on you continue your journey. Okay so that's it. Now I have a challenge for
you. I want you to print something to the console. I want you to print your
name. So how would you do it? I'll give you a couple seconds if you think about it
can pause the video then when you're done we're going to go on and do the
challenge. Alright so how did it go? So we're going to print something to the
screen to the console. We're going to say console and I'm going to say dot log and
then what is the string here? Two single quotes and I'm going to say I don't know.
I'll say my name. You can say your name. Okay so my name is a string. It's being
passed as an argument to the log function. Notice functions always have the
opening and closing parentheses. Okay so when you see parentheses think of
function. Okay the log function is part of the console object which has a function
to console has many functions. One of them is log and to log to the console. So
it's related. Alright so there you go console log and you are going to get
your name here. Alright so this is it for this video. Hope you liked it and see
you next time. Bye!


fff8-03 Logging a Message to the Console using JavaScript in the Browser

JavaScript Variable Definition with const

```markdown
# Summary of the Video on Variables

## Introduction
- The video discusses the concept of **variables** in programming, specifically in JavaScript.
- It serves to explain how to store information when writing programs.

## Key Concepts
1. **What is a Variable?**
   - A variable is a container that holds data values.
   - Data can be personal information, like your name or age, which needs to be stored while programming (e.g., in an application like Facebook).

2. **Defining Variables**
   - In ES6 (ECMAScript 2015), we define variables using the keyword `const`.
   - Example of defining a variable:
     ```javascript
     const name = "My Name"; // where "My Name" is a string
     ```
   - Once defined, a variable can store a value that can be accessed later.

3. **Variable Naming**
   - It's encouraged to name variables descriptively to enhance code readability and maintainability.
   - Poor naming practices (like using single letters) are discouraged.

4. **Types of Values**
   - Variables can hold different types of data, such as:
      - **Strings:** Enclosed in quotes.
      - **Numbers:** Not enclosed in quotes.

5. **Using Variables**
   - To retrieve and display the value stored in a variable, use `console.log()`.
   - Example:
     ```javascript
     console.log(name); // Outputs: My Name
     ```

6. **Assignment Operator**
   - The `=` signifies assignment, which means you assign a value to a variable.

## Challenge
- Viewers are challenged to define a variable called `age`:
   ```javascript
   const age = 35; // Example value, must be a number
   ```
- The `age` variable should be a number (not a string) and can be logged to the console.

## Conclusion
- The video ends with a recap of what was learned about variables, different value types (string and number), and encourages viewers to practice by creating variables.

## Call to Action
- Viewers are encouraged to like the video and subscribe for more content.
```


Alright guys, welcome back. Welcome back to MBK world. In this video we're going to be
talking about a concept called variables. Basically we need to learn how to store information
when we're doing our programs. So how does it work? Okay, so before I go on let me clear
my console. There's this nice icon here of the trash can. It can clear my output. And
we're going to start over. We're going to talk about variables. So last time we talked about
console log, how to print a message to the console. We learned about the concept of a
function that takes an argument and as an input and then process does some processing and then
output something. And now we need to learn how to store information. Because we I don't know,
say you have, for example, you're using, I don't know, you're using Facebook, for example, and
they taking many kinds of information, right? They need your name, your birthday,
or interest, like many, they want your descriptions, that kind of stuff. So where does all those
information go when you see that page? So all those guys are inside a variable, they're stored in a
variable. So variable is just some kind of box where you put some stuff and you can retrieve it.
You can access it later. Okay, so the way you define a variable in JavaScript.
Okay, is the following note I'm using what's called a yes six and beyond JavaScript is an
implementation of a language called academic script, which is the standard for the JavaScript
language. And I'll be using the ES six, so called academic script 2015. And before that, the language
had some constructs. And now they added new constructs to the language. Now the language is
much more, you know, much more convenient. And one of those concepts is that they change a little bit
how you assign a variable. The old ways that works, but now you can do another way. And this
other new way is what I'm going to teach you. Okay, so you declare a variable with a keyword
called cost. Okay, cost. So cost. And then you're going to say you have to give the variable a name.
It could be anything with certain exceptions for the name convention, but I won't get it to that
here. But let's make it simple. Let's say we want to store our names. I'm going to call the variable
name. And the value this variable is going to hold, you assign it with the equal operator. Okay.
Now you name this case has to be a string, right? Because it's a name. And to that, I am going to
write my name. Well, you can write your name, but I'll write my name. Okay, so let's take a look at this.
So this is going to be your name. It's a string, remember? String is like a sequence of characters.
So on the equal sign, it's an assignment operation. Okay, you're assigning
your name to a variable called name this case. Okay, the variable, you choose the name of the
variable. When you do programming, and you learn what development you learn that's always good to
name your variables to give good name to your variables. So like that, the programmers and
developers will understand what's going on right away when they see the name of the variables. So
try to name give them a very good name, don't go around naming variables with just one letter or
something very cryptic. That's a very bad practice if you're doing development in the real world.
All right. So const is a keyword. It's a new thing in ES6, the set before,
new version of JavaScript, which is going to be the de facto standard now.
Supported by most hopefully is going to be supported by most fully supported by most
major browsers very, very soon. Okay. So const, and then the name of the variable equals whatever
you want it to be. What's the value? This is called the value of this variable. Okay, now
you type enter and then you define the variable. Don't worry about this undefined here. It's the
it's actually a return value of this expression. Don't worry about it. Just ignore it for now. Okay.
So we define a variable called name that holds the value my name. Okay, so
if you want to see what's inside the variable name, since we are in the console, we can just type
name, okay, and then enter. And there you go. It's going to say, okay, the value of the variable
name is my name. Now, if you want to use this, for example, you want to do a console log,
you want to log to the console, the variable, you can use that function we learned console log,
right? And then you give an an argument is between the parentheses, you give the function an argument.
We're going to give the argument, let's say we just want to console log or name. So you can
just type the variable name there. Notice there's no strings. Okay, because this is a variable.
And the variable name here has some value. And this value here, my name is going to be
substituted here. So it's going to be actually like this. Okay. And then the console log is going to
print my name. Okay, so let's see if it really works.
Okay, so right here, this line, it print my name. Okay.
So that's
those are variables. Okay.
So let's review, let's review. What we did was define a variable called name, whose value is a string
that included your name, my name. We use the keyword const to define this variable.
Then you can console log it and just give it the name of the variable and the value of the variable
will be substituted here and then be print. Okay.
So notice there's no quotes around it because this is not a string. This is a variable. All right.
So there's a difference there. Now I want to challenge you.
I want you to define a variable. Okay. And this variable is going to be called age.
So I want you to define a variable called age, whose value is going to be your age. You don't
have to tell me, but you can do it by yourself. Okay. And I'll give a couple of seconds. And as
for the value, it could be a string, but what we're going to learn as we're going to learn later,
there's also another type of value in JavaScript. And that's a number. Yes. So you can actually type
a number and assign it to a variable. And you don't need quotes for that because that's how
you differentiate numbers from strings. A string is enclosed by quotes, but a number is not. A
number is just numbers by themselves. Okay. So I want you to try that out. Define a variable
whose name is age and value is your age as a number. Okay. Type the number, not a string.
I'll give you a couple of seconds. So how did it go? So I'm going to hear define a variable,
start with keyword const. Then I give the name of the variable I called age. And now we're going
to assign a variable, a value to this variable with the assignment operator. And I'm going to just
make something up. All right. I'm going to put 35 as a number, not a string. Notice there's no
quotes around it. So it's an actual number, another type in JavaScript. So that's it. I can see that
there's actually 35 inside that variable. And I want you to console log it. So let's console
console log age. See what we get 35. Same as previous line. Okay.
So that's it. Hope you liked it. We learned about variables. And at the end, we learned about a
new type of value. That's the number. So thank you so much for watching. Please like
video and subscribe. And until the next time, bye.


fff8-04 JavaScript Variable Definition with const

Doing Basic Math in JavaScript

```markdown
# JavaScript Course: Exploring Numbers and Operations

Welcome back to nbktech world! In this video, we continue our JavaScript course focusing on **numbers** and basic **mathematical operations**.

## Key Points Covered

### Understanding Numbers in JavaScript
- JavaScript recognizes only one type for numbers: `number`, which includes both **integers** and **floating-point** numbers.
- No distinction exists between integer and decimal numbers in JavaScript.

### Basic Math Operations
- We explored four basic operations:
  - Addition: `47 + 13` gives `60`
  - Subtraction: `77 - 8` results in `69`
  - Multiplication: `3 * 9` equals `27`
  - Division: `12.3 / 3` initially gives `4.1`, but may show an extended floating-point result due to precision issues.

### Special Cases
- **Division by Zero:**
  - `7 / 0` results in **Infinity**.
  - `0 / 0` results in **NaN (Not a Number)**, indicating an undefined mathematical result.

### Order of Operations
- JavaScript follows standard mathematical precedence:
  - For example, in `2 + 3 * 3`, multiplication is evaluated first, resulting in `11`.
- To change the order of operations, use parentheses:
  - `(2 + 3) * 3` evaluates to `15`.

### Conclusion
- Remember, the console can be a useful tool for quick calculations and exploring JavaScript quirks.
- Be aware of peculiarities such as *Infinity* from division by zero and *NaN* from undefined computations.

Thank you for joining this session! Please **like and subscribe** for more videos. Until next time, happy coding!
```

Welcome back to nbktech world.
Let's go on with our JavaScript course.
Like I've already talked about variables, we learned how to define a variable using
the keyword cost.
Then at the end we learned about a new type of value in JavaScript which is the number.
So we now know there are strings and there are numbers.
This video will be all about numbers.
We're going to learn some operations on the numbers.
We're going to do some math.
Alright, so just a disclaimer, we're going to do some basic math operations, addition,
subtraction, multiplication and division.
So let's get going.
First I want to switch to new browser so we can have some variation.
And I'm going to use, let's see, let's use Safari.
Here I'm Safari.
I have my browser console open.
Remember you can click develop and then show JavaScript console.
So let me increase the size here so you can see better.
So here at the bottom, alright, let's do some math.
So in JavaScript there are numbers.
These just appear as they are.
So 10, 23.4, so on.
Okay so in JavaScript there's no distinction in terms of type between an integer number
and a decimal number.
If you already know some programming, right, you know there's always what are called the
integers versus the floating point numbers.
So for JavaScript there's only one type and there's the type number and that supports
that have a decimal point or not.
That's it for that stuff.
You don't have to really get that right away.
So let's just do some operations here.
Let's try addition.
So you can just use the console to do some math for you.
So you can type a number plus another number.
So for example 47 plus 13 will give you 60.
So just use the plus operator.
The same thing.
77 minus 8 is going to be what?
69.
And that's right multiplication.
Three times nine.
27, right?
So that's the multiplication operator.
And then let's try 12.2 divided by, let's try 12.3 divided by 3.
Okay, so that's a, wow.
There's a big, big, big, big number.
So if you think about this in terms of real life math you can do 12.3 divided by 3 should
be 4.1.
But our JavaScript console gave 4.10000 out to 5.
So it's not exactly correct.
And that's because of floating point numbers.
The computers cannot exactly tell you the exact value.
So this is like a, there's a very slight error, precision error.
It can be accounted for if you're doing like real world stuff.
There's the concept of a big number type and all that kind of stuff.
I don't want to get you into that.
We're just beginners here.
So what you need to be aware of is whenever you have decimal numbers like the result is
a decimal it's not going to be 100% precise.
There's going to be a slight error there.
So be aware of that.
Okay.
Put that in the back of your mind.
And it might come up someday if you're doing some programming and really hardcore computations.
All right.
So be careful with decimal numbers.
So called floating point.
All right.
So we did addition, subtraction, multiplication and division.
Now what happens if you divide by zero?
Oh my God.
Let's try.
Seven divided by zero.
Oh my gosh.
What just happened?
Seven divided by zero gave us an infinity.
All right.
So that's apparently some value in JavaScript.
So watch out for division by zero.
You might get infinity.
Now what happens if I divide zero by zero?
Wow.
I got NAN.
What does that mean?
Well that just means not a number.
So it's kind of like a JavaScript thing where if you try to do some operation on, you know,
and the result is it couldn't really get a number result out of it.
So it says it's another number, NAN.
All right.
So watch out for that too in JavaScript.
You don't have to memorize this.
Just be aware these things might happen.
So you want to try experimenting in doing your journey with JavaScript.
There's going to be many weird things that they're going to pop up.
All right.
This is just some weird things in JavaScript, the way it came about.
And this is one of them, not a number.
All right.
So we learned division by zero by its gives of infinity and then zero by over zero, not
a number.
I think we're good in terms of operations.
I just want to end with the order operations, right?
Because say you want to do, we all know that like in math, if you have something like two
plus three times three, the first operation that's going to take place has to be what?
The multiplication because it has higher precedence, right?
The same is going on here.
So you're not going to get first the two plus three.
That's not going to happen.
It's going to obey the mathematical rules.
So you're going to have first is going to do three times three, which is nine.
And then it's going to add to two, got 11.
All right.
So be aware of that.
So it follows the basic mathematical principles of order operation.
Now if you really want to have two plus three occur first, then what do you have to do is
add parentheses, right?
So you can add a parentheses between these guys and it will first do this operation before
doing the multiplication.
So if you have parentheses in closing two plus three, first is going to do that.
So it's going to be five.
And then after that is going to be five times three, which is 15.
Okay.
So you can use the parentheses to change the order of operation to force the plus or the
minus or whatever operation to come first to take higher precedence.
Okay.
And I know that in math we have like, if you have parentheses like this, then you have
to put the square and then the braces outside to like to give a separate the kinds of precedences
about in programming here and in JavaScript to you only need for all of them, no matter
if it's square or the brace, you always use parentheses.
Okay.
So you can put two plus three.
And then you have, let's say, I don't know, times three, then nine.
You can put all these guys like this.
All right.
And whatever, you know, so it's always parentheses to make those guys like this has to take place
first instead of the multiplication.
And this has to take place first instead of whatever you put here.
I don't know what it is.
It could be anything.
Okay.
So I think we're good for this video.
We learned simple mathematical operations.
Your console is your friend.
If you want to do some mathematical calculations, it's there for you.
Just open it up.
If you have any browser, just open it up and you can do some calculations.
Learn about a few quirks about JavaScript, division by zero with an actual number over
zero, given infinity and then zero over zero, given NAN, which is called not a number.
Okay.
So thank you so much for watching and be K-Tac World E.
And please like and subscribe.
And until the next time.
Bye.


fff8-05 Doing Basic Math in JavaScript

The typeof Operator

# NBK Tech World - Understanding the `typeof` Operator in JavaScript

Welcome back to NBK Tech World! In this video, we will explore the `typeof` operator in JavaScript, a useful tool for understanding the different data types available in the language.

## Overview of `typeof`

- The `typeof` operator returns a string indicating the type of the unevaluated operand.
- It's not commonly used in application development, but it enhances our understanding of JavaScript's data types.

## Using `typeof` in JavaScript

### Examples of Data Types:

1. **Strings**
   - Example: `let name = 'John';`
   - `typeof name` returns `"string"`.

2. **Numbers**
   - Example: `let num = 123;`
   - `typeof num` returns `"number"`.

3. **Strings vs. Numbers in Quotes**
   - Example: `let stringNum = '123';`
   - `typeof stringNum` returns `"string"`, illustrating the difference between a number and a string representation of a number.

4. **Arrays**
   - Example: `let arr = [];`
   - `typeof arr` returns `"object"` (arrays are technically objects in JavaScript).

5. **Objects**
   - Example: `let obj = {};`
   - `typeof obj` returns `"object"`.

6. **Functions**
   - Example: `let logFunc = console.log;`
   - `typeof logFunc` returns `"function"`.

7. **Booleans**
   - Example: `let isTrue = true;`
   - `typeof isTrue` returns `"boolean"`.

8. **Undefined**
   - Example: `let undefinedVar;`
   - `typeof undefinedVar` returns `"undefined"`.

## Additional Resources

- For further reference, visit the **Mozilla Developer Network (MDN)** documentation on the `typeof` operator: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof)
- MDN provides comprehensive documentation, examples, and information about browser compatibility.

## Conclusion

Understanding the `typeof` operator is essential for new JavaScript developers as it helps clarify the nature of various data types within the language. If you have questions, don't hesitate to look up resources like the MDN documentation for guidance as you advance in your JavaScript journey.

Thank you for watching! If you found this video helpful, please like and subscribe for more content. Until next time, peace!

Welcome back to NBK Tech World.
In the last video, we learned some basic math in JavaScript.
Now in this video, I would like to introduce you to an operator called TypeAuth.
It's not that big of a deal, it's not something you're going to use a lot when you're out
there developing your application, websites, and so on.
But it's very useful to learn what's going on behind the scenes in JavaScript.
So it's like I'm going to introduce it to you so that you can be curious about JavaScript,
about the things or the objects, number of strings, whatever it is that you might already
know, might expect or might not even know.
So let me start off here.
I want to, I want to switch to Chrome now because we did so far the next time.
I want to do some, so I'm here in the browser console.
Let's make this bigger for you.
So the operator is called TypeAuth.
Now this guy is going to give you whatever you type after it.
You can check what the type is.
For example, remember we defined strings, right?
We have strings, say I have my name.
This is a string because it has single quotes.
What is the type of this guy?
Well, it's going to tell you it's a string, okay?
So we learned this guy is a string.
Now let's try a number.
One, two, three.
What's the type of this guy?
That's a number.
Whoa, it's not a string.
It's a number.
So it's different, right?
So wait a minute.
What's the type of this guy?
Just follow the basic principles.
This guy is in quotes, so it's got to be a string.
It's not a number.
All right, so there's that difference.
So be aware.
A number inside quotes is not a number.
It's actually a string.
Now there are other things, other kinds of things in JavaScript that we haven't learned
yet, but I can introduce to you now just to illustrate how the type of can help you learn
JavaScript and help you define kinds of things, all right?
So let's try an array.
I'm going to put an empty array here for you.
So an array is an object.
Remember that.
You probably won't, but it's a very important thing to know in JavaScript.
But you don't have to know.
Let's just illustrate type of, what about this guy?
That's an object too.
So these braces, whatever that is, we don't know it yet, right?
We haven't learned, but it's called an object.
Let's try something else.
Remember we learned that function console log?
What is the type of console.log?
Wow, it's a function.
Yeah.
So it is indeed a function as we learned before.
Now what else can we have?
Ah, how about this?
I can type this word true.
What is the type of this word?
Boolean.
What the heck is a Boolean?
So true and false are special keywords in the language of JavaScript.
And it's called a Boolean value.
It just means true or false, all right?
Something is true, something is false.
It's like a switch on and off.
So think of that that way.
So the word true doesn't have quotes.
It's called a Boolean.
So what's the opposite?
I want you to try.
Please try the opposite of true, which is false by the way.
Type of false.
It's also Boolean.
Okay, so we have true and false and we learned about Boolean.
Okay.
Now, this little thing in JavaScript called undefined.
I want to introduce undefined.
It's also a special keyword in JavaScript, a very weird thing.
And the type is undefined.
It's weird.
Yeah, but that's JavaScript for you.
Anyway, we learned the type of operator to learn about the nature of things in JavaScript.
We started off about the things we already knew, strings and numbers.
And we learned the difference between, again, that a number is not a number under quotes.
A number under quotes is a string, not a number.
We learned about an empty array, an object.
Actually, we're going to learn a lot more about these later, but I just wanted to illustrate
that they're both an object.
We learned, confirmed, right, that log is actually a function.
Indeed, it is.
We learned about new kinds of values in JavaScript, true and false.
They're so-called Boolean.
And then we learned about undefined, this weird thing in JavaScript, which actually
is undefined.
Now, what I want to leave through is reference.
So you can start, get started with getting to know how to reference things in JavaScript,
where to look for things, like you're doing your development and you forget certain things.
That happens a lot, by the way.
So I need some kind of guide or reference for me to look up things when I forget.
So I want to give you a reference for all several types, for the types in JavaScript.
So if you go and do a search, here I'm just going to search type of JavaScript.
This way, you can get a very good documentation online.
The one I want to direct to you to is the one from MDN, the Mozilla Developer Network,
which came out first on this search engine, type of.
So I'm going to choose this one.
So it's the type of documentation from MDN, that's the developer.mozilla.org.
It's pretty good documentation, in my opinion.
And you can get some examples here.
But what I want you to see is if you scroll down here at the description section, you
can get some types, JavaScript types here.
We learn number, there are numbers in JavaScript, there are strings.
And today we learn this video about Poolean, the weird undefined, learn about the function
type, the object type, and there are others here you can see.
So if you forget, there's always this nice reference table you can look up.
Give you mind MDN is a very good documentation, not only for this specific case, but for all
other questions that you might have.
As you get more advanced into JavaScript, you're going to be doing more complex stuff.
You might forget a lot of things that happens a lot.
And you have to look it up and review and remember them again.
So very good reference with good examples here, console log type of whatever and gives
you the output.
Very nice.
All right.
So that's MDN.
Also a very nice thing I forgot to mention is at the bottom here, you can see the browser
compatibility because not everything is going to work on every single browser.
So you have to make sure as you're out there in the real world developing applications
that you have to cover.
You might have to cover multiple browsers.
So no one on our browser support the same thing.
It used to be very predominant back in the day.
It will be browsers did things differently.
So you have to account for one browser and then figure out how to fix issues for another
browser.
But these days is pretty getting standard among different browsers.
There's a standard and it's much less headache now, but be aware of browser compatibility
or right.
And IE specific notes.
Oh, no.
Anyway, thank you so much for watching.
And please like and subscribe and until the next time.
Peace.


fff8-06 The typeof Operator

String Concatenation in JavaScript

# Summary of the Lesson on String Concatenation in JavaScript

## Overview
This lesson from NBK Tech World teaches you about string concatenation in JavaScript using variables to insert dynamic values into strings.

## Key Concepts

1. **String Concatenation**: This process combines strings with values from variables to create a complete message.

2. **Defining Variables**:
   - **Name**: `const name = "YourName";`
   - **Age**: `const age = YourAge;`

3. **Printing to Console**:
   - Use `console.log()` to print strings that incorporate variable values.

4. **Using Variables in Strings**:
   - Simply placing a variable within quotes outputs the variable name, not its value.
   - To incorporate a variable's value, use the `+` operator for concatenation.

5. **Example Message**:
   ```javascript
   console.log("Hello my name is " + name + " and I am " + age + " years old.");
   ```

6. **Spacing**:
   - Ensure to manually add spaces in the strings to separate the words properly.

## Step-by-Step Process
- Start with the static strings and use `+` to concatenate them with dynamic variable values.
- Break the final sentence into smaller parts for clarity.
  
## Challenges
- Participants are encouraged to practice by completing sentences and experimenting with console logging different messages using their own variable values.

## Conclusion
The lesson emphasizes the importance of understanding string concatenation and encourages viewers to practice with their own variables.

### Call to Action
If you found the lesson helpful, consider liking and subscribing for more content.

Welcome to NBK Tech World. This lesson will be about string concatenation in
JavaScript. Let's suppose we want to print to the console the following sentence.
Hello my name is blank and I am blank years old. Let's say that the values in
the blank are going to be filled with the values from two variables. One from the
variable called name and then another from the variable age. Remember we did
that before? We learned how to define a variable. We define our name and we define
our age previously in another lesson. Now we're gonna combine that with this
predefined string like we're gonna print to the console. Hello my name is blank
and I am blank years old. So to do that we're gonna learn the cause of a
concatenation. That is we're gonna combine strings with the value from
variables. In this case we're gonna have this string here combined with the value
from the variable name, combined with this string, combined with the value from
the variable age, combined finally with this string. Okay so let's get started.
First let's define the variables. Remember how to define variables? I'm gonna
cut this. Let's first define the variable name. So we're gonna say cost name and you
can say your name there. I'm just gonna say my name like so. Then I'm gonna define
another variable for the age. Cost age is whatever your age is. I'm just gonna
make something up. Alright the reply. Now as you can see there's my name is there
and age is there. So we're all good. Now what we have to do is start. We want to
print the message to the console. So what function allows you to do that? That's a
live function from the console object. So console.log and then whatever you
want to say here. So in this case we're gonna say that message. Hello my
name is blank and I am blank years old except these values here have to come
from the variables we defined previously. This is gonna come from name and this is
going to come from age. So now to do that you got to do what's called a
concatenation. You can't just put the variable name like here. If you put name
like so it's just gonna say hello my name is name. It's not the actual variable
here because this is just a string. Remember anything within the quotes is
just a string. In this case it will just appear as it is. So you have to find a
way to somehow tell it hey don't use the actual name text literally but use the
value from the variable called name. So as we previously learned right if you
just console.log name like so without the quotes that's actually gonna be the
console.log variable. The value of the variable name substituted here so we
actually get my name. But if you console.log name under quotes say you're
gonna get the actual text name right which is just a string. This is not a
variable. So what we have to do is what if you do like so you add a plus here and
you say name. See what we're gonna get here. So name as it is appeared here and
then followed by whatever the value of this variable is and this gets my name.
So you can see name immediately followed by my name. So this is called a
concatenation. So we concatenated this string with the value from this variable
and it amounted to this string right here. Notice the spaces between the
operator the plus operator don't really matter. It will not reflect in this guy.
If you want actually want a space there you have to add it yourself to the string
say to the name space. See the space right here. Like so. Okay now the space will
appear. So following this logic here we can do the same for our big sentence as
before. Let me do a console.log again. I'm gonna paste that thing we had before.
Now we're gonna do I challenge you to do the same here except you have to break
this guy apart right. So you cannot just have name here. You have to do a
concatenation right here. So you have to use this string here make this guy's a
isolated string and then you put a plus variable name and then plus the string
and so on. Let's just start with the first part. Let me get this other part out of the way.
Let's just start simple. Let's do hello my name is whatever right. So hello my name is and then
there's a space here whatever. How can you add that whatever you can say plus and the variable name.
So this is gonna say hello my name is space whatever the value of the variable the value
whatever value the variable called name is holding. So as you can see you get hello comma my name is
and my name which is the value stored in the variable name. Okay so this is called concatenation.
All right so I challenge you to complete the sentence and do more concatenation to
finish the sentence we had before which is hello my name is blank and I am blank years old period.
You can pause the video and do it and then we'll do it together later.
So how did it go? So we have hello my name is and then we're gonna add another string here
and I am blank right. We have to have the space here otherwise there's not gonna be a space
and then you put a plus by convention I always put spaces between the before and after the plus
that's the convention okay you don't need any have to have it but it's a good convention to follow okay.
Let me just leave it without space so you can see it doesn't really matter. I am blank so the blank is
gonna be substituted with the variable here what's the name of the variable that holds the age called age
like so no strings because no quotes I mean because there's not a string it's an actual variable
that's holding some value that we want to be substituted here right
and then I am blank space years old right. I forgot the period here
and then you see hello my name is my name and I am blank the blank now substituted with the value
from the variable age in my case 35 and then followed by the string space year space old followed
by a period okay notice there didn't matter to have a space before after the plus it's just a
good convention to make things look clean and organized okay. So let's review what we did
so what we did is called a concatenation so if you have a string and you want to display in the
string like the value of some variable in this case we have the name and the age stored in two
variables then the variable name and the variable age you want to display them together inside a
sentence right to do that we have to break the things into smaller pieces right we have to break
this guy into this string followed by the variable here which is going to substitute its own value
and it's going to be added to the ultimately to the final string here followed by another string
followed by the variable age followed by the string okay so we use the plus sign for concatenation
okay
so that's it for this lesson and now you can practice do a console log of many
kinds of messages you can define variables and use those variables to substitute their value in
the final text for the log here okay thank you so much for watching if you like this video please
click like and subscribe until the next time then bye


fff8-07 String Concatenation in JavaScript

String Interpolation in JavaScript

```markdown
# MBK Attack World: String Interpolation in JavaScript

Welcome back! This lesson is a follow-up to the previous one on string concatenation in JavaScript. Today, we'll explore **string interpolation**, introduced in ES6 (ECMAScript 2015). This method simplifies the process of including variable values in strings, aligning with patterns found in other programming languages.

## Key Points

- **String concatenation** requires breaking the string into parts using the plus sign (`+`). For example:
  ```javascript
  console.log('Hello, my name is ' + name + ' and I am ' + age + ' years old.');
  ```

- **String interpolation**: Using backticks (`` ` ``) instead of single quotes allows for easier variable substitution without breaking the string apart. Here's how it works:
  - Use backticks to enclose the string.
  - Substitute variables within the string using the syntax: `${variable}`.

### Example

Given variables:
```javascript
const name = 'My Name';
const age = 35;
```

Using string interpolation:
```javascript
console.log(`Hello, my name is ${name} and I am ${age} years old.`);
```
This outputs:
```
Hello, my name is My Name and I am 35 years old.
```

## Important Notes

- Always use backticks (`` ` ``) for string interpolation.
- Ensure you are using a modern browser that supports ES6 features. Older browsers may not support this syntax.

Thank you for watching! Please like and subscribe, and see you next time!
```


Welcome back to MBK attack world. This lesson is a follow-up to the previous
lesson about string concatenation in JavaScript. I would like to give you an
alternative for a string concatenation and that is the string interpolation.
The string interpolation is something actually new in the JavaScript version
ES6 so-called acromascript 2015 and it makes things a little bit more
convenient and follow other programming languages patterned for a string
interpolation. So let's have a look at it. So we're gonna do the same example we
had before. If you don't remember let me recall here we had this message hello my
name is whatever and I am whatever your zone and where these values were
actually blanks that we had to substitute with the value coming from a
variable in this case the variable for the name and the variable for the age. So
we wanted to display this message in the console and we use console log to do
that. Now what we did before was using concatenation using the plus sign right
so we have to break things apart have this string here followed by the variable
followed by a string followed by the variable followed by the string. So there's
actually a way now to do that in JavaScript so that you don't have to
break the string apart into smaller pieces to actually substitute the value
of a variable right here okay. So the way we're gonna do that it's called a string
interpolation okay interpolation and to do that we will not use a single quote
for the string instead we're gonna use the back tick. If you have an American
keyboard the back tick is the one right under the tilde which happens to be
typically under the escape key in the case of for the Mac next to the number
one key okay so it's this guy right here you see the back tick so we're gonna use
that guy instead of the single quote okay because the back tick in JavaScript
will allow us to have to do the string interpolation so if you don't have that
it will not work. So make sure you're typing the back tick back back tick. So
let's go so we're gonna do the following we're gonna do the console log as we did
before and instead of using the single quote we're gonna use the back tick. Back
tick face the text you want to print to the console and then what we're doing
the blanks is the following you go to the blank whatever value from a variable
you want substitute and you're gonna do the following you're gonna put a dollar
sign open braces curly braces and you inside this curly braces you have to
say the name of the variable whose value you want to substitute here in this case
the variable is called name okay we define it previously if you go up here
we define name a constant name as my name or your name whatever you want and
concepts age I made it up 35 okay and then we use those variables here and
their values are going to be substituted here where this dollar sign with the
curly braces is okay so let's do the same for the other blank the other blank
is for the age dollar sign over and close curly braces and then inside you
give you have to say the name of the variable this case the variable is called
age so age holds the value right now 35 so you expect to 35 to be substituted
here for name my variable has the value my name which will be substituted here
okay so this is called string interpolation let's finish it up with
the closing oops actually already had it another line finish it up and enter
okay so hello my name is my name and I am 35 notice the value of the variable
age is substituted here years old okay so this is string interpolation using the
back tick and JavaScript ES6 okay make sure when you try this you always have
the latest version of a modern browser because they should support the ES6
notation okay if you are using a really old version of a browser that does not
even support ES6 you might this might not work okay anyway so that's the
string interpolation of the back tick and with that we end this lesson thank
you so much for watching and please like and subscribe and until the next time
bye


fff8-08 String Interpolation in JavaScript

Comparison Operators in JavaScript

```markdown
# JavaScript Comparison Operations

Welcome back to NBK Attack World! In this video, we will explore comparison operations in JavaScript.

## Key Points Covered:

1. **Basic Comparison Operators**:
   - Greater than (`>`)
   - Less than (`<`)
   - Greater than or equal to (`>=`)
   - Less than or equal to (`<=`)

2. **Boolean Values**:
   - The result of comparison operations will yield a boolean value (`true` or `false`).

3. **Examples**:
   - `7 > 4` returns `true`
   - `4 > 7` returns `false`
   - `5 <= 5` returns `true`
   - `100 >= 33` returns `true`
   - `101 >= 100` returns `false`
   - `100 >= 100` returns `true`

4. **Styling**:
   - It's a good practice to include spaces before and after operators for clarity, although it's not mandatory.

5. **Equality and Inequality**:
   - To compare equality, use double equal signs (`==`).
   - Example: `2 == 2` returns `true` while `2 == 3` returns `false`.
   - For inequality, use an exclamation mark followed by an equal sign (`!=`).
   - Example: `2 != 3` returns `true`, while `4 != 4` returns `false`.

## Conclusion
We reviewed how to use comparison operators in JavaScript, enabling you to compare values and obtain boolean results effectively. Practice using these operators in your browser console to deepen your understanding.

Thank you for watching, and keep practicing until next time!
```

Welcome back to NBK Attack World
on our journey to learn JavaScript
So guys, this video will be about
comparison operations in JavaScript
We're going to do some mathematical comparisons
We already learned some math that JavaScript can do some basic math
addition, subtraction, multiplication, division
We're going to talk about comparison, we're going to compare things
Remember the greater than, less than, greater than or equals to
equals to that kind of stuff, so we're going to do it right now
So let's start with
greater than. To do a greater than for example
number 7 is obviously greater than 4
So we can do the greater than
the result of this operation if we press enter right now, it's a
value that's either true or false
Remember that value is called a boolean
So this comparison
7 is greater than 4
That's going to be true
Now if I put 4 greater than 7
it's obviously false, right?
So that's comparison, JavaScript
in your browser console
Now we know 4 is less than 7, so we can do less than
and if you want it to be less
than or equal to, you can do like so
You put the less than sign followed by the equal sign together
and if I put 5 less than
or equal to 5 is going to be true
By convention I always put a space before and after the
operator just to make things clean, but you don't have to have it
You can do like this, it's fine, but I strongly advise
you to have this style
Now let's learn greater than or equal to
100 is greater than or equal to what? 33? True
But if I put 101 it's going to be false
If I put 100 it's going to be true
So there you have it
Let's review, so we learn greater than
less than, greater than or equal to, less than or equal to
Right? I assume you already have a mathematical background
So that's why I go a little bit quick on these
So I just wanted to know that these comparison operators are available to you
in JavaScript and you're going to be using them a lot
So don't forget them
You can just open up your console and practice using these operators
to see what you get, true or false
Now let's go on and learn about equal or not equal
So let me clear this
Where's the Chrome? Is a clear console right here? This icon
Now the two, verify that for example two is equal to two
You would have to use, well mathematics
is a single equal sign, right?
Actually in programming typically the single equal sign will mean
assignment operation when you like the finding variables
That's why we have to do a double equal sign
for comparison, okay? So be careful with that
When you're doing the equal to two, it's two equal
to two, you have to use the double equals
Okay? And this is going to be true
But two is not equal to three, is it? False
Now if you want to say, okay, I want this guy
not equal to, where you going to use the
exclamation point, okay?
So unfortunately we cannot type the, we can type
the character with the equals with the bar
on top, crossing it, but that's not very convenient to type it
on a keyboard, so the way they do not equal to is with
the exclamation with equal sign, okay?
So that's not equal to
In this case two not equal to
three, that's going to be watched, true or false?
True, okay?
Now it's four not equal to
four, that's obviously false
Okay, looking good
So let's review, double equal to equal to
exclamation point and equal to not equal to
AKA different
Alright?
So that's it for comparison operators in JavaScript
You'll learn how to compare greater than, less than
greater than or equal to, less than or equal to
and not equal to
Hope you liked this video and keep on practicing your browser console, try different numbers
and different comparison operators to see what you get
the boolean values, right, true or false? Thank you so much for watching
and until the next time, bye!


fff8-09 Comparison Operators in JavaScript

JavaScript Variable Reassignment with let

# NBK Tech World - Lesson Summary

In this lesson, we learn about assigning values to variables in JavaScript, focusing on the difference between `const` and `let`.

## Key Points:

1. **Defining Variables**:
   - Previously, we learned to define a variable using the `const` keyword. For example:
     ```javascript
     const name = 'my name';
     ```

2. **Reassigning Values**:
   - If you try to change the value of a variable defined with `const`, you will encounter an error:
     ```javascript
     name = 'other name';  // Error: Assignment to constant variable
     ```

3. **Using `let`**:
   - To allow reassignment of variable values, use the `let` keyword:
     ```javascript
     let lastName = 'my last name';  // Initial assignment
     lastName = 'another name';  // Successful reassignment
     ```

4. **Differences between `const` and `let`**:
   - `const`: The variable's value cannot be reassigned after its initial definition.
   - `let`: The variable can be reassigned multiple times.

5. **Best Practices**:
   - Start with `const` for variables that will not change, and switch to `let` if reassignment is later needed.

6. **Naming Conventions**:
   - Follow the camel case convention for variable names:
     - For example, `anotherName` where the first letter is lowercase, and the first letter of each subsequent word is uppercase.

## Conclusion
Using `const` and `let` correctly allows for better management of variables in JavaScript, encouraging clear and maintainable code. Additionally, following naming conventions like camel case improves readability. 

Thank you for watching, and see you in the next lesson!

Welcome back to NBK Tech World. In this lesson we're gonna learn how to assign a
value to a variable more than once. Previously we learned about the keyword
cost to define a variable. We defined a variable name for example with your name
as gave my name and we can use a variable later. I got this error because I
had already defined name but it's here defined. So the problem now is what if I
want to change the value of name. I want it to be something else somebody else's
name how would I do it. What if I just try doing like so I say name again and
whatever other name. You might notice because I already tried to do that before
here and name has already been declared. Okay that's because I is cost let's see
what we get if I do like so. So I get another error. I tried to assign the
string other name to the variable name which was already previously defined
with the value my name right using the cost keyword and we got an error saying
assign it to constant variable was a type error whatever that means right. So
actually the variable cost only allows you to assign a value to a variable
once. If you try to reassign the value again later you will error out like so.
So if you really want to be able to change the bad variables value later if
you want to reassign it then you have to use the another keyword and that's
called a let okay. So we're gonna let something be whatever. So let's try again
let's make up a new variable. I'll call it say last name for example so we're
gonna say let okay then the variable name I'm gonna say last name and give
something my last name whatever okay. So this is gonna define a variable just like
we learned before the variable is called last name and has the value my last
name to confirm you can type it here. Just like before nothing changed but we did
use the keyword let which will allow us as you're gonna see right now to reassign
the value without any errors. So if I say last name is another name you say
it worked no errors so I can say that's name and now the value is another name
it totally changed okay. So that's the difference between lat and constant in
JavaScript ES6. So using lat will allow you to reassign a value if you already
assigned a value once you cannot do it again if you did use constant but if you
use lat you can do it as many times as you want. So we reassigned last name to
another name you can do it again. Last name is yet another name and it will
work just fine and you can see the value of last name is now yet another name
okay. So two ways to define a variable in JavaScript ES6 constant versus the lat
constant. The rule like typically if I would do it I would always start with
constant and define a variable of constant and then if I figure out a later
I need a variable to change its value I would change that constant to a lat okay.
So that's my own personal rule you can try that too. So I will start a constant if I
find out a later on oh no I have to reassign the value to this variable
second not use constant anymore I'm gonna switch and constant with lat.
Alright and just to finish it off I would like to give you some convention let
you know that notice I used the variable name last followed by uppercase
name that's a camel case convention in the JavaScript that we use in JavaScript
language so it's called a camel case. So for example if you have different words
like I don't know another name like so you have two words right when I want to
make a variable name my convention for naming the variable I will use another
and then since I have another word name I capitalize the first letter and say
like so. So this is called the camel case naming convention alright so another
name and then becomes like that you have two words so for every new word that you
add to the variable name capitalize first letter notice that the first letter
very first letter of the variable name is lowercase not uppercase so it's a camel
case okay so that's it for this lesson hope you all liked it and until the next
time thank you so much for watching and the K-Tag world bye


fff8-10 JavaScript Variable Reassignment with let

Introduction to JavaScript Functions

# Summary of JavaScript Functions Lesson

## Introduction
- The lesson covers the concept of functions in JavaScript.
- Functions are blocks of code that perform specific tasks and may take inputs to produce outputs.

## Understanding Functions
- Previously, we called the `log` function from the `console` object to display messages.
- Now, we'll create our own functions.

## Creating a Function
1. **Define the Function**:
   - Use the `function` keyword followed by the function name (e.g., `sayHello`).
   - Include parentheses for input parameters (can be empty).
   - Define the function body within curly braces `{}`.

   ```javascript
   function sayHello() {
       console.log("Hello World");
   }
   ```
2. **Function Call**:
   - After defining, you must call the function by its name followed by parentheses to execute it:
   
   ```javascript
   sayHello(); // This will log "Hello World" to the console
   ```

## Benefits of Functions
- Functions can be called multiple times, reducing code repetition.
- If changes are needed (e.g., changing "Hello World" to "Hello People"), update only the function definition:
  
  ```javascript
  function sayHello() {
      console.log("Hello People"); // Changing the output here updates all function calls
  }
  ```

## Key Takeaways
- A function is defined using the `function` keyword and can have zero or more inputs.
- Calling a function executes its instructions.
- Using functions helps avoid repeating code, making maintenance easier.

## Conclusion
- This lesson provides a foundational understanding of creating and using functions in JavaScript.
- For further learning, like and subscribe for more content.

Welcome back to NVK Tag World. This lesson will be about JavaScript functions.
We heard that before, the word function, right? We called the log function from the console object before,
and we used that to display some text in the console.
So we did what was called a function call. We called upon the log function to display some message to the console.
Now we're going to create our own functions. We're going to build them.
So a function typically has an input, some input that you provide, and then it does some processing,
and then at the end it gives you back some output.
So in this case for the log function we gave as input this string, and then it outputted it to the console.
Now we have to create our own functions now. Now to create our own functions, we're going to use the keyword function.
Okay, and then you give your function a name. Let's say we want to just write a function that will display Hello World,
specifically to the console. Let's say the name of the function, I'm going to call it say Hello,
and then you have to add some parentheses here, and these will be a list of inputs to this function.
But let's say we don't have any input for now, so we can leave it empty.
Alright, so you open the braces here, and let's break the line, and I'll put two spaces that by convention for the indentation.
And then we're going to do console, log, Hello World. This is the structure this function is going to take.
So if you call say Hello, what it's going to do is whatever you write in between the opening and closing braces.
This is the body of the function, and it could be one or more statements.
In this case it just does the call to the console log, which by the way is yet another function.
So you can have functions being called inside other functions that's perfectly fine.
And this will log Hello World to the screen.
Now when you press enter, you're only going to define this function, but it will not be called.
So you're just providing the set of instructions for what's going to happen if you happen to actually type say Hello.
If you call say Hello, it's going to do these steps.
Now with that enter, we just define the function. Now if you actually want to run that function, you have to say the function name followed by the parentheses.
Remember, whenever you see parentheses, you would typically think, oh, function.
So what's going to happen when I press enter? Can you guess?
So it's going to print Hello World to the console.
So let's walk this through. The moment you say this, there's say Hello, that's the name of the function.
And then you put the parentheses. Oh, so it says, okay, you want me to call say Hello function.
It's going to go here, say Hello to the body and look at all the instructions.
And it's going to go one by one from the top to the bottom.
You're going to say, okay, you want to log Hello World to the screen. Let's do it.
So it did it. And then it reached the end. Nothing else to do.
Comes back here. Okay, that's it. Okay.
So we created our first function.
Now you can call the function multiple times, right? You can do it again and again and again.
So it doesn't matter how many times you call it. I was going to do whatever you told it to do.
So that's very useful. For example, if we had a program, let's open up my open up text editor here.
Suppose I have a program that actually did this very simple thing of logging the message Hello World to the screen.
But it did it at multiple points in my program. Not necessarily in order, but it could say Hello World and do whatever.
And then after a while, it comes to some part where it does Hello World again and then does something else and then Hello World again.
You see, I'm doing the same thing over and over. So if you find yourself doing things over and over again,
that might be a good sign that you can actually take that and put it into a function and then just call the function.
And the advantage to that is, for example, if I wanted to change the message here, say I don't want to say Hello World anymore every time.
I want it to be something else. So if you had to change it, there will be four in this case.
Instances where you have to go here, the first one, and change, I don't know, Hello People.
And then, okay, I have to change this one too and this one too.
And you see, I'm doing so much repetition for the same thing and they all do the same thing.
So what you do is actually just define this guy, this statement.
You make a function like we did before, say Hello, and then you open the body and you take this guy,
and you put that in the function. And then instead of doing this explicitly, just call the function here,
every time you need to actually do the console log, I use my text editor or the Atom text editor to select multiple lives, by the way.
And you can just say Hello every time you want to say Hello whatever, right?
And then you call it here, say Hello, say Hello, say Hello four times.
And then if you actually want to change the message, oh, I don't want to Hello People anymore.
I want a Hello World. I want it back to Hello World.
So you only have to change one line. Only change the function definition here.
And then everything else, once you call the function, will call Hello World.
So instead of changing every single instance of the console log, you take that, put it into the function,
and then you only need to make the change to the function and nowhere else.
Okay, so that's one of the advantages of using a function.
Okay, now let's take a deep breath and go back a key here to the console to review.
So previously we had now, we learned how to call a function, we called the log function from the console object to print a message to the console.
Now we wanted to create our own functions or all set of instructions to be called every time you need something done.
And we created a function called say Hello.
You put the keyword function before name the function and some parentheses.
This is going to be the argument list. Okay, the parameters of this function takes, but in this case there's nothing.
So it doesn't really take any input, but it does produce some output,
which is the console log instruction here that we added.
So if you want to call a function, all you have to do is the name of the function followed by the parentheses.
Okay, in this way, and it will do whatever instructions were you told it to do in the definition to the function here in the function body between the curly braces.
Remember, when you type the function definition and you type enter, it does not actually call the instructions, it just defines the function.
If you want the instructions to be executed, you have to call the function by its name followed by the parentheses.
Okay.
So that's a very brief introduction to the function in JavaScript.
And I hope you like this video.
Please like and subscribe and I'll see you next time.
All right.


fff8-11 Introduction to JavaScript Functions

JavaScript Functions with Parameters

# Summary of MDK Tech World - JavaScript Functions with Parameters

## Introduction
In this lesson, we will expand on our understanding of JavaScript functions by adding parameters, which serve as inputs to functions.

## Key Concepts

1. **Parameters vs. Arguments**:
   - **Parameters**: Defined in the function declaration and specify what inputs the function will accept.
   - **Arguments**: Values supplied to the function when it is called.

2. **Function Definition**:
   - The structure for defining a function includes the `function` keyword, the function name (e.g., `sayGreeting`), followed by parentheses for parameters, and curly braces for the function body.

3. **Creating a Greeting Function**:
   - Define a function called `sayGreeting` which takes in two parameters: `name` and `age`.
   - Use console.log to display a message, utilizing **string interpolation** with backticks.

   ```javascript
   function sayGreeting(name, age) {
       console.log(`Hello, my name is ${name} and I am ${age} years old.`);
   }
   ```

4. **Calling the Function**:
   - To call the function, provide the arguments that correspond to the defined parameters:
     ```javascript
     sayGreeting("My Name", 35);
     ```

5. **Indentation and Style**:
   - Recommended to use consistent indentation (e.g., two spaces) for readability.
   - The use of semicolons at the end of statements is a matter of personal preference; they are conceptually necessary but not always enforced in JavaScript.

## Review
- **Parameters** are defined when creating the function and can be multiple, separated by commas.
- **Arguments** are values that replace the parameters when the function is called.
- You can test different inputs to see varied outputs from the `sayGreeting` function.

## Conclusion
This lesson covered how to define a function with parameters, use string interpolation, and the importance of coding conventions for readability and consistency in programming.

Thank you for your attention, and practice using the `sayGreeting` function with different arguments!

Welcome to MDK Tech World. In the previous lesson we learned about JavaScript functions.
Now we're going to go a little bit further in our learning of functions.
We're going to learn how to add parameters to our functions.
Those are the inputs given to the function.
To do that we're going to use an example that we previously used.
Remember the Hello My Name is blank and I am blank years old.
We use this to display a message like this where the first blank would be somebody's name that was stored in a variable called name
and then somebody's age stored in a variable called age.
We use this, we display this message to the console using the console log function.
Now what we want to do in this practice, this challenge, the challenge is to follow me.
I'm going to write a function that's going to do precisely this.
We're going to do a log of this message except we're going to take the name and the age as parameters as arguments to the function.
So when I say parameter and argument they're sometimes used interchangeably.
When you call your function you pass the function arguments.
When you're defining a function you typically define the parameters.
Those parameters are actually what you give as arguments when you call the function.
So keep in mind there's a slight difference in the usage of the word depending on the context situation.
So let's start writing the function.
The first thing you have to say is what? What's the keyword?
Keyword is function and then followed by space followed by the name of the function.
Let's call this function say greeting for example.
And then you pass what? You have to write the two parentheses like this and then the curly brace.
And inside the curly brace you write the set of instructions this function is going to perform.
In this case we want to do a console log of whatever the message was.
Let's use string interpolation remember string interpolation use back tick and then here let's paste the message.
Wherever you see the blank you're going to put the dollar sign with the two braces and inside this has to be the variable name.
Let's call this variable name name and then the other one age as like we did before.
Except now we have not defined these guys previously right and we expect these guys to come from the function input.
Okay, so whoever's going to call say greeting has to provide the name and the age so that the console log is going to display something here in the name and the age.
So to do that you're going to go here see the parentheses.
This is going to be your parameter list.
The function takes several parameters could be zero or more.
This case you're going to take the name and the age as parameters the parameters are a listed comma separated.
So first parameters name if you want one more parameter you have to put a comma followed by another variable name.
You don't have to have a space here but by convention I was put a space here.
So I highly encourage you also follow this convention.
Okay.
So let's just reveal a little bit what we did.
So we're defining we're declaring this function.
Okay.
And name is say greeting.
It takes two parameters takes the some name and age.
Then the instructions to this function inside here the function body in between the curly braces is like so you do a console log of this message.
And inside the message it's going to interpolate whatever value store in this variable called name and whatever value store in this variable called age.
And these variables just so happens to come from the function parameters.
That's the input that is going to be given by whoever calls the say greeting function.
Okay.
So we just enter here and then we're going to do is we're going to try calling it like by the name and then we have to give the input say greeting.
Now first input has to be named.
So you can say your name as a string.
Now the second one has to be separated by comma has to be the age and we're just make it up like before like so.
Okay.
So the function name and then you give a list of arguments.
So when I do in the function call typically call these guys arguments that are passed to the say greeting function.
And these are the parameters.
So this value is going to be mapped to this variable called name and this value 35 is going to be mapped to this variable called age.
And these are be referenced inside the log here.
So let's try it out.
So as you can see after calling say greeting we got the message hello my name is my name and I am 35 years old.
So let's just look at some other things here in the function.
You may notice that I always type like two spaces in the function body every time I open the curly brace.
That's an invitation convention.
It's very common when you do programming.
It used to be traditionally a tab but these days we plus to do spaces and in because I do web development.
I got into the habit of always using to space indentation so I would always add two spaces every time after I see opening curly brace like in the function definition to make things look nice and see OK this is part of the body of the function and not something else like on the same level.
You can look into that if you want to get to know that more.
It's just a convention that makes the code easier to read as you have a lot a lot of code working with a huge like a group code base.
So that's a good style and practice.
You should be following from early on in your learning.
So I strongly suggest you always put the invitation when you see an opening curly brace at say my case I was just two spaces.
You can use for the web development typically to these days.
All right.
So other thing I want to point out is we haven't really used a semi colon before.
And this is something that you would always add at the end of every statement.
OK.
So this is a statement right here and at the end you put the semi colon.
So this comes from programming in a C language.
Every statement has to end in the semi colon.
But when JavaScript came about it's not really like necessary to have it but people who added anyway just to be consistent and they might you might get end up having some bugs because they forget to do some things or combine statements.
But so the take is some people there are people who like to have it versus people who don't want to use it.
In my case I always like to have it.
So that's my recommendation for you.
But you don't have to follow my standard.
Feel free to look into that to some research and choose your side.
I will always put a semi colon when I'm writing JavaScript here like a writer function a statement at the end of the statement semi colon.
OK.
I didn't do much of this before when I started the course because we're just doing the JavaScript console.
We're not really writing a program source files that if we had a like a big program in an actual external file it's not just the console.
I would always add the semi colon.
So you might not see me adding semi colon every time here.
And that's because of that.
Like I didn't add a semi colon here but he actually could have added.
So it doesn't hard to add one.
All right.
So keep that in mind as you walk in your journey.
So enough of that.
So thank you for watching and just just a little bit review before we end the video.
So we learned how to define our own function with parameters and parameters can be none like we did before say hello.
There was no parameter but now we added we made a function called safe reading with two parameters.
If you have more than one parameter separate them with a comma.
OK.
And then these parameters they'll be mapped according to how how you pass the arguments when you call the function.
It will be in order.
My name will be mapped to the first argument parameter here.
Thirty five map to the second here and those will be available as a variable inside the function body like I did here.
All right.
So and what's good about this is that you can say say reading with different inputs and get different outputs.
So if say another name and twenty nine.
I forgot to say the quote here.
If you say like this you expect a different message.
So you're going to say hello.
My name is another name and I am twenty nine years old and you can try different inputs and see the different outputs that you get.
That's an exercise I'm going to leave to you to try different things with the same reading method.
OK.
So thank you so much for watching until the next time.
Bye.


fff8-12 JavaScript Functions with Parameters

Converting String to Upper or Lower Case in JavaScript

# Summary of String Operations in JavaScript

## Lesson Overview
In this lesson from NVK Tech World, we learn about basic string operations in JavaScript, specifically converting strings to uppercase and lowercase.

## Key Concepts

### Understanding Strings
- Strings are sequences of characters enclosed in quotes.
- Strings can be used to store messages or names.

### Converting Strings
1. **Uppercase Conversion (`toUpperCase`)**:
   - Example: For the string "Hello World", the first letters "H" and "W" are originally uppercase.
   - To convert the entire string to uppercase, call the `toUpperCase()` method.
   - **Syntax**: `string.toUpperCase()`
   - This method returns a new string with all characters in uppercase without modifying the original string.

2. **Lowercase Conversion (`toLowerCase`)**:
   - Example: For the string "HI THERE", all letters are in uppercase.
   - To convert the entire string to lowercase, call the `toLowerCase()` method.
   - **Syntax**: `string.toLowerCase()`
   - This method also returns a new string with all characters in lowercase.

### Using Variables
- To work with strings stored in variables, define a variable using `const` or `let`.
- Example of variable declaration:
  ```javascript
  const name = "John Someone";
  ```
- To convert the name to uppercase:
  ```javascript
  name.toUpperCase();
  ```
- The original variable `name` remains unchanged. If you want to update the variable, use `let`:
  ```javascript
  let fullName = "Anna Someone";
  fullName = fullName.toUpperCase();
  ```
  
### Important Takeaways
- The methods `toUpperCase()` and `toLowerCase()` do not modify the original string; they return a new string.
- Be mindful of whether a function modifies the original value or creates a new one.

## Conclusion
This lesson provides a foundational understanding of how to manipulate strings in JavaScript using basic operations. Remember that string methods typically return new strings without altering the original ones.

Thank you for watching, and see you in the next lesson!

Welcome to NVK Tech World. In this lesson, we're going to learn about some basic string
operations to turn all the characters in the string to lowercase or into uppercase. So
let's get started. So, strings as we know are sequences or characters that are enclosed
in some quotes, right? Like this guy is a string. And we work with strings before we
use the we stored our name before previously in a string. And we said some message to we
started a message inside a string. Now, we're going to learn how to do some basic string
operations here. And these operations are very basic. Essentially, we're going to take a string,
for example, Hello World. And then we're going to turn all the characters that you see in this string
into either lowercase or uppercase. So let's start with uppercase. So essentially, you have,
for example, this first letter H. In this case, it's in uppercase. But all these other letters
from the word Hello, they are in lowercase, right? And the same for the word World here, the first
letter W is in uppercase and the remaining letters are in lowercase. Now, suppose we want to turn
all of these letters into uppercase, how would we do that? So if you have a string,
like so, you can say to uppercase to uppercase is a function, okay, that if you call this function
on a string like so, it will take this string and generate a new string with all the letters
capitalized. Now notice, if I have a function call, what we have always after the function name,
do you remember? That's right, we need the parentheses. In this case, this is a function
does not take any arguments. So I leave it blank. So this guy will take this string,
generate a new string, all the characters in uppercase. So let's try it out.
So we call this function. And then we get this output, okay.
So all the letters now in this output string are in uppercase that have all been capitalized.
So this is the two uppercase function, okay, on a string. Notice that the first letter upper
and first letter case is capitalized, it's following that convention that we learned before.
It's the camel case naming convention, where each following letter after the first word
has to have the first letter capitalized and all the remaining letters in lower case.
So always keep that in mind that in JavaScript, you use this naming convention called camel case.
Now that we learned how to do uppercase, how about we do lowercase?
Suppose I have the following string.
I just have a message saying hi there, okay. Now let's take this guy and convert all the letters
to lowercase. In this case, all the letters are in uppercase, but we want them to become
lowercase. So we can say to lowercase like so. You put up a dot after the string, okay,
the quotes to lowercase following the camel case naming convention.
And then you have to pass some arguments to the function to lowercase. But in this case,
there are no arguments. So this is left in blank. So let's try it out.
As you can see, the output is a new string with all the letters in lowercase.
All right.
So that is to uppercase and to lowercase, two very basic operations on a string
Now let's learn how to do all of this if the string were in a variable.
So let's clear everything and let's define a variable. Remember how to do that.
Let's start off with cost. And let's give this variable a name. Just call it name like we did
before. Remember, we said your names and I'm just going to give a fictitious name here.
So suppose you have this person full name here, two words, John someone, you can use any name
you want. I'm just making an example. So this john someone string notice it's under quotes, right?
It's going to be stored in a variable called name. Now, let's say we want to
convert all the characters in the john's name to uppercase. How would you do it?
You cannot use the string directly because now the string is inside a variable. And we want to
be able to use the variable itself. How would you do it? Can you guess? So all you have to do is
say the name of the variable that holds the string in this case, its name, and then do the same thing
we did before. Dot two uppercase, for example, if we want to convert all the characters to uppercase,
and then that's it. You're going to get a new string with all the letters of the original string
capitalized. Now notice if I try to see what's inside the variable name now, it's still the same
thing. And why? Like I said before, every time I said what happened here, I said the word new.
So remember that that's why I said it so many times. When you do this operation, it creates a new
string, okay? It's a new string. It does not modify the original. That's why the variable name still
holds the original john someone name, like so. Alright, so the two uppercase and two lowercase,
they create, they generate new strings and do not modify the original. Now if you really want to
modify the original, what you would have to do is make the variable name changeable. Now because
I define it with the word cost, remember that I can only assign a value once. We learned before
that if you want to be able to reassign a variable's value more than once, you have to use a different
keyword when you declared a variable. That's what keyword let remember. So let's do an example.
Let full name, I'm going to create this variable called full name. Now I'm going to use let because
I want it to be changeable in the future more than once. And I'm going to call it Anna someone.
Okay, now full name. If I do full name, for example, to convert to uppercase,
as we saw before, that will generate a new string and the variable itself holding the value Anna
someone will remain unchanged. If you really want to change the full name to be all caps,
you just need to redefine the variable like so. You say full name. Now how do you define a variable?
Again, just put the equal sign to assign a new value to this variable. And then you just say full
name dot to uppercase. Okay, note that this full name here on the right hand side is going to
refer to the original Anna someone like so. Then it's going to take that generate a new string
called with the Anna someone all in capital letters, then it's going to assign that value,
this guy to the value to the variable full name. So whatever's in full name will be replaced
with Anna someone all capitalized. Okay, so let's see how it goes.
Now let's see the value of full name again. Now you can see it changed because we reassigned with
the equal operator. Okay, so keep that in mind as you're working with strings, and you have to
learn about if the output if some function, for example, to uppercase, you have to ask the question
that this does this function modify the original thing. In this case, whatever you it's on the
left hand side in this case. So I'll skip that in mind, because there might be functions that
modify the original thing. But there are functions that all that might not modify. In this case,
we're dealing with two uppercase and two lowercase. And these two functions on the string,
do not modify the original. Okay, so keep these two things in mind, doesn't modify it doesn't
modify the original as you go through your journey in JavaScript.
All right. So this is it for this lesson. Thank you so much for watching. And until the next time. Bye.


fff8-13 Converting String to Upper or Lower Case in JavaScript

String Slicing in JavaScript

```markdown
# JavaScript String Slicing Lesson

Welcome to NVK Tech World! In this lesson, we will learn about string slicing in JavaScript using the `slice` method.

## Introduction to String Slicing

- We start with a basic string, for example, "hello world".
- The goal is to manipulate the string by removing certain characters.

## Using the `slice` Method

1. **Basic Slicing**:
   - To remove the first character (H), call the method with the argument `1`:
     ```javascript
     let str = "hello world";
     let slicedStr = str.slice(1); // Result: "ello world"
     ```

2. **Removing Multiple Characters**:
   - If you want to remove the first two characters (H and E), call the method with the argument `2`:
     ```javascript
     let slicedStr = str.slice(2); // Result: "llo world"
     ```

3. **Slicing with Start and End**:
   - To extract only "hello", specify a start and an end index. Remember that indices start from 0:
     ```javascript
     let slicedStr = str.slice(0, 5); // Result: "hello"
     ```
   - The end index is exclusive, so for "hello", use `slice(0, 5)`.

4. **Extracting Other Parts of the String**:
   - To extract "world":
     ```javascript
     let slicedStr = str.slice(6, 11); // Result: "world"
     ```
   - Alternatively, you can use:
     ```javascript
     let slicedStr = str.slice(6); // Result: "world"
     ```

## Accessing Documentation

- Familiarize yourself with the official documentation to understand how to use the `slice` method effectively.
- A reliable source is the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice).

### Key Points in Documentation:
- Syntax of `slice`: `string.slice(beginIndex, endIndex)`
- The second argument (`endIndex`) is optional and exclusive.
- The `slice` method does not modify the original string, it returns a new string.
- Compatible with all modern browsers.

## Conclusion

Thank you for watching this lesson! Keep practicing string slicing and refer to the documentation as needed. Until next time, goodbye!
```

Welcome to NVK Tech World. In this lesson we're going to learn how to do some string
slicing in JavaScript. So let's say we have a string like we did before, right? Some basic
sentence could be whatever you want. I'm just going to say hello world again. Now suppose
I have the string and I want to get rid of certain characters. For example, if I want
to get rid of this age, I just want to show everything after the first character in the
string. How can I achieve that? How can I slice some parts of this string? So we're
going to use this function. It's method called slice. Okay. So with slice, we're going to be
able to just get parts of the string instead of the whole thing. So we can get this part,
we can get this part, can get this part, and so on. Okay. So we have a string. And then we're
calling a function. This is also called a method, by the way. If you hurry the word method, a method
is actually a function. So they might be used interchangeably. But there's a slight difference
between them in terms of the context of where they appear. So in this case, you can also call this
function a method. So this guy, you can think of it as a method that operates on this string type.
Okay. So slice. And then I need some arguments, because it needs to know, okay, you let me know
how much you want to slice the string. So what parts of this string do you want? Do you want this
highlighted part? Do you want this? You have to tell it. Otherwise, it doesn't know. Okay. So let's
say we want just to get rid of the H here, but we want everything else in this string. So if you
just want to get rid of the first character in the string, you can just give an argument one. And
let's try it out. So as you can see, the first letter of the string is gone. The first character, H,
is gone. And that's the most basic use of the slice in this case with one argument. Okay. So if you
try to, what do you think is going to happen? That's right, the first two characters of the string
will be wiped out. Now there's no H, there's no E. It's just the remaining low world. Okay. And so on,
you can keep trying until you reach nothing else to chop, right? So that's the most basic.
Uses all the slice method. Now let's try something else. Let's say we have Hello World. And then we
just want to get rid of the first character. And actually, let's say we just want to take the world
Hello. And everything else wanted to be wiped out. So to do that, we're going to do like so. So we
have to tell slice where to start and where to end. So where do we start? We're going to start at the
first character here. Okay, now the first character when you're dealing with strings, you have to,
there's a location index for each character. Now this location index, it's counted one by one,
except it starts not from one, but from zero. So it's offset. So the first character is actually a
position zero. The second character is a position one, third character position two, and so on. So
we're going to tell slice to start at the first character, that's position, that's index zero. Okay,
keep that in mind, all starts counting the index from zero. Now you want to be able to go all the
way up to the old character. Okay, that's where let's count zero, one, oops, one, two, three, four. Now
the old character is that position index four. So you would think that slice, if you give four,
it will, okay, let's get from zero to four. But that's not how slice works. Actually slice would
take the second argument as the position that you want to chop, but one plus. So we will not
include this guy at position four in the slicing. So actually, you're going to get just the hell
word, okay. So the O is going to be gone, because slice always assumes that the second parameter,
it's not going to be inclusive. So you always have to add one to whatever position index for
the last character is. So this case is going to be four plus one, which is five. So
you're going to go from zero all the way to five minus one, because the five is not inclusive,
the five is the white space. So you cannot include that because slice always assumes the second
argument is not inclusive. So you're going to get the word hello. So let's write out.
There you go. You see there's no O missing, and there's no space. It's just hello
from position zero in the string to position four. Remember, the five is the actual,
actually the white space. Okay, so you give it a starting index and index, which is not inclusive,
not inclusive. And you got the word hello. Now I want you to try it out. I want you to
to get the word world by itself using slice. Now remember, you have to first count where you're
going to start. So you're not going to start from zero because zero is where the H is. First,
you got to figure out what's the position index of the W is. And then in this case, where does it end?
Okay. What's the position index of the last character plus one for the slice? Okay.
So I'll give you some time. And then we'll go on. So how did it go? So let's try to capture the world,
the world, the world world, right? So we're going to do a slice.
Now we're going to count here, what's the position of the W? We always count from zero. So starting
with the first character zero, one, two, three, four, five, and then six, right? So that's going to be
two. This is going to be six. Now what's the last character? Well, we were started at six. Now seven,
eight, nine, 10 is the last character, but slice always assumes you have to say the last character
plus one, which is going to be 11 because the 11 is going to be is not going to be included
in the slicing. So what we get? World. Okay. So that's it. We're going to get the world world
starting position index six ending at position 10, which is always the last this guy, guy minus one.
Notice that this case is actually you didn't need to have the second argument.
You could have done just six because as we saw before, you can just give slice
six, just one argument. And then it's going to assume that, okay, so you want me to just get
rid of the first six characters. And then it's going to end at the end of the string. So you
can think of this way too, like we did before. Okay, please start at six, but go all the way to
the end of the string. That's one way you can think about this. So that works too. Same thing.
Okay. So that's the slice method. Now what I want to teach you is how to reference all these methods
because you got to get used to accessing the documentation for all these things we do.
Now, let me minimize the window here. And I'm just going to do a search on JavaScript string,
slice. Now I want you to go to, I think one good documentation is on the MDN web docs. In this
case is this guy here from developer dot Mozilla dot org. And you can see this is a slice method.
Make sure you're dealing with the right type. This case, we're doing strings, right? So make
sure you read string here and not something else. So string prototype slice, that's the method,
okay, the slice method. So it gives a brief explanation of the method here, some good examples.
And then you can see down here, the syntax, you can see big in index and index,
those are the arguments, these brackets square brackets means the argument is optional.
As we saw before, you don't have to have the second argument. So therefore, it is optional.
And you can read about the parameters here of the method, beginning and end, you can see the
end index is optional. And so on, blah, blah, blah, and return value a new string. Look at this
string. It's this word is very important to know that it does not modify the original, okay, new string.
And the description more description, more examples. And very important section two, the
specification and the support compatibility of the browser seems like this method is
supporting and pretty much all modern browsers. So you'll be very much safe to always use this
method in your code. So there's no problem there. Okay. So that's it. I just want you to get familiar
with the documentation. So you can always reference it to a search and see what the arguments what the
function does, the method, what's the our parameters, what each parameter does, what more
description examples, specifications and the compatibility to see if you have basics afford
among all major browsers. Okay. So thank you so much for watching. And until the next time, bye.


fff8-14 String Slicing in JavaScript

Strict Comparison Equal (===) in JavaScript

# Strict Comparison in JavaScript

In this lesson from NVK Tech World, we explore the concept of strict comparison in JavaScript, focusing on the triple equals (`===`) operator and its distinction from the double equals (`==`) operator.

## Key Concepts

- **Double Equals (`==`)**:
  - Used for comparing values, but it performs type coercion.
  - Example:
    - `2 == 2` results in `true`.
    - `3 == "3"` also results in `true` despite one being a number and the other a string.

- **Triple Equals (`===`)**:
  - Used for strict comparison, meaning it checks both the value and the type of the operands.
  - Example:
    - `3 === "3"` results in `false` due to different types (number vs. string).
  - Ensures that comparisons between different types (like strings and numbers) do not lead to unexpected results.

## Practical Use
When developing software, it's crucial to ensure that you're comparing values of the same type to avoid bugs. The triple equals operator helps maintain type integrity, avoiding mistakes that may arise from JavaScript's type coercion.

## Type Checking
You can use the `typeof` operator to check the type of a variable:
- For example:
  - `typeof "3"` results in `"string"`.
  - `typeof 3` results in `"number"`.

By using strict comparison and type checking, developers can ensure their code behaves as expected.

Welcome to NVK Tech World. In this lesson we'll be talking about strict
comparison in JavaScript. We'll learn about the triple equals operator and its
counterpart. As we saw before we can make comparison in JavaScript using the
double equal operator in this way. For example if you want to assert that 2 is
actually equal to 2 you can use the double equals. So 2 is obviously equal
to true therefore the result here which is the boolean value is true. Now if you
have 3 and you try to do 3 equal to that's false right? So that out sounds
great there is no problem there but then what happens if you try to compare a
string that contains a number and an actual number that's where the problem
lies. Things get a bit less strict in JavaScript when you do this comparison.
For example let's see if the number 3 is actually is equal to the 3 as a
string which is not really a number this guy's a string because there are
quotes around it. So you're going to get true even though technically this number
is not really a string so that's not really a strict comparison in JavaScript.
So because of this there is also what's called a triple operator to account for
this kind of problem because sometimes usually you want to make sure that you
are dealing with the correct types you want to make sure you only have a
number when you need a number and you don't want to be mixing numbers with
strings in the manner that it might cause a lot of bugs as you're developing
your software. So you want to make sure you know exactly what you're working
with and am I working with strings am I working in numbers that kind of stuff so
that's why we have the triple equals operator. This guy will make a strict
comparison it will not tolerate you trying to compare a number inside a
string with an actual number. So let's see what we get if we try to compare a
string 3 let me put the quotes here with the number 3 you're going to get
false because it's a strict operation. This guy here the triple equals will not
only check for the value that it thinks the types have in this case they both
have value kind of 3 right but the type is different so the triple equals will
also make sure to check that the type of each of these operands is the same.
Okay also check for the type and let's see the type of each of these guys.
Remember we can use that operator called type of to see what the type or
something is. Type of this 3 here is a string but the type of the other 3 is a
number so they're obviously different types so the triple equals will make sure
okay we have kind of the same value but you do not have the same type therefore
this is false this is a strict comparison so that's the triple equals okay.


fff8-15 Strict Comparison Equal (===) in JavaScript

Strict Comparison Not Equal (!==) in JavaScript

# Summary of JavaScript Strict Comparisons

In this transcript, we cover the differences between loose and strict equality comparisons in JavaScript.

## Key Points

- **Loose Equality (`==` and `!=`)**:
  - Using `==` (double equals) checks for value equality, but it does not take types into account, which can lead to unexpected results. For example:
    - `3 == '3'` results in `true` (loose comparison).
    - `3 != '3'` results in `false` (loose comparison).
    
- **Strict Equality (`===` and `!==`)**:
  - Using `===` (triple equals) checks both the value and the type, giving a stricter comparison:
    - `3 === '3'` results in `false` (strict comparison).
  - Thus, it is a best practice to use `===` and `!==` for comparisons to avoid type-related bugs.

## Best Practices
- Always use **triple equals (`===`)** and **triple not equals (`!==`)** when comparing values in JavaScript to ensure type safety.
- Be aware that while there may be rare exceptions where loose equality can be used, it is generally safer to stick with strict comparisons.

## Additional Resources
- For more details, the transcript references the MDN documentation which provides examples and further explanations about strict comparisons in JavaScript.

## Conclusion
Using strict equality operators helps create more predictable and error-free code. Always consult documentation for clarity and examples when needed.

Thank you for reading!

Now, if you want to do the opposite, which is asserting something is not equal to, you
could use the exclamation point with the equal sign, right?
Remember that.
So for example, if you have three not equals to the string as a three, well, if you think
about in terms of types, this is a number, this is a string, you would think it would
be not equal, right?
But actually it's going to say what?
False.
Okay, this guy is equal to that.
So it's kind of like not really strict.
So three is not equal to the string three, and it's giving false.
But if you want to be really strict, these guys are not the same because even though
they have the same value, this guy has the type number and this guy has the type string.
So technically this should be true, right?
Because they actually don't have the same type, even though they have the same value.
So you can add one more equals and it's going to be true.
So three is not equal, strictly equal to the string three, that's true.
Okay, so that's strict comparison JavaScript.
So typically as you're developing in the real world, you want to use always, whenever you
can always start off with the triple equals when you're making comparisons that will make
you your code like less prone to bugs because you know exactly what kind of types you expect.
It's not like you expect a string or you expect a number and you don't know which one is
coming through.
So always make sure to start as a best good practice to start with the triple equals when
you want to make a comparison and or the not the exclamation point with the two equal signs
to make not equal to strict comparison.
So that's a good practice.
I want you to remember.
And yes, there might be cases, very few exceptions where you can use this guy and this guy, but
keep those special cases, but always make sure to start off with the triple comparison
operators.
Okay, so that is it.
Just reviewing what we did.
We learned that JavaScript is a bit loose when it comes to comparison.
If you use the triple, if you use the double equal or the exclamation point equal to compare
things to say, are they, is this the same as that?
Is this different from that?
Then it's kind of a bit loose when it comes to comparing numbers with numbers inside strings,
right?
As we saw before.
So to make that a little bit less stricter, right, we only use the strict comparison operators
add one more equal sign there, one more equal sign there, and that will also will make the
comparison be not only about the value, but also about the type of the things you're comparing.
Okay, if you want to have more reference on this, as we mentioned before, there's always
the good documentation out there online.
So let's minimize this.
Now do a search here for JavaScript strict comparisons.
For example, let's see if we get anything.
We got this MDN page.
So you can see strict comparison triple equals is only true if the upper ends are of the
same type and the contents match.
So that's exactly what we talked about.
Get some examples here.
So if you ever forget what we talked about, just come here and have a look at the examples
to see how these guys do.
You can run it.
You can see the output here so on, right?
And there's some details here.
And each operator equality, inequality.
We did that strict equality.
That's what we talked about in this lesson.
And you can see returns to the upper end are strictly equal with no type conversion.
That's the key here.
We will not try to convert that like for example, this number inside a string to an actual number
and then it will turn out to be true if it were only two equals.
You can see here no identity, a strict inequality.
We talked about that too.
Okay.
You can see an example here.
We did.
And so on.
Okay, so keep that in mind.
Always reference these wonderful documentation.
Thank you so much for watching and until the next time.
Bye.


fff8-16 Strict Comparison Not Equal (!==) in JavaScript

String Replacement in JavaScript

```markdown
# NDK Attack World - String Replacement Lesson

## Introduction
In this lesson, we will learn how to perform string replacement in JavaScript by finding a specific pattern of characters in a string and replacing it with another set of characters.

## Overview
- **Example String:** "Hello World"
- **Goal:** Replace "World" with "Earth".

## Using the Replace Method
1. **Method Invocation**: To replace text, we use the `.replace()` method attached to the string.
   ```javascript
   let originalString = "Hello World";
   let newString = originalString.replace("World", "Earth");
   console.log(newString);  // Output: "Hello Earth"
   ```
   - **Arguments**: 
     - First argument: the text to search for (e.g., "World")
     - Second argument: the text to replace it with (e.g., "Earth")

## Replacement Behavior
- The `.replace()` method will only replace the **first instance** of the text found.
- Example with multiple instances:
   ```javascript
   let originalString = "Hello World, Oh Dear World";
   let newString = originalString.replace("World", "Earth");
   console.log(newString);  // Output: "Hello Earth, Oh Dear World"
   ```

## Replacing All Instances
To replace all instances of a word, we need to use a **regular expression**:

1. **Regular Expression Syntax**:
   - Use forward slashes around the pattern:
     ```javascript
     let newString = originalString.replace(/World/g, "Earth");
     ```
   - The `g` flag indicates a **global replacement** for all matches.

2. **Example with Global Replacement**:
   ```javascript
   let originalString = "Hello World, Oh Dear World";
   let newString = originalString.replace(/World/g, "Earth");
   console.log(newString);  // Output: "Hello Earth, Oh Dear Earth"
   ```

## Conclusion
- String replacement in JavaScript can be performed using the `.replace()` method.
- To replace all instances of a substring, use regular expressions with the global flag (`g`).

Thank you for watching this lesson!
```

Welcome to NDK Attack World. In this lesson we are going to learn how to do string replacement.
That is, given a string of characters, we are going to learn how we can find some pattern of characters
and then replace that with another set of characters.
So for that first we're going to need a string.
I'm just going to use that previous example of the Hello World string.
In this video I'm using the Firefox console, okay, Mozilla Firefox Browser console.
So given you have a string with two words Hello World like this, suppose I want to replace the word World with another word.
Let's replace it with Earth. So to do that we're going to use a method, a function called Replace.
So you call that method on the string itself with a dot and then replace, okay.
So this is the name of the method. Remember, method is another name for a function.
It's a special type of function because in this case this function is attached to a string.
In this context we call it a method, okay, a method of the string type.
So we're going to call replace. I always have the parenthesis, right, because we're calling a function.
So replace takes in this case two arguments. The first one is going to be what we're looking for in the string.
So we were looking for, we want to replace the word World. So let's write the World string.
And with the second argument to the replace method you have to pass.
What do you want this to be replaced with?
So we want to replace the word World with something else. In this case we want Earth.
So in this string right here it's going to search for the pattern W-O-R-L-D exactly as we mentioned here in the first argument.
And it's going to take this pattern of characters and replace it with this other set of characters that you passed as a second argument to replace.
It just so happens that it's a word and it's Earth. So let's see what we get.
So the output of this method, replace, will create a new string. A new string with the word World replaced with Earth.
So we get Hello Earth, a new string.
Okay so that's the replace method. The first argument is the pattern to search for.
And the second argument is what we want the pattern to be replaced with.
Now there's a detail about this call here that we're going to see if we add more stuff to our original string.
Suppose you have Hello World, Oh Dear World in this case. We have a string with more two instances of the word World.
And then what happens if we try to call replace on this guy? Will both of them get replaced? Let's see.
So what we get is Hello Earth, Oh Dear World. So the second word, World was not replaced.
So the method replace on the string will only replace the first instance found.
So it's going to start looking for the pattern W-O-R-L-D, the word World, and finds it right here.
Then it's going to replace it with Earth. But then it stops because it only does it once.
Okay? It only replaces the first instance it finds.
Now if you really want to replace all the instances, not only this guy, but also all the other guys that come subsequently.
So you have to do a little more work in your call to the replace method.
So it's going to be almost the same thing except the first argument right here.
So you're going to call the first argument instead of pressing just a string.
You have to pass it in a special format for the language JavaScript.
We're going to use instead of the quotes, we're going to use this forward slash.
And then at the ending quote, another forward slash. Okay?
So in JavaScript, when you have something between the forward slashes in this fashion, this is called a regular expression.
Regular expression is some kind of pattern that you can devise and then replace will know that if it finds this pattern, it will replace of the word Earth.
So we just got introduced to regular expressions. There's not much we don't know much about it.
But just be aware that when you see these slashes and means, okay, this is treating this pattern as a regular expression.
Okay? Now if you want to be able to replace every instance of world with Earth, you have to add this kind of option to the regular expression.
We put a G there. So after the last closing slash, add a G, this G stands for global.
So we're going to perform a global substitution. Okay, global replacement of every instance of the word world, we're going to replace with Earth.
So let's try it out.
Now you can see the first world becomes Earth and the second world becomes Earth and so on.
If you had many, many, many, many worlds in the string, it would have been replaced with that. Let's see.
There you go. Everything gets replaced. Every world word gets replaced with the word Earth.
Just by using this G here after the regular expression with the pattern, which just so happens to be a word with the characters w, o, followed by r, followed by l, followed by d.
Okay? So that's string replacement with the replace method of the string type in JavaScript.
Thank you so much for watching and until the next time.


fff8-17 String Replacement in JavaScript

Review of the JavaScript Things We Learned (Part 1)

# Summary of NBK Tech World Lesson

Welcome back to NBK Tech World! This lesson serves as a review of the concepts covered in the course so far. If you're comfortable with the previous lessons, you can skip this video; otherwise, let's continue.

## Key Topics Covered

### 1. Browser Console and JavaScript Commands
- Each major browser has a console (e.g., Firefox) where you can type JavaScript commands.
- The console provides an interpreter that returns results immediately.

### 2. Printing to Console
- To print a message, you use the `console.log()` method.
- Functions perform actions, take inputs, and return outputs. When tied to an object, they're called methods.

### 3. Variables
- **Constants** (`const`): Declare a variable that cannot be reassigned.
  - Example: `const name = 'Your Name';`
- **Let** (`let`): Declare a variable that can be reassigned.
  - Example: `let age = 35;`
  
### 4. Data Types
- Strings: Enclosed in quotes (`'string'`, `"string"`, `` `string` ``).
- Numbers: Numeric values (e.g., `35`).
- Use `typeof` operator to check types.

### 5. Mathematical Operations
- Basic math operations (addition, subtraction, multiplication, division) can be performed directly in the console.
- Parentheses can change operation precedence (e.g., `3 * (4 + 8)`).

### 6. Special Cases in Math
- Division by zero results in `Infinity`.
- `0 / 0` results in `NaN` (Not a Number).

### 7. Comparisons
- **Strict Equality** (`===`): checks both value and type.
- **Loose Equality** (`==`): checks only value, coercing types if necessary.
- Comparison operators (e.g., `<`, `>`, `<=`, `>=`) are also useful.
- **Strict Inequality** (`!==`): checks if two values are not equal in both value and type.

### Final Thoughts
Remember to start with `const` for variables. Use `let` only when reassignment is necessary. The lesson covered fundamental concepts that serve as building blocks for more advanced programming.

--- 

This concludes the review. Happy coding!

Welcome back to NBK Tech World. This lesson will be a review of everything
we've done so far. If you already feel comfortable with all the previous lessons
you can skip this video. Otherwise let's keep on going. So going back to the
beginning of the course we learned that every major browser contains a browser
console and in my case right now I'm using Firefox we can open up the
console and we can type JavaScript commands here and we have an interpreter
that will give you the result on the spot. So the first thing we learned how
was how to print a message to the console. We learned about the console object
that has a method and that method is called log. So remember when we have
functions functions do something they take some input they do some processing
and they return give you back some output that's the general idea of functions.
Now we learned also that when we have a function and when that function belongs
to an object in this case the console object we can call that function a
special name called method. So you might hear the terms function and method used
interchangeably but there's that slight difference. So if the function is by
itself and it's not tied to any object it is not really a method but if it is
tied to some object you can call a method. Anyways let's keep on going let's do
the review. So essentially the function will take an argument which is kind of
the input so you have to tell it what to print to the screen. We can just print
any message we want using a string. A string is a set of characters enclosed by
quotes. By convention I'm using the single quotes convention but mind you
there are other types of quotes like the double quote and the back ticks and they
all have slightly different behavior we haven't really learned in detail about
those but just keep in mind anything under quotes think about strings okay. So the
function will produce this print out to the console with whatever you gave as a
string here. So in this case we got hello world. Alright so that's how we
started then we learned about the concept of variables to store information. So we
can define or declare a variable and then define it with a value in two ways
and the first way is with a const keyword. We can define for example a variable
called name and to that let's assign a string to it. Let's call it whatever
your name is. I will just call it my name. Right we learned that this string will
be stored in this variable called name and because we use const that value can
only be assigned once. So if I try to change name like this some other name
we're gonna get an error because in violet assignment to const and that's
because the const if you define declare variable const it will only allow you to
assign a value once. If you want to be able to change the value of the variable
name again like I tried to do here you have to use another keyword and that's
the keyword let. So if you say let for example let's create another variable
called age. I'm gonna give an arbitrary number okay. So let age be 35 so the
variable age contains the value 35 which by the way is what kind of type in
JavaScript that's a number okay. It's not within quotes it's just a number by
itself so it's type of number okay. Remember type of operator you can type
type of and putting whatever you want to find out the type of and it gives you a
number. So we also learned that right. So going back to the let if I try to change
age to something else like 23 notice that now it works there's no error like
before and if I see what's inside age it's exactly 23 the new value. So that's
because we use the word let. So if you want to change be able to change assign
the value to the variable age more than once not just the first time like we did
here you use let. My advice is to always start out with cost and if later as you
program and do more add more code if you feel that's necessary for the variable
to be changed you should change the cost to let in the declaration. Alright so
that's it for variables and then we talked about the numbers and operations
on the numbers basic math that kind of stuff. So I'll be pretty quick with that
I think you got the point we can do mathematics here right on the console
23 minus 11 gives you 12 and 20 divided by 5 gives you 4 7 times 3 21 and you
can do addition 9 plus 2 11 right. We learned about parentheses if you have
3 times 4 plus 8 but if you do it like this because of the precedence of the
operators the 3 will multiply 4 first if we actually intended for the 4 to be
added to 8 first you would have to add the parentheses right. That's where you're
forcing the addition to be the first thing they'll be 12 and then you do 3
times 12 which is 36. If you didn't have that right you're going to get something
else because the multiplication always takes precedence over addition. So we
get 12 plus 8 which is 20 totally different value right. We also learned
about some things like if you try to divide by 0 what do you get you're gonna
get infinity if you take a number that's non-zero and divide by 0 but if you take
0 and divide by 0 you get NAN which means not a number okay this is not a
number. So if you just type off let's see what we get. So 0 divided by 0 wow it's
type number okay all right so whoops I accidentally open the other window that
continue your type of to find out what the type of this guy is you can see is
also a number so both these guys seem to be a number okay so
you have hello well and if you have a number within strings
it's actually strings not really a number so we learn also about that because
3 is not really equal to 3 if you use the triple equals operator right because the
triple equals the strict equality it compares not only the contents but also
the type of each operand operand is whatever is next to the operator here so in this case
the slap hand side operand 3 so 3 this is a number there's no quotes and on the right hand side
there's a number but it's within quotes so this guy must be a string but a string is not really
a number so this guy is strict equality saying it'll be false but if you have double equal
equals that's not so strict so it's actually going to give you what is 3 equal to the string 3
it's going to be true because it only compares the contents it tries takes this guy okay let's
try to make it a number because you have a number of things strings so it tries to convert
to a number and it succeeds because it's just a number under quotes and it's actually
equal in content even though the type is different we have a number on the left hand side we have a
string on the right hand side so we learned that about those kind of comparisons and can use other
kinds of operators uh greater than greater than or equal to less than less than or equal to we also
learned about the strict inequality right which is the opposite of the triple equal sign if you
want to check if something is not equal to another thing in a strict fashion okay


fff8-18 Review of the JavaScript Things We Learned (Part 1)

Review of the JavaScript Things We Learned (Part 2)

# NBK Tech World - JavaScript Review Summary

Welcome back to NBK Tech World! In this lesson, we will review topics covered so far, including string concatenation, interpolation, functions, and string operations.

## String Concatenation & Interpolation

- **String Concatenation**: 
  - Used to combine strings using the `+` operator. 
  - Example: `"hello" + "world"` results in `helloworld`. 
  - Make sure to include spaces where necessary.

- **String Interpolation**: 
  - A feature from ES6 that allows easier string combination using backticks (`` ` ``) and `${}` for variables.
  - Example: `` `hello my name is ${name}` `` simplifies the process without needing to break and concatenate strings.

## Functions

- Functions allow for code reuse by defining a block of code that can be executed multiple times.
- **Defining a Function**:
  - Use the `function` keyword, followed by the function name and parameters.
  - Example:
    ```javascript
    function sayHello(name) {
        console.log(`Hello ${name}!`);
    }
    ```

- **Calling a Function**: 
  - Invoke the function by its name and pass the appropriate arguments.
  - Example: `sayHello("John");` outputs `Hello John!`.

- You can also add more parameters:
  ```javascript
  function sayHello(name, age) {
      console.log(`Hello ${name}, you are ${age} years old.`);
  }
  ```

## String Operations

- **Changing Case**:
  - Use `.toUpperCase()` to convert a string to uppercase.
  - Use `.toLowerCase()` to convert a string to lowercase.

- **Slicing**:
  - Use `.slice(startIndex, endIndex)` to extract a portion of the string.
  - The end index is not inclusive.

- **Replacing Substrings**:
  - Use `.replace(searchValue, newValue)` to replace part of a string.
  - For global replacements, use a regular expression with a `g` flag.

## Conclusion

This review encompasses important aspects of string manipulation and function definition in JavaScript. These concepts are foundational for continued learning in programming.

Thank you for watching, and see you in the next session!

Welcome back to NBK Tech World! Let's continue our review of what we have done
so far. Remember if you already feel comfortable with everything we've did,
we've done so far feel free to skip this lesson. Alright so we finished our last
video talking about revealing the operators we talked about the triple
equals, strike equality, talking about striking equality and all the other
operators greater than or lower, less than or equal to etc. So now let's review
what we did in terms of string concatenation and interpolation. So we
learned about string concatenation to combine strings together. So if you have
a string hello and you want to add this guy to another string you can use the plus
another string. For example if I have the string with the word hello and I have
another string with the word world and you want to combine them you can use the
plus operator and that will concatenate this with that. Notice if I do this way
there won't be any space between the words so they'll be all glued together.
So you actually have to place a space either here or here okay. Let's do it in
a world. So keep that in mind. Also remember that this space here around
the operator doesn't really matter it's just for style convention that I adopted.
Even if you have spaces here could have as many as you want it will make a
difference to the output right it will be the same. What determines the output is
whatever is inside the quotes okay. The convention is I always put one space
before and after the operator this case the plus that's a style convention okay.
So that's concatenation and we learned that we can also have the variables like
we'd had before right. If you have a name the variable you can concatenate this
variable with whatever you want. So like a message to the screen we learn console
log hello my name is whatever right. You can concatenate with the variable here.
So if you want to print to the console some message and in the message you need
some value from a variable in this case the variable is called name and holds
the value my name or whatever your name is. So you can use the plus and then you
concatenate with the string that's stored in the variable name. Okay so hello my
name is my name okay. So that's string concatenation. Now we also learn about
string interpolation. It's an alternative to concatenation that allows you to do
the same kind of thing except you don't have to break the string right here and
have to add a plus and then continue on another different part. You can just use
the back tick if you want to do string interpolation that's a feature from
JavaScript AcumenScript 2015 aka ES6. Okay so back tick and then you do the same
thing hello my name is except now you can do the interpolation using the dollar
sign with two curly races and whatever you want to interpolate inside. So this
time I want this value of the variable name to be replaced right here where these
these guys at. Okay so hello my name is my name so that's string interpolation.
Okay so string concatenation or string interpolation. It's up to you to choose
which one you would like to use. Can you use either of them or a combination of
both? Doesn't matter. Whatever if you're comfortable with if you like better remember
that string interpolation is fairly new to JavaScript comes with ES6 AcumenScript 2015.
That's it for interpolation and concatenation so we also learn about functions. So we
learned the concept of function and we learned to reuse code so we can call the
function many times and we don't have to change the same code at multiple places.
We can just change that in the function definition so we can call the function
many times and if you want it you need to modify that function you just do it
once instead of every single instance where you have to do the same code. Just
to illustrate let's define a function here that prints some message and your
name like we did before. So we start off with the keyword function then you give
it a name let's say say hello okay and then you need some parameters. This
function needs some inputs so we're gonna do just somebody's name so we need
somebody's name so we can generate an output that is we want to print the
message to the console saying let's say hello whatever the person's name is.
Okay so we're gonna need that input you need to know the name person's name
before you can say hello to them. So that's only one parameter in this function.
Now when you define this function signature here you're gonna open the
function definition function body with the open curly brace by convention I
always put a space a style convention space after the parameters up to you to
choose which convention you like. I usually do this convention and whenever I
open a block okay this is called also a block a function definition block I
indent by two spaces okay that's another convention that I use and then I start
writing the function. It could be one could be one or more statements or it
could be nothing at all right but that wouldn't be useful so let's do that
console log to print a message so what we want to do is we want to say hello
whatever the person name is and an exclamation how about that let's do a
string interpolation do you remember use the back tick instead of the other kind
of quote and then the variable name within the curly braces with a prepended
with a dollar sign and that's what the exclamation point there okay remember I
like adding semicolons to the end of statements set to another convention you
don't have to have it here but it's a convention that I follow for every
statement JavaScript I will have the semicolon and then I close the function
I finish this definition with the closing curly brace aligned on the same
level as the function keyword okay I don't do this I do that okay always aligned
that's a convention that's widely used in not only JavaScript but other
programming languages so let's see everything okay keyword function name of
the function parameter just one that's the name definition just does a log to
the console and it the message is going to be hello whatever name exclamation
okay so we press enter we get nothing return value on defined right the
function because we just defined a function we did not call it yet so first
you have to define it before you can try to use it so if you want to call the
function what do you do is first what's the function name say hello now you need
to give it argument remember the whole notion of a parameter versus argument so
when you define the function declaring the function signature this part here you
give it a name and you give some parameters when I'm talking in this
context I usually refer to this guy as the parameter but when I'm talking about
the calling when you're calling a function I usually say argument instead of
parameter that's just a convention and a naming okay that's like difference but
sometimes some people might use the same term interchangeably but you should be
aware that's a slight difference so what's the argument at whatever person's
name you want I just gonna use my name you can use your name okay so let's try
it out say hello with the argument name takes this guy and goes to that function
and then this variable is gonna hold this value then it's gonna do a log
hello and then whatever you passed here in this case my name is gonna be
display hello my name with an exclamation mark so that's it that's a
function right just reviewing what we already did and we learned if you can add
more stuff to the function if you want you can add age like we did before so
that would add another what what do you call this guy not a parameter right if
you want to add another parameter you have to separate them with a comma so
let's with age and also say hello whatever you are age years old so it's
gonna say also the person's age you are age years old so remember comma
separated parameter list for the function definition here by convention I
always put a space after the comma it's not necessary but it's a style convention
so you see there's all these style conventions that we follow I highly
recommend that you pick them up from the beginning because it'll make your code a
lot cleaner and you just practice ours is the beginning and once you're doing the
real thing you're just gonna buy automatically right in a very elegant
fashion okay so keep that in mind I was following these good best practice
conventions so that's defined this again that's called a function now we can pass
two arguments can pass your name comma the second argument is gonna be the age
I'm just gonna make something up a number 35 okay so comma separated and this guy
is gonna be mapped to name 35 is gonna be mapped to age so whatever say name
you're gonna get this inside the function block okay whenever say age you're gonna
get 35 inside the function block all right so let's try it out hello my name
you are 35 years old so exactly we want it to be okay so that's it for functions
now let's go on and continue our review we learned about some string operations
remember so we learned about converting a string all the characters to uppercase
and all the characters to lowercase so that's very easy right so if you have
somebody's name like John someone and you want to convert this you want to
generate a new string with all the characters in uppercase you can use
to uppercase this is a method of the string you can use the dot name of the
function or method and you just call it without any arguments because it already
has the string right here so you're gonna get a new string okay it's not the
original that's changed you're gonna get a new string with all the letters
capitalized in the same fashion if you have John someone all capitalized and
you want to convert all of these guys to lowercase note I just put some lower
case here it won't matter you will stay the same right when we do to what to
lowercase and then don't forget the parentheses whenever you have function
calls remember the parentheses okay John someone so you're gonna get every single
letter in lowercase so that's it to uppercase and to lowercase methods of
the string type okay now let's talk about slicing a string so like we did
before slice is used if you want to take parts of a string and you want to cut
things off so if you have let's do the same example John someone you want to for
example just get his last name here you want to get rid of one two three four
five characters you can use slice right five characters give me you can think of
it this way please slice the first five characters that's one way of thinking
about this so this means it's gonna only get this part of the string
okay then there's not a you can add another argument to the slice method to
be able to grab not only from one side from the other example you want something
like this part how would you get that well we have to figure out the indices
right the index for each they start index and the end index for the string
remember indices always start counting from zero count the index from zero so
you're going let's count I just want this part of the string so how can we do
it so zero is J one is O and two is gonna be the H so the first argument to the
slice is gonna be two and I forgot if I highlighted everything okay sorry I took
off the highlight but let's do it like this one from the H to out the way to the
so me you owe the okay the last oh so where's that last oh so we figure out the
first index for the H that's two let's keep counting and is three spaces for
s is five oh is six and seven e eight oh nine okay oh is nine but remember that
the slice is always the second argument is X is not inclusive so you have to
count one more so you're gonna count to the end and that's 10 let make sure one
zero one two three four six seven eight nine ten yeah correct ten so use 10 which
is the index for n but that is not included when you do the slicing it
actually includes 10 minus one which is gonna be the O so it's gonna grab from
the H to the last oh let's try it out so it each to the last oh correct okay so
that's slice so you're gonna get parts of a string you want to slice it okay now
to finish our review we're gonna talk about replacement string replacement if
you have John someone and you want to replace say someone with I don't know
let's say another you can use a dot replace on that string first you have
to tell it what to look for look for someone replace that with what the second
argument is going to be another so I want to replace every instance of these
the sequence of characters with this other sequence of characters called
another just happened to be a word doesn't have to be a word could be any
sequence of characters any patterns so you're gonna notice now it generates a
new string with whatever whenever see someone it replaces with another the
second argument to the replace method of the string we also talk about globally
global replacement because if you have John someone and someone and someone
whatever it only replaces the first instance it finds so if you really want
to replace every instance of someone with another you have to do a global
substitution for that you'll have to write the first argument in a regular
expression fashion the JavaScript you can put forward slash anything in between
will be a pattern for a regular expression we just learned the term we
don't quite understand everything about it yet you just know that's something
that you can put a pattern in between and then after that we put a G to say it's
a global substitution okay for the replace is gonna take that okay you want
to replace every instance of this pattern the word someone with this other
word another so that case every single instance of someone is replaced with
another okay so we have finished our review of all the things we've done so
far I hope that helped you to refresh your mind about all the things that we've
done so we can go on and keep on learning in this JavaScript this wonderful
journey with JavaScript thank you so much for watching and until the next time
goodbye


fff8-19 Review of the JavaScript Things We Learned (Part 2)

Introduction to JavaScript Arrays

# Summary of JavaScript Arrays Lesson

Welcome to MBK Tech World! This lesson focuses on arrays in JavaScript, which are ordered lists of items.

## Key Points

1. **Definition of an Array**:
   - An array groups multiple items (e.g., names) into a single variable.
   - Unlike defining multiple variables (like `name1`, `name2`, `name3`), an array allows for easier organization.

2. **Creating an Array**:
   - You can create an array using square brackets and separating items with commas.
   - Example:
     ```javascript
     let names = ["John", "Anna", "Andrew"];
     ```

3. **Array Properties**:
   - The array is treated as a single variable containing multiple items.
   - The number of items in the array (elements) can be accessed using the length property.
   - The array's elements can be accessed by their index (starting from 0).

4. **Viewing Array Contents**:
   - In a browser console (e.g., Google Chrome), typing the variable name reveals its contents.
   - Elements in the array can be viewed alongside their positions:
     - Position 0: John
     - Position 1: Anna
     - Position 2: Andrew

In summary, arrays simplify the management of collections of related data, making it easier to store and access multiple items efficiently in JavaScript.

Welcome to MBK Tech World. This lesson will be about JavaScript arrays. An array is an
order list of items. So let's start off with an example. Remember that before when we first
learned about variables, let's say you un-store somebody's name like this, right? But now,
suppose you not only have one name, but you have multiple names. Say we have three people.
We could do like so. We could call this variable name one. We could make another variable for
the other person, let's say Anna. And then yet another variable for another third person,
I don't know, like Andrew. And then we could access each of their names using name one,
name two, name three. But notice this is kind of tedious to have to define each variable
one by one. So isn't there a better option we can do? Yes. So that's when arrays come
about. So you can group a list of items, like in this case, I have names, right? String,
three strings, we can group them in a single entity, a single variable. And we call that
an array. Simply put, it's just a list of items. So instead of doing one variable at
a time, you only create one variable. For example, let's create a variable called names.
And this variable will hold a list of names. Okay. So all you have to do is you separate
them with a comma. So let's put John, Anna, and Andrew. And then you put square brackets
around this list. Okay, the square brackets means, okay, we're making an array, we're
making a list of items separated by a comma. This extra space here is optional. It's a
style convention that I use, like all the other style conventions that I already mentioned
to you. Okay, so it's just a normal variable, except now we're not only starting just one
single strings, but a list of three strings. And this list is called an array. When you
see square brackets, think about array, okay, in this context. So let's define it. And now
let's see what's inside. Let's just type names. And you can see there's a number three, and
then you have the list right here. So three means, there are three things inside this list.
Now those things have a name. And the formal name is an element. So an array has elements.
So each one of this, these guys is called an element. So this array has three elements.
And if you click here, I'm using Google Chrome, by the way, in this video, you can expand
this and Google Chrome allows you to see what's inside this list. You see at position zero,
there's John, one, there's Anna, there's two, two, there's Andrew. So there's an order to
the array. So the order that you define will also be appear in the same order here when
you try to access them.


fff8-20 Introduction to JavaScript Arrays

Accessing JavaScript Array Elements

```markdown
# Summary of Array Basics

## Array Indexing
- Each item in an array has a position called the **array index**.
- Indexing starts at zero:
  - `index[0]`: John
  - `index[1]`: Anna
  - `index[2]`: Andrew
- Arrays maintain a specific order.

## Array Types
- The example uses strings, but arrays can hold:
  - Numbers
  - Objects
  - Arrays of arrays

## Accessing Array Elements
- Elements can be accessed using square brackets `[]` after the array variable.
- For the variable `names`, to access:
  - **Anna**: Use `names[1]`
  - **John**: Use `names[0]`
  - **Andrew**: Use `names[2]`

## Additional Information
- Arrays are a special type of **object** in JavaScript.
- You can use the `typeof` operator to confirm the type of an array:
  - Example: `typeof names` returns "object".

### Exercise
- Try accessing the first and last elements of the array (`John` and `Andrew`) using the described method.
```


So, this position number here for each item in this list is called the array index.
So, at index sub zero we have the item John, index sub one, we have the item Anna, index
sub two, have the item Andrew.
Notice we always count starting from zero, okay?
And this always follows the order in which the array is defined.
So, it's an order list, okay?
Keep that in mind.
There's a specific order, a specific sequence.
So, also, just so you know, we are only using strings here as each element of the array,
but that's not necessarily the case for every single array that you define.
You can define an array of any kind of type, okay?
Could be a number, could be an object, or even an array of arrays.
So, it just so happens that our example here uses strings, okay?
Now that we know how to define an array, we have to learn how to access each of these
specific elements in the array individually.
So, the way to do that is using two brackets after the name of the variable that holds
the array.
In this case, we are holding this array in a variable called names.
So, if you want to access, for example, Anna inside this array, you have to add square
brackets here, then inside you have to tell it the position index.
So remember, we look before, y'all's count started from zero.
So, if you want Anna, you have to start here at the beginning of the array.
So, the first element is John.
The index is zero.
So, if you go to Anna, now the index is one.
You increment, right?
So, to get Anna, I will have to tell it to go to index one.
At index one, we're going to get whatever is there in this slot.
In this case, it's the string Anna.
Okay?
In a similar fashion, you can get the first element and then the last element.
I'll leave it to you as an exercise.
So, pause the video and try to get first John and then try to get only Andrew.
So, how did it go?
So to get John, simply reference the name of variable, square brackets, then the index.
This case is going to be zero.
To get Andrew, that's the last item.
In this list, it's going to be sub what?
You count from the first zero is John, one is Anna, and two is Andrew.
So it has to be two.
Okay?
So, that's how we access individual elements of an array.
And, if you remember type of operator we used before, you can try to tell, okay, what's
the type of names and it will tell you it's an object.
And this is because the array is actually a special type of object in JavaScript.
So keep that in mind, all right?
So an array is just a special kind of object in JavaScript.
We haven't really talked much about object, but just keep that the back of your head.


fff8-21 Accessing JavaScript Array Elements

Adding / Removing Elements at the End of JavaScript Array (push and pop)

```markdown
# Summary of JavaScript Arrays Lesson

In this lesson from NDK Tech World, we continue our study of JavaScript arrays. Here are the key points covered:

## Accessing Array Elements
- An array, such as `names`, allows access to its elements using bracket notation with zero-based indexing.

## Modifying Arrays
- We learned to modify arrays using two methods: `push` and `pop`.

### Push
- The `push` method is used to add new elements to the **end** of the array.
- Example: `names.push('new name')` adds 'new name' to the end.
- The return value is the new length of the array.

### Pop
- The `pop` method removes the last element of the array.
- Example: `names.pop()` removes the last element and returns it.
- After calling `pop`, inspecting the array confirms that the last element has been removed.

## Conclusion
- Both `push` and `pop` affect the **end** of the array, either adding or removing elements. Keep this in mind when working with arrays in JavaScript.

Thank you for watching, and see you in the next lesson!
```

Welcome back to NDK Tech World. Let's continue our study of JavaScript arrays.
So let me clear the console. I'm using Google Chrome this time. So we learned how
to access elements in an array, right? We had the names array with three elements
and to get each element you just use the brackets where brackets in the index,
right? Get John, get Ann and get Andrew. So the index always starts from zero. Now
how can we modify this array? That's what we're going to learn in this lesson.
We're going to talk about push and about pop. So push and pop, these are the
methods we can use to change the array, either to insert an item or to remove an
item. Now push and pop, as we're going to see, they add, you add either add to the
end of the array or if you remove from the end. So it's a little bit of constraint
there. So let's get started. Suppose I have this names and I want to add a new
name. So I can say names and I put a dot push. This is the method, okay? It's a
method called push. Then you put two parentheses because it's a function call.
And then you need to tell it, okay, what do you want to push? It could be multiple
things, but let's start like starts simple and just push one name. So you can push
another person. I don't know what to call the name or just say a new name. Let's see
what happens. So I say names dot push a new name. And I got this four back. The
return value here, this is called the return value of the result of this
expression. So this is just telling you how many elements are now present in the
array names. If you inspect names like so, you're going to notice that not only
John and an Android there, but also a new name has been added to the end of the
list. So that's what push does. It adds a new element at the end of the list. Okay.
Now we have four elements. Now let's learn how to remove an element from the end of
the array. That's called a pop operation. So if I say names dot pop, remember the
parentheses, because it's a function call. In this case, I don't need any arguments.
I just want this list called names to pop the last element. So if I say that, I
actually get as a return value from this function call, the element that was popped.
But if you inspect names now, you can see that new name is no longer there. So it
has been removed from the end of the array and was given as a return value of the
pop operation. Okay, so that's push and pop. Let's review what we did. So we have
an array called names that holds people's names. This case, we start off with three
names. Then we wanted to add a new name called new name to the end of the list. We
use the push operation, it always pushes to the end. Okay. And then we learn how to
remove the last element in the array, we're using the pop operation. So push and pop always
operate at the end of the array. Okay, keep that in mind. So I think we're good for this
video and until the next time, see you.


fff8-22 Adding / Removing Elements at the End of JavaScript Array (push and pop)

Adding / Removing Elements at the Beginning of JavaScript Array (unshift and shift)

# Summary of JavaScript Arrays Lesson

In this lesson, we continue our exploration of JavaScript arrays, focusing on how to add and remove elements from the beginning of an array using the `unshift` and `shift` methods.

## Key Topics Covered

1. **Defining an Array**: 
   - We start with an example array called `names` that contains three elements.

2. **Adding to the Beginning of the Array**:
   - The `unshift` method is used to add an element to the beginning of the array.
   - Example: `names.unshift("Another Name")` adds "Another Name" at the start. This returns the new length of the array.

3. **Removing from the Beginning of the Array**:
   - The `shift` method removes the first element of the array.
   - Example: `names.shift()` will remove the first element and return the removed value. The original variable `names` is modified.

4. **Finding the Length of the Array**:
   - To determine how many elements are in the array, you can use the `.length` property.
   - Example: `names.length` returns the number of elements without parentheses.

## Summary of Operations

- **Add an Element**: Use `unshift` to add an item at the beginning of the array.
- **Remove an Element**: Use `shift` to remove the first item in the array.
- **Array Length**: Use `.length` to get the count of elements in the array.

### Important Notes

- Operations like `push`, `pop`, `unshift`, and `shift` modify the original array directly.
- Ensure to check the modified array after performing these operations.

Hope you enjoyed this video! Until next time!

Come back to NBKE Tech World. This lesson we will continue our study of JavaScript arrays.
So we learn how to define an array, how to access individual elements, how to push and pop
at the end of the array. Now let's learn how to do
add and remove from the beginning of the array. We're going to use Unshift and Shift.
Okay, so with the same array as before, oops, names, let me define it again.
So we have an array of three elements. Now let's remove, let's actually add an item
to the beginning of the array. So we can say names dot
Unshift, this is the method that we'll add an element to the beginning of this list.
Okay, so Unshift, whatever you want to add at the beginning, let's Unshift another name, for example.
Now the return value is how many elements the array names are now have. So if you look
at names, now we have another name at the beginning of the list. Okay.
And I'll just keep in mind that the operations we did like push, pop, and even on Shift here,
it modifies the original array. It does not create a new one. Be aware of that. Okay,
that's why we now see there's another name inside names.
Now, if you want to remove the first element of the list, you're going to do an inverse
operation. And it's simply called shift without the on. So names dot shift, call this method,
it will remove this first element from the array. Notice this expression will return the
remove element. So you got the remove element, but the actual variable names will have been
modified. Notice there's no longer a first element called another name. Now there's back to three
elements. Okay, that's the length of the array. And that is something I haven't told you yet. If you
want to find out how many elements there are inside a list, well, in this case, you can obviously
tell right, John and Andrew, we have three. But internally, as you're creating and programming,
you have your own program, your script, there's you cannot help the computer
see there are three elements. So you have to explicitly tell or ask for the length of the
array. And that's very easy to do. You just reference the array name, the variable name dot
length, just like that. And that will give you the number elements in this array. Notice there's no
two parentheses is just dot length. Okay, that's the property of this array. There are three elements.
So let's review what we did. So we learned yet another set of operations on arrays. We learned how
to add and remove add or remove an item at the beginning of the list. To add something to the
beginning of the list, we use the on shift method. On shift returns the number elements,
in the new in the array that was modified. We learned also how to add an element at the beginning of
the list. That's how that's when we use shift, there's no on. And this operation, this statement,
will return the removed element. But the original element, the original element,
will return the element. And the original element, the original element, will return the element.
And the this operation, this statement will return the removed element. But the original
is changed permanently. Okay, keep that in mind. These operations change the original thing you're
operating on. Then finally, when it up, just mentioning that you can get the array length,
simply by saying dot length on the variable here.
Okay, so that's it for now. Hope you liked the video and until the next time.


fff8-23 Adding / Removing Elements at the Beginning of JavaScript Array (unshift and shift)

Using split to Break Down a String into an Array in JavaScript

# NBK Tech World - JavaScript: String and Array Connection

In this lesson, we explore the relationship between strings and arrays in JavaScript through the use of the `split` method.

## Overview

- **Objective**: Learn how to split a string into an array of substrings.
- **Key Concept**: The `split` method.

## Example

1. **Define a String**: 
   - We start with a sentence: "There is a cat on the table."
   - Store it in a variable named `sentence`.

   ```javascript
   let sentence = "There is a cat on the table.";
   ```

2. **Using Split Method**:
   - To create an array of words from the string, we use the `split` method with a whitespace as the separator:
   
   ```javascript
   let wordsArray = sentence.split(" ");
   ```

   - This method divides the string into multiple substrings based on the specified separator (whitespace, in this case).

3. **Resulting Array**:
   - The resulting array contains the words of the sentence, including punctuation (like the period).

   ```javascript
   // Result: ["There", "is", "a", "cat", "on", "the", "table."]
   ```

4. **Splitting by Different Characters**:
   - The `split` method can also use different characters as separators. For example, splitting by the character 'a':

   ```javascript
   let splitByA = sentence.split("a");
   ```

   - This splits the string at every occurrence of 'a', creating a new array without the 'a' characters.

## Conclusion

The `split` method is a powerful way to manipulate and extract data from strings in JavaScript, allowing for flexible separation based on specified delimiters.

Welcome to NBK Tech World. In this lesson we're going to make a connection between the string type and the array type in JavaScript.
We're going to learn how to take a string of characters and split it into an array of substrings.
We're going to learn the split method.
So to get started let's do an example.
Say we have a string that holds a sentence.
Following sentence there is a cat on the table. Period.
So this is a string. Let's store this string in a variable.
I am going to use the lat keyword just in case I need to change this variable later on.
So the variable is going to be called sentence and hold this string.
Okay so let's just make sure the sentence string is there.
Now let's say I want to capture each of these words separately in a list, an array.
The way we have it right now it's inside the string.
The whole string contains the sentence. It's one single entity.
But what if you want to grab each of those words separately?
So what we're going to use is the split method.
So we're going to say the following. Take the variable name dot split.
Split is a method in this case of a string.
Okay type.
So the split expects in this case an argument that's going to be the separator.
You have to tell it how you want to split this string.
In this case what's the separator here? What separates each word from the other?
In this case it's the white space, right?
So the white space is the separator.
So we're going to write the white space as a string.
This is the white space.
Okay there's nothing but there is something. It's the white space, the space bar.
And that's our separator.
Now see what is going to happen.
So it takes the string with the separator.
It's going to split the sentence into multiple strings in a list in an array.
Each element of this array is going to be the word in the sentence.
There is a cat on the table.
Notice the period is included because the separator is the space and it does not care if it's a word or not.
It includes everything that's in between the space and the other space.
In this case the end of the sentence so it doesn't have anything else to capture.
So there you go. This is the split.
And this creates an array of seven elements.
Okay.
And notice it's not necessarily by word because the period dot is there.
Okay.
Now there are other ways you could split this sentence.
You could split any character you want.
So for example sentence dot split.
Let's split this into using the character a.
So you're telling it to whenever you see an a you're going to take that and break the string right at the point where the a is.
And it does not include the separator character.
So let's see what we get.
So it captures everything.
There is space and then it finds the a.
The a is the separator.
So it takes breaks right here.
It removes the separator character and goes to the next element.
Keeps going space cat and then it hits the a again.
Right.
And the a is the separator is removed.
You get a break right there.
Then it makes a new element and keeps going.
T on the T a got the a right here.
Let's make a barrier here.
Make a wall and split into different substrings and finally bowl with the period.
Okay.
So that's the split method of the string.
The argument is a separator.
Now.


fff8-24 Using split to Break Down a String into an Array in JavaScript

Splitting a URL string into an Array in JavaScript

# URL Parsing Challenge Summary

In this exercise, the speaker presents a challenge to extract different parts from a given URL string. The URL format given is:

```
https://www.minds.com/plus
```

## Objectives

The goal is to extract:
1. The **protocol**: `https`
2. The **domain name**: `www.minds.com`
3. The **path**: `plus`

### Extraction Steps

1. **Extract Protocol**:
   - Use the `split` method with the delimiter `://` (colon followed by two slashes).
   - The result is an array where the first element (at index `0`) is the protocol.

2. **Extract Domain and Path**:
   - Take the substring after the protocol, which can be stored in a variable `remainingURL`.
   - Use the `split` method again on `remainingURL` with the delimiter `/` to separate domain and path.
   - The first element (at index `0`) of the new array will be the domain, and the second element (at index `1`) will be the path.

### Code Example

Here's a simplified version of the extraction process in pseudocode:

```pseudo
URL = "https://www.minds.com/plus"

// Extracting Protocol
protocol = URL.split("://")[0]

// Remaining URL after splitting out the protocol
remainingURL = URL.split("://")[1]

// Extracting Domain and Path
remainingURLParts = remainingURL.split("/")
domain = remainingURLParts[0]
path = remainingURLParts[1]
```

### Conclusion

The exercise illustrated how to effectively use the `split` method to parse a URL string into its constituent parts. The process involves possibly multiple calls to `split`, and emphasizes that the original string remains unchanged as `split` generates a new array.

**Key Takeaways**:
- The `split` method can take multiple-character delimiters.
- Accessing array elements is done using zero-based indexing.
- Variables can help manage complexity by abstracting parts of the process.

Thank you for participating in this lesson, and looking forward to more learning ahead!

Now, I want to give you a challenge. Say I have the following URL, https slash slash colon slash slash
www.oops www.mines.com slash plus. So I have this URL for certain website inside a string. And I have
the following elements in the URL. I have the https colon slash slash part. I have the www.mines.com part.
And I have the plus slash plus. So say we want to extract this part of the URL. And then we want to
extract this part. And then we want to extract this part. So how would we do it knowing that we only have
the single entities, the string with the URL? So I want you to do that as a challenge. You might not
necessarily have to do only one call of split. You might have to call it multiple times. And keep
keep in mind that the split method does not modify the original. So I always remember it creates a new
array from the original string. So how did it go? So let's say this guy is in a variable. I'll just
call it URL. So URL holds the URL that we're working with. We want to extract this part, this part,
and this part. So we can use multiple goals using split. So let's grab this first one. So that's going
to be let's call it protocol. And then we're going to take URL, we're going to split into what? What's
operator can we use just to get this guy? Let me just backtrack a little bit. I want to remove
this variable definition. I just want to work like this. I don't want to define any variable.
So to get to HTTPS, this part looks like this guy here could be a delimiter because there's no
such thing afterward, right? You could try the colon too, assuming there's no other colon.
After that, it's another choice. So I just want to illustrate you don't have to necessarily have
a single character as the delimiter. So you can also put colon slash slash and see what you get.
So colon slash slash as the delimiter for the split method will give you two
elements, a two element array of the HTTPS and the rest of the URL. So now you need to get
the HTTPS because it's an array has two elements. So how can we access
this? The first element of this array. Remember, we use the brackets with the index
to access elements of an array. What's the element of the first element? Remember,
we count from zero, so it's going to be sub zero. So you can do the same thing we did before. Then
you add a bracket sub zero. Okay, because this guy right here on the left hand side that's highlighted
gives you the array. And from this array, you're going to grab the element at index sub zero,
which is the first element. So that gives you HTTPS. So in your program, you could
store this guy in a variable like I was going to do before. But let's leave it as an exercise for you.
I don't really care about storing that in a variable, I just want to illustrate how to find
how to grab the HTTPS. Now let's grab the other parts of the string, we figure out how to get
the HTTPS. How would we get this other part? Well, we could have used this guy,
and that would give us HTTPS, then would give us this guy, but then this guy would have to be
split again, right? Because we only want the first part of the this address, right? So let's do
this guy. And then let's grab the second element with sub one. So that gives you that. Okay.
Now if this whole thing is already confusing to you, you can always put that in a variable to
abstract it. So let's put remaining URL. This whole thing, let's assign it to a variable
called remaining URL. So now you abstracted everything that you did with that command,
those state that statement in a variable. So the variable only holds the string,
so you don't have to know how it was, how this string was obtained. So now you don't care
anymore about this part. So forget about that. Now we have this guy, this URL, remaining URL,
that contains this string. Now we can solve the problem, right? Because we made it simpler, and we
don't care about looking at this anymore, because all we have right here is a single string. And we
know the separator is the slash. So to get this guy, I split with a slash, right? And to get this guy,
the same thing, except I grabbed the second element of the resulting array. So let's do it.
So let's do it. dot split. What's the delimiter? Slash. Then what does this operation give you?
It gives you, this guy is a string, so you're going to split the string into an array,
right? So it gives you that an array of two elements. The first element is the
www.minds.com. Second element is the plus. So to get the first guy, the minds.com is sub
zero, right? Because it's an array. To get the second guy is sub one. Now we solved it. Now if you
feel this guy is already too confusing, like I said before, you can always grab this part
and abstract it into another variable. So we can say remaining URL parts,
yet another variable with this guy. So this variable has a good name, remaining URL parts,
meaning you're going to have a list of things. So you're going to take the remaining URL split
with slash, you get an array, right? Remaining URL parts. Now working with this guy, you're
ready to know, okay, this guy is an array. You don't care how it was obtained. This part is done.
So you only have an array. So how can I grab the first element? You put, say the name of the
array, sub the index, which is zero. So that's it. And then how do you get the second element?
Name of the array, sub one, index one is the second element because you count from zero.
Okay. So there, there you go, we have obtained the three parts we wanted. Going back, the HTTPS,
the minds.com part and the plus. So we needed like two calls to split if you notice.
If you keep track of what we did, we first have to split using the colon slash slash to get the
HTTPS to be separated from the rest of the URL. Then we have to take this second element here of
this array and split it again using the slash. And we get this other array. And then we finally
are able to access the three parts we want. Okay. Just reviewing again, we learn in this exercise
how to use split to take a string and break it down into smaller parts.
And you'll give split an argument that's the separator.
Separator could be anything, any could be one character, two characters, and so on.
All right. So thank you so much for watching and the K tech world. And until the next lesson, see you.


fff8-25 Splitting a URL string into an Array in JavaScript

Using join to Create a String From an Array in JavaScript

# Summary of NBK Attack World Lesson

In this lesson, we learned how to convert an array of elements into a string by combining them with a specified separator using the `join` method. 

## Key Concepts:

1. **Creating an Array:**
   - An array can be created using square brackets (`[]`).
   - Example: An array of phone numbers:
     ```javascript
     let numbers = [123, 456, 7891];
     ```

2. **Using the `join` Method:**
   - The `join` method combines all elements of an array into a string, inserting a specified separator between elements.
   - Example: To combine numbers with a dash (`-`):
     ```javascript
     let result = numbers.join('-'); // Output: "123-456-7891"
     ```

3. **Example with Words:**
   - An array of words can also be combined into a sentence.
   - Example: Creating a sentence from words:
     ```javascript
     let words = ['there', 'is', 'a', 'cat', 'on', 'the', 'table'];
     let sentence = words.join(' '); // Output: "there is a cat on the table"
     ```

4. **String Concatenation:**
   - To add punctuation (like a period) to the result string, concatenation can be used.
   - Example:
     ```javascript
     let finalSentence = sentence + '.'; // Output: "there is a cat on the table."
     ```

## Review:
- We explored how the `join` method works to convert arrays to strings, both for numbers and words.
- We recognized that the separator can vary (e.g., dashes for numbers or spaces for words).
- We also learned how to enhance our strings with additional characters using concatenation.

**End of Lesson.**

Welcome to NBK Attack World. This lesson we will learn how to get an array and
combine all the elements into a string. So this time we're going from array to
the string type. So let's get started. As usual let's take an example right off
the bat. Suppose I have say an array. I am going to use square brackets right here.
An array of three elements and those elements each one of them will be a
number. So let's think about phone numbers for example. So let me just create
the array right here. First element is the number 1 2 3. Second element is going
to be another number 4 5 6 and then the third element is going to be 7 8 9 0 or 1.
Let's put 1. So here we have an array. Notice the square brackets right and we
have 1 2 3 elements and they're separated by a comma right. I just add an extra space
after the comma by convention style convention okay. So we have three numbers
here. Let's say we want to somehow combine all these numbers into a string and
between each number we want a dash okay. So how can we accomplish that? So we want
to be able to come from here and generate this guy right here on the
right hand side. So to do that we're going to use the method join on the array
okay. So we're going to learn about join. So we're going from an array to a string
with some separator in between each element and that's going to be a dash
in our case. So let's get started. So given the array right here let's do let's
first put the sky in a variable. I'm going to use lat in case I want to change it
later on okay. Let's call it numbers. So this is an array right with three
elements and each of the elements is a number. Now let's do numbers dot join.
Then the join method on the array type okay. It requires the argument telling it
what's the delimiter. What's the separator you want when I'm combining all
these elements together. This case is going to be this dash right but we have
to enclose it in quotes so it becomes a string. So let's see what we get. So we
get each element value separated by a dash which is what the argument to the
method join and that's a resulting string okay. It generates a new string from
the numbers array. Numbers array remains unchanged and the moment you do the
operation you get a string a new string. So that's join. The separator doesn't
have to be a dash could be anything you want. For example I could put star five
star. So you would get a five star star in between each element okay. So that's one
example. Let's try another example now of a sentence. We want to build a sentence
from an array of words. Let's build an array of words. Let's start with the
square brackets. We're creating an array a list of items. Let's add a word to it.
Let's have a word for each element of the array. Let's use the example there is a
cat on the table. It's a fourth element cat with element on its element the
element table. So we have an array right here. Each element is a string notice the
quotes surrounding each sequence of characters. In this case we have a word
as each element. So let's create a variable here. I'm going to use let just in
case I need to change it later on. Let's call it words. This is a variable that
holds an array. A list of items. Each item each element of this array is a
string representing a word. Words is an array that has seven elements. Each element is a word.
Let's make a sentence out of this array. The sentence is going to be a single string.
All these guys combine and what's in between each word. It's a wide space. So how can we do
that knowing that you can use the join method on an array. I want to see you try it by yourself.
Pause the video. Once you're done we're going to do it together. So how did it go. So let's do
words. Name of the variable that holds the array dot. The method is called join. Got our parentheses
here because it's a function call. Now we want to join all the elements of this array using the
following separator the wide space. I just type a wide space right here. Let's see what we get.
We get the sentence there is a cat on the table. There is no period but we can add it easily. And
I'll show you just now how to add a period. It's very simple. You can use the string concatenation
technique. Remember that. So if this guy gives you the sentence all you need is to add a period.
You can do so by concatenating with the plus and the period inside quotes. So the string. So you're
taking this guy whose output is a string this whole thing and you're adding a period and you're
going to get a new string with the period right at the end. Okay. So we use the string concatenation
to add the period right there. So let's review what we did in this lesson. In this lesson we
learn about the joint method of the array type. We learn how to get an array of elements and create
a string with all the elements of the array combined separated by some sort of the limiter. We did
our first example with three numbers inside a list. Then we generate a string with all those
numbers separated by a dash. Could be some sort of phone number formatting. Then we did the example
of the sentence. We have an array of words. Each word is a string. Then we want to generate a
sentence a whole string. We took the array of words and use a joint with the wide space as the
separator. Then we got the string with the sentence. We added the period just to
as an extra using string concatenation. Okay. That's it for this lesson and I'll see you on the next one.


fff8-26 Using join to Create a String From an Array in JavaScript

Using the if Statement to Control the Flow in JavaScript

# Summary of Control Flow Introduction Lesson

## Overview
In this lesson, we learn about control flow in programming, specifically focusing on the `if` statement. Control flow allows us to alter the course of our program based on certain conditions, much like navigating intersections on a road.

## Key Concepts

- **Control Flow**: The ability to dictate the path of the program based on conditions.
- **If Statement**: A conditional statement that executes code based on whether a condition is true or false.

### Conditional Logic
- The basic structure is: 
  ```plaintext
  if (condition) {
      // Execute this block if condition is true
  } else {
      // Execute this block if condition is false
  }
  ```

### Example: Age Verification
1. **Scenario**: You can only enter a location if you are at least 18 years old.
2. **Implementation**:
   - Create a variable named `age`.
   - Use an `if` statement to check if `age` is greater than or equal to 18.

#### Code Example
```javascript
let age = 35; // Example age variable
if (age >= 18) {
    console.log("You may enter because you are at least 18.");
}
```

### Execution Flow
- If `age` is 35, the condition `age >= 18` evaluates to true, and the message is printed.
- If `age` is set to 16:
  ```javascript
  age = 16; // Change age to 16
  if (age >= 18) {
      console.log("You may enter because you are at least 18.");
  }
  ```
  The condition evaluates to false, and nothing is printed.

### Next Steps
- Introducing the `else` block to handle cases where conditions are false will be covered in the next lesson.

--- 

This lesson serves as a foundation for understanding conditional statements in programming, enabling developers to control the flow of execution based on specific criteria.

Welcome to NBK Attack Well. In this lesson we're going to be introduced to
control flow. We're gonna learn about the if statement. So imagine your program is
a road and you're going down this road but it's only one way right? Now imagine
if you want to be able to change the course of your program. Imagine if that
road you end up in an intersection where you can go this way or that way. So how
can we accomplish that in our program? How can we change the course of the
program based on some condition? You can make the decision to go this way or to
go that way and that's control flow. You can control which way your program is
going to go and to do that we're gonna learn about the if statement. Okay? So
basically if a certain condition is true you're gonna go this way otherwise if
the condition is false you're gonna go the other way. In the programming world
the terms to think about are usually if this condition is true do this else
that's a keyword do this other thing. So let's get started. So let's say you are
at some place where you can only enter if you're at least 18 years of age and
older. So you can enter if you are at least 18. Now how can we do this in our
program? Let's imagine let's make it happen here. Let's make a variable called
age to hold our age. Let me make it let so I can change it later. So let's say my
age is I'm just gonna make it out 35. So I'm storing a number inside the variable
age. Now in my program somewhere down the road I want to be able to ask the
question are you at least 18 years old if so go this way otherwise go the other
way. To do that we're gonna use the if statement. So if you are at least 18 go
this way I'm just making it up some pseudocode for you here otherwise go the
other way. So if the condition that you are at least 18 you're gonna do go this
way otherwise you're gonna go another way if you're not at least 18. So to do this
the condition right here is going to be a boolean variable boolean value okay. So
remember boolean value is either true or false. So if this condition right here
is true okay true the result of this condition is true you're gonna go this
way you're gonna do something otherwise if this condition turns out to be false
you're gonna do something else you want to go the other way okay. Now that of the
way let me just give a concrete example how to do this. So let's say we want to
say a message console log remember console log to print a message to the
console you are at least 18. Let's say we want to say this message you may enter
because you are at least 18. So I want to display this message if the variable
age holds the value at least 18. So we're gonna say if and open parentheses
and then the condition here the condition as the age has to be greater
than or equal to 18. So this is the condition okay and then we're gonna do
the following open some braces right here break some line add some
indentation for a style we're gonna say the console log right here and I'm gonna
add a semicolon by convention okay so let me explain what I just wrote the
condition of the if statement is right here if this condition turns out to
yield the value true everything in between the braces will be executed in
this case is going to print out to the console this message that you may enter.
Now I use space here space here by convention style convention and I add
indentation because I open a new block using braces so all these are style
conventions that I highly encourage you to also follow. So the condition right
here age is a variable right now the value is 35 so 35 is gonna go here 35 is
that greater than or equal to 18 that is going to be true so this guy is gonna
become true okay because of that everything inside within the following
brace block this code block right here everything in between the opening and
closing curly braces will be executed it can be one or more statements okay so
let me just revert and just I'm gonna enter and you'll see what happens I get
this message right here because the condition is true now what happens if
the age is now set to 16 for example I set the age to 16 now let's try the same
thing I can press the up arrow to go back to what I wrote before by the way then
let's see what we get let's just age has 16 now so 16 is gonna go here 16 is
greater than or equal to 18 that is going to be false so false this condition
is false because of that this block will not be executed therefore we're not
gonna get any message let's try it out so we got nothing out of that okay because
this value turned out to be false and therefore this block was not executed now
what if we want to execute something in case the condition is false we're gonna
learn that next and that's called the else block so see you on the next lesson


fff8-27 Using the if Statement to Control the Flow in JavaScript

Using “else” to Deal with False if Condition in JavaScript

# NVK Tech World: Understanding the Else Block

Welcome back to NVK Tech World! In this lesson, we will explore the `else` block in programming.

## Introduction to the Else Block

- We previously discussed an example where we check if a person's age is greater than or equal to 18.
- If the condition is true, we print a message allowing entry. 
- If the condition is false (i.e., the person is under 18), we want to display a different message indicating that entry is not permitted.

### Implementing the Else Block

1. **Syntax**:
   - After the `if` statement, add the `else` block using the following structure:
     ```javascript
     if (condition) {
         // code to execute if condition is true
     } else {
         // code to execute if condition is false
     }
     ```

2. **Example**:
   - For age under 18:
     ```javascript
     else {
         print("You are under 18. Sorry, but you cannot enter.");
     }
     ```

### Execution Flow

- If the `if` condition is true (e.g., age is 18 or older), the corresponding block executes, and the `else` block is skipped.
- If the `if` condition is false (e.g., age is 16), the program executes the statements inside the `else` block.

### Experimenting with Age Values

- **Case 1**: When age is set to 16:
  - Output: "You are under 18. Sorry, but you cannot enter."
  
- **Case 2**: When age is set to 18:
  - Output: "You are at least 18 years old, you may enter."

### Summary

- The `else` block handles the scenario when the `if` condition is false.
- Only the code block corresponding to the true condition executes when the `if` statement evaluates to true, while everything in the `else` block is skipped.

Thank you for learning about the `else` block in this lesson. See you in the next lesson!

Welcome to NVK Tech World. Let's continue. We're now going to learn about the else block.
Picking up from the previous example right here. So if the age is greater than or equal to 18,
you're going to print out a message saying that you may enter. Now what if you're not
over or at least 18. We want to display a message that you cannot enter. So to do that we're going to do the else block.
So right after the if, we can add an else block. So I'm going to type else, open some curly braces,
a code block, add some indentation because there's a new code block. I'm going to usually add two spaces.
I'm going to print out a message saying you are under 18. Sorry, but you cannot enter.
So what's going to happen is if this condition in the if clause right here is false, it's going to go here and execute those blocks.
If the condition is false, it goes to the else block and executes all the statements there.
I'd like style convention add the else right here under the closing brace of the if. Some people like doing like this.
It doesn't matter. Choose your own preferred style. Okay.
So let's try it out. Remember age is 16, as I said before. Let's try it out.
So I executed this guy. And then I got the following message you are under 18. Sorry, but you cannot enter.
Okay, so that's the else block getting executed because the condition was false.
Now let's change the age. Let's put it at 18. Age is now 18. Let's try the same thing again.
I'll help Aero to go reference my previous statements and execute it again.
Now I get the message you are at least 18 years old, you may enter.
And that is because as if we analyze the code right here, age holds the number 18.
18 is greater than or equal to 18. This becomes true because the condition in the if statement parentheses here,
is A is true. What gets executed is whatever is mentioned in the block for the if statement.
And it skips everything else. Okay, this guy, this part does not get executed because the condition here is true.
Therefore, only this part gets executed. Everything else as part of the if else statement is skipped.
This guy does not get executed. Okay.
So that's it for this lesson. We learn about the else part of the if statement.
If the condition is true, it executes the code block defined by the curly braces right after the if.
If the condition is false, it goes to the else block. Okay, and everything there in the else is executed.
Remember, if the condition is true for the if statement, only the part here, only the code block right after the if line is executed.
Everything else in the else block, for example, is skipped.
So, see you on the next lesson.


fff8-28 Using “else” to Deal with False if Condition in JavaScript

JavaScript Exercise: if Statement with Array Access (Phone Number Parts)

# Summary of NVK Tech World Transcript

## Exercise Overview
The exercise involves using control flow statements (`if`, `else`) and working with arrays in programming. The example provided is about handling phone numbers, specifically checking an area code from an array.

## Example Array
- The array consists of three elements representing parts of a hypothetical phone number:
  - Element 1: `1, 2, 3`
  - Element 2: `4, 5, 6`
  - Element 3: `7, 8, 9, 1`

Here, the first element `1, 2, 3` is treated as the area code.

## Task
The program needs to check if the area code (the first element) is `1, 2, 3`:
- If it matches, output: “Found phone number with area code 1, 2, 3.”
- If it does not match, output: “The phone number area code does not match.”

## Implementation Steps
1. **Declare the Array:**
   ```javascript
   let phoneNumberParts = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1];
   ```

2. **Check the First Element:**
   - Access the first element using index `0`.
   - Use strict equality (`===`) for comparison.

3. **Write the Conditional Logic:**
   ```javascript
   if (phoneNumberParts[0] === 123) {
       console.log("Found phone number with area code 1, 2, 3.");
   } else {
       console.log("The phone number area code does not match.");
   }
   ```

## Further Example
- If the array is changed to `[7, 8, 1, 9, 8, 7, 6, 5, 4, 3]`, the condition will evaluate to false:
  - Output: “The phone number area code does not match.”

## Conclusion
The lesson emphasizes the usage of conditional statements and arrays, providing foundational knowledge for further programming exercises.

Welcome to NVK Tech World. I have an exercise for you and that's gonna involve
control flow of the NIF, ELSE block and arrays. So let's suppose we have an array
with three elements and each element is a number. Let's think about something
like phone numbers. So say we have this array right here. It's an array with three
elements. First element is 1, 2, 3, number 1, 2, 3, then second element number 4, 5, 6,
third number is number 7891. So let's imagine these are parts of a phone number.
So you're processing many phone numbers in your program and you want to check for
the area code. I'm just making these numbers up by the way. They're not
necessarily something specific. So let's say the first element of this array, the
whole array itself is a phone number and this is the part of the phone number
that we're interested in. The first part is going to be the area code. In this case,
this is the area code 1, 2, 3. Now suppose we want to check in our program if we
want to check to find if the phone number is 1, 2, 3. We want to display, do
something. In this case, we're just going to display a message saying the phone
number is 1, 2, 3, something like that. Found phone number 1, 2, 3. Otherwise, we
don't really care. We're just going to say this phone number just doesn't match 1, 2, 3.
So let's add, store this array in a variable. I'm going to use let in case I need to change it later.
Let, let me say, let's call it phone number part about that. So this variable phone number part,
I use the camel case naming convention by the way, if you haven't forgotten,
naming camel case always starts off lowercase for the very first letter, but every
following new word, the first letter has to be capitalized. All right. Now this
variable holds this array of phone number parts. We're interested in the first element of the array,
which is the area code. Like I want you to right here make
console log found phone number one of area code 1, 2, 3. If the phone number parts,
the given phone number parts in this case, I already defined it here. If it is, you assume it's going to
be stored in this variable, by the way, doesn't have to be this value, I'll be changing it.
So it's changeable, but use the same variable name. Then if it's, if you find that guy to be the value
one, two, three, print out a message found phone number area code one, two, three. Otherwise,
if you did not find one, two, three for the for the area code, just say a message.
The phone number area code does not match. Okay, so that's an exercise for you.
Just as a hint, you're going to use the if statement.
You can pause the video and trade out. And then we're going to do the solution after that.
So how did it go? So we have to check first.
If this area code is 123, how to do that, we're going to do a comparison. So phone number parts
is the variable that holds all these three elements. How can we get the first element?
This is an array. So to get access elements of an array, you can use the brackets square brackets,
right after the name of the array, and you have to give it the index index always counts from zero.
So the first element here has index zero. And then this guy has index one and this guy index
two and so on. So we are only interested in the first one. So it's going to be zero.
There you go. So we grab 123. And now what we're going to do is we have to check if this guy is
indeed 123. We're going to make a comparison of equality. We're going to do triple equals.
I always use triple equals initially. I always want to test for strict equality.
In rare cases, do I want to use the double equals? Okay, it's just to make it strict. It's better and
causes you to have less bucks down the less bugs down the road. So be aware that I will always start
with the triple equals to be a strict equality. So we're going to check if that guy is the number 123.
Well, this case is going to be true, right? But it might not be true if phone number part holds
different phone numbers. Okay, so let's have this condition now as part of our if statement. We're
going to say if open parenthesis, this is the condition close parenthesis, then open the if block
with curly braces, then add some mediation to space in my by convention for me.
Then you're going to say found phone number with area code 123, something like that.
Now, if this condition is true, this will execute. But what if this guy holds different values?
So we want to take care of that as well. We're going to use the else
block right here, in case this condition turns out to be false. We're going to say that the phone
number did not match. Phone number area code did not match something like that.
Okay, so we expected to run what because this guy we know, given the value that I set right here,
it's going to find 123 for the first element. So it's going to execute this guy and skip the else block.
So found phone number area code 123. Now if I change phone number parts to be something else,
a new part array of phone number parts, let's say 781 sorry, 781 987 6543, I'm just making these up.
So let's say we have now these phone number parts is a different value. Say somehow your program is
going through this list of phone number parts, all these phone numbers. And I just change it manually
so you can see but the program will do it automatically, but we don't know how to do that yet.
But let's just try the RF statement again. So with these values 781 987 6543,
we expect our condition right here first you're going to get to this array. Check the first guy is
going to be 781 right 781 triple equals 123. That's going to be false because this condition is false.
It's going to go to the else block. Everything in the else block will be executed in this case is
going to be the console log saying that phone number area code did not match. Let's try it out.
There you have it phone number code did not match. All right.
So that's it for our exercise in this lesson. And see you next time. Bye.


fff8-29 JavaScript Exercise: if Statement with Array Access (Phone Number Parts)

Using if, “else if”, else Statement in JavaScript

# MDK Tech World - Introduction to IF-ELS Statement

## Overview
In this lesson, we expand on our understanding of the IF-ELS statement to include the ELSE IF construct, enabling our program flow to follow multiple paths based on several conditions.

## Key Concepts

### 1. Basic IF-ELS Statement
- The IF-ELS statement controls the flow of the program, allowing decisions to be made based on conditions.
- **Example**: At a crossroads, if a condition is true, you take one path (left); if false, you take the other (right).

### 2. Introducing ELSE IF
- When there are more than two paths, we can use `else if` to evaluate additional conditions.
- The structure now includes:
  - **IF**: checks the first condition.
  - **ELSE IF**: checks a second condition if the first is false.
  - **ELSE**: executes if all previous conditions are false.

### 3. Code Example
Using JavaScript, we demonstrate how to implement an IF-ELS statement with ELSE IF:
```javascript
let letter = 'B'; // Example variable

if (letter === 'A') {
    console.log('The letter is A.');
} else if (letter === 'B') {
    console.log('The letter is B.');
} else {
    console.log('The letter is something else.');
}
```

### 4. Explanation of Code
- The code checks:
  - If the variable `letter` is 'A', it logs "The letter is A."
  - If not, it checks if `letter` is 'B' and logs "The letter is B."
  - If neither condition is true, it logs "The letter is something else."

### 5. Testing Different Values
- Changing the value of the `letter` variable tests different paths through the IF-ELS structure:
  - Setting `letter` to 'B' prints: "The letter is B."
  - Setting `letter` to 'A' prints: "The letter is A."

## Conclusion
The ELSE IF statement provides additional flexibility in deciding the flow of a program, allowing for multiple checks and executions based on varying conditions. We will continue to explore more aspects of programming in upcoming lessons.

Welcome to MDK Tech World.
We have learned about the IF-ELS statement.
In this lesson, we're going to go further and learn about yet another way of figuring
out where to go in the flow of your program.
In the IF-ELS statement, we learned that you can control the flow to go one way or another.
Now we're going to learn to do just that except we can go not only one of the ways, but more
than two ways.
We're going to learn about the IF-ELS statement.
So as an example, look at what we learned.
Let's look at this diagram here.
So suppose you are at a crossroads.
You have two ways of going.
This is the road and you can go this way to the left, or you can go that way to the right.
Now this perfectly illustrates the IF-ELS statement.
If a certain condition is true, you go this way down to the left.
Otherwise, else, you go the other way.
Now what if we want it to actually, the roads had not only two ways to go, but an extra way.
For example, if this guy extended like that, now we have three ways we can go, right?
We can go bottom left, strictly down, or to the right.
Now how would we do this?
That's what we're going to learn.
We're going to learn about the IF-ELS statement.
Let's look at some code.
So I'm going to open the text editor here.
And this is what we learned so far.
Here I have my text editor.
I am using Adam.
And it's colored differently here because there's syntax highlighting.
That's when certain keywords in the language, in this case the JavaScript language, have
some special meaning and they highlight with a different color.
Now we learned this construct before, right?
So if openTorrentis is some condition here, some expression that yields a Boolean variable,
value, that's true or false, right?
Then we're going to execute this piece of code in between the IF block, in between these
curly braces.
By the way, these slash slash whatever here, it's called a comment.
Commenting after a slash slash is taken as a comment by the JavaScript language and this
will not get executed at all.
So I just use this comment to illustrate, to make a comment that do this, whatever is
within these curly braces.
So if this condition turns out to be false, it's not going to execute the IF statement
block, it's going to execute the else part, this guy right here.
If this condition turns out to be false, it's going to execute the else block.
Everything in between the opening and closing curly brace for the else clause will be executed.
Again I use slash slash, otherwise do this just to make a comment here.
There will be some code right here.
We would do whatever, console log, etc, etc.
I just want to illustrate that this part here, whatever you write here, will be executed
if the condition is false.
So that's the IF else, we already know that, right?
Now we introduced the third path in the road in our diagram, remember?
So how do we do that?
Let's look at some code.
Here I have another file, illustrating the else if part.
So not only now do we have IF and else, we have something in between and that's called
the else if.
This else if right here will be an in-between condition that will be checked before you
get to the else case.
So let's start from the beginning.
So you start out saying if certain condition is going to be checked, right?
Now if this condition is true, we're all good, we're going to execute everything in between
the IF clause block.
Now everything else will be skipped, will not be executed.
Now we understand that.
Now if this condition is false, what's going to happen is the following.
It's going to go to the next statement which turns out to be an else if.
Now else if allows you to check yet another condition.
So you can put another condition here to see if that turns out to be true.
We know this if condition here was false.
Then it's going to go to the else if and check this other condition.
If this condition turns out to be true, it's going to execute this else if block whatever
code you put in between these curly braces.
Everything else will be ignored, okay?
So only this part will be executed.
Now if the condition of the else if is false, then it's going to go finally to the else
statement and execute whatever you placed in between the curly braces.
Okay?
Just like the normal IF, ELSE, FLOW you learned before.
So the difference now is you can check for extra condition.
An extra condition here with this else if is trying to go straight to the end of the
last resort case with the else.
So that's the else if.
Let's illustrate that with an example.
Let's jump to code.
I'm going back to the browser to the browser console.
I'm using Firefox by the way.
So let's say you have some variable.
Let's start some letter for example, letter B. So I'm going to start a B. It's a string.
Letter B. Let me use that by the way in case I need to change it later.
So this variable called letter stores the letter B. Let's make an IF statement to check
if the letter is A, B, or any other letter.
So to start out, IF the letter is A, we're going to do a console log.
I haven't put the condition so I want you to try with me.
Let me just write out what we want to accomplish with each case.
So in the first case, the letter is A. Now the second case, we're going to do an else
if.
We're going to say the letter is B. And then the other case, in case any other letter,
the letter is not A, nor is it B. It could be C, D, E, F, G, whatever up to Z. Whatever
character.
Now these are the cases.
Now for the first one, we want to check if the letter is A. What's the condition here?
So the variable is letter and you want to check if the value is A. A is a string.
So we're going to say letter.
We're going to use the triple equals, open quotes, A. So if the letter is A, we're going
to print to the console the letters A.
Now I want to see you do the else if condition here, there.
So how did it go?
We're going to have letter, triple equals what?
B. So it's going to check the value of this variable to see if it's strictly equal to
the letter B, the string with the character B. Upper case, by the way.
All right?
It's case sensitive, so be sure to be typing upper case.
Otherwise if the letter is not A, it's not B, then it's got to be something else.
We're going to do this console lot.
Okay?
Notice that it's checking first this case is the letter A if so execute this guy.
Otherwise go to the next else if check the condition.
Okay, is the letter B?
If so, execute this.
Otherwise if this condition is false, execute the else.
Let's try it out.
So the letter is B right now.
So what would you expect to be console lot?
You would expect the else if, right?
There you go.
The letter is B. Now let's try letter being A. Let me redefine the variable letter to
be A. Then I'm going to do the same thing we typed before.
I use the up arrow in my keyboard to go back to my previous statements that I typed before.
Let's try it again.
Now the letter is A. Okay?
Because I changed the letter to A, it went into the if statement.
Check the condition.
Letter in this case is A. So this is going to be true.
Execute the if block statements and everything else is skipped, is ignored and will not be
executed.
Okay?
So that's it for the else if statement.
We have if, else if, else.
Okay?
That is it for this lesson and I'll see you on the next one.


fff8-30 Using if, “else if”, else Statement in JavaScript

Mapping a Score to Letter Grade (If Else If Else Statement Exercise) using JavaScript

```markdown
# NDK Tech World Lesson Summary

In this lesson, we practiced the use of the `if-else` statement by mapping student exam scores to letter grades. Here’s a breakdown of the exercise:

## Objective
To automate the process of assigning letter grades based on student scores using programming.

## Grading Scale
The following mapping table was introduced:

- **A**: 90 - 100
- **B**: 80 - 89
- **C**: 70 - 79
- **D**: 60 - 69
- **F**: Below 60 (fail)

## Approach
1. **Using `if-else` Statements**:
   - The `if-else` structure allows for multiple conditions through `if`, `else if`, and `else`.
   - You can chain as many `else if` statements as needed to cover all scoring ranges.

2. **Execution Flow**:
   - The program starts by checking the first condition. If it's true, it executes the associated block and ignores the rest.
   - If false, it moves to the next `else if` condition, repeating this process until it either finds a true condition or defaults to `else`.

## Next Steps
Write out the code that implements these conditions based on the grading scale.

---

This lesson highlights the logic of condition-based programming and provides a framework for automating grade assignment.
```

Welcome back to NDK Tech World. In this lesson, we are going to do an exercise to practice the if else statement.
The exercise is about mapping a score to a letter grade. So let's get started.
Suppose you are in charge of a, you are working for a school and you have to map certain student exam test scores to a letter grade.
Let's say as an example, this is the mapping table for the school. For example, if a student does a test and he gets 81 for his score.
Now, according to this table, if you get between 80 and 89, you should get a B as your letter grade. So that's what the student would get.
Now, suppose there are so many students and doing this by hand is kind of tedious. So you want to write a program to automate all this process.
The program would read all the test scores and then it would give you all the letter grades. So how can we accomplish that?
We want to just focus on the part of mapping the score to a letter grade. Okay?
So it looks like we have some cases here. We have the case where if you get between 90 and 100 points, you're going to get an A.
That's the first case. And if you get between 80 and 89, you're going to get a B.
If you get between 70 and 79 points, you're going to get a C. If you get between 60 and 69 a D.
And if you get any other kind of points, that is below 59, you get an F. You fail.
So we have five cases. So how would we accomplish this?
Let's go back to the if-else. So we know we can do two cases like this. If-else.
And then we learn about if-else-if-else. We can do three cases, but we don't really know how to do five cases.
Now, the beauty of if-else-if is that you can add as many as you'd like. So it doesn't have to necessarily be just one else if.
So you can actually have multiple. You can have another else if in between. And that would be four conditions.
You can add another one and it would be five. So one, two, three, four, five conditions.
So this is actually what we would use to solve this problem.
So let me just walk through this again so we can review what this does.
It starts off at the if condition here. If this condition is true, execute this and ignore everything else.
Otherwise, go to the next else if, check for some condition.
If the condition is true, execute this block of code and ignore everything else.
Now, if this condition turns out to be false, it goes on and checks the next else if condition.
Hey, is this true or false? If it's true, execute this, ignore everything else. Skip everything else.
Now, if this condition is false, it goes to the next else if, check this condition again.
If it's true, execute this, ignores everything else. Otherwise, if this condition is false, you're going to finally end up with the else.
And there's nothing else you can do but execute this else block.
You can see that's pretty much how it works. Kind of a tedious to walk through, but remember to always walk through if you find yourself confused with what's going on.
So this is what we're going to use for this example. It's pretty much that. We just got to figure out the conditions.
Every one of these conditions. So we have the condition. The first one is for letter grade A. The second one is for B and C, D and then finally F, which is the case where we don't really care.
If all the other conditions have failed, then it has to be an F grade.
So let's write it out.


fff8-31 Mapping a Score to Letter Grade (If Else If Else Statement Exercise) using JavaScript

Solution to Mapping a Score to Letter Grade in JavaScript

# Transcript Summary

Here's a summary of the discussed concepts regarding mapping score grades to letter grades using condition checks in programming.

## Letter Grade Mapping

- **Score Variable**: A variable `score` is defined to hold student score values, initially set to **85** for testing.
- **Letter Variable**: A variable `letter` is defined to hold the corresponding letter grade, initially set without a value.

## Grade Conditions

1. **Grade A**: 
   - Condition: If `score >= 90`
   - Action: Assign `letter = "A"`

2. **Grade B**: 
   - Condition: If `score < 90` and `score >= 80`
   - Action: Assign `letter = "B"`

3. **Grade C**: 
   - Condition: If `score < 80` and `score >= 70`
   - Action: Assign `letter = "C"`

4. **Grade D**: 
   - Condition: If `score < 70` and `score >= 60`
   - Action: Assign `letter = "D"`

5. **Grade F**: 
   - Condition: If `score < 60`
   - Action: Assign `letter = "F"`

## Key Points

- Use of `if`, `else if`, and `else` constructs effectively checks multiple conditions sequentially.
- If the score passes through all conditions without assignment, it falls through to the final case (else).

This structure allows for a clear and systematic grading system based on defined score ranges.

Let me first have the letter grade mapping table right here on the right hand side so
we can have a reference.
Now the first condition right here is going to be what?
Let's say we have right here you have the score right?
Let me make a variable.
Let's score be whatever.
I'm just going to get an arbitrary value so we can test it out later.
Let's give it 85 the number.
The score is the variable that is going to hold the score, the number of points.
As an example I put 85 right here.
We can use this variable in our condition checks.
And then please use the variable letter to assign a letter.
Since we don't know yet I'm just going to do a letter so you can define later in each
of these condition code blocks.
The variable score holds the number of points.
You have to use this in the conditions.
Then once you figure out the conditions you're going to assign a value to the letter variable.
So the first condition is what?
If the letter grade is a.
How can we do this?
Well the score has to be between 90 and 100.
So let's assume the score never goes beyond 100 so we can just say what?
If the score is greater than what?
In this case it would be 89 right?
So if the score is greater than 89 that is 90, 91 and so on.
Assume it never goes beyond 100.
We're fine ignoring the upper bounds.
And we're going to assign the letter a.
Okay let's review what we did.
The variable score holds the number of points we want to check.
If this is greater than 89 that is it could be 90, it could be 91 all the way to 100.
Then we assign the string a to the variable letter.
Okay?
Now do you know another way of writing this guy?
Instead of saying 89 you want to say 90?
Yeah another way is you can say greater than or equal to 90.
And this is just another way I think it looks better.
It's up to you to choose which way.
So if the score is greater than or equal to 90 we're going to assign the letter a.
Now as an exercise I want you to do the next case which is the letter grade b.
Note that this condition will have been false by the time you reach this condition.
So pause the video and try it for yourself.
So how did it go?
So if the score is not greater than or equal to 90 then it has to be less than 90 right?
So in order for us to assign the letter b we just need to check if the score is greater
than or equal to what?
What's the lower bound for b?
It's 80.
Then if that is the case we assign the letter b.
That I did not care for 89 this upper bound because we already knew that it checked already
for the value if it's greater than or equal to 90.
Since we already know this is false if the score was indeed this condition was less then
this would go here and then you just need to check if it's at least 80 because we already
know it's at most 89 because of this condition would have failed.
Okay and in the same fashion let's do the other one.
Now if it's c we expect the score this is going to be false then it's going to be less
than 80.
So it's less than 80 and we have to check if it's at least 70.
So score greater than or equal to 70.
In this case we assign the letter c.
Notice that I always use the semicolon at the end of my statements as I previously mentioned
in another video.
That's a convention that I would use.
So just so you know.
Now let's go to the next condition that's d.
Now assuming score is less than 70 it would go to this else if right here then we need
only check if the score is at least 60.
So if the score is greater than or equal to 60 if that is the case we assign the value
d the string containing the character d in uppercase to the variable letter.
Okay now for the final case it actually turns out to be pretty easy because we don't have
to check any condition.
We already know after it went through this through this through this and finally through
score greater than or equal to 60 if this turns out to be false it means the score it
has to be less than 60 which could be between 0 and 59 assuming the score is never lower
than 0.
So we were just assigned the letter f for the else case.
That's when it fails because all these conditions would have been would have failed if the score
in d turned out to be less than 60.
So as you can see the if else if construct allows you to check for an infinite number
of cases and you just keep checking condition after condition after condition until you
hit the last resort which is the else.
So in the if else if else construct you're always going to do something no matter what
but it's going to check the first one if it's false go to the next one false and go to the
next one and so on until it hits the else when everything else fails all the conditions
fail.
Okay.


fff8-32 Solution to Mapping a Score to Letter Grade in JavaScript

Running the Score to Letter Grade Mapper Script in the JavaScript Console

# Transcript Summary

In this session, the instructor tests a solution regarding calculating letter grades based on a score. The key points discussed include:

1. **Initialization of Score**: The score is initially set to 85, which is assigned a letter grade 'B'.
2. **Console Logging**: The instructor demonstrates how to display the letter grade using `console.log` combined with string concatenation to print the variable's value.
3. **JavaScript Execution**: Steps are taken to copy the code into the browser's JavaScript console for execution.
4. **Conditional Logic**: The instructor explains the logic behind determining the letter grade through conditional statements (`if` and `else if`):
   - A score of 85 results in 'B'.
   - The instructor removes a previously defined variable to avoid redeclaration issues.
5. **Testing Different Scores**: Various scores are tested to confirm that the correct letter grades are returned:
   - 70 results in 'C'
   - 60 results in 'D'
   - 80 results in 'B'
   - 100 results in 'A'
   - 8 results in 'F'
6. **Assumptions**: It is noted that the code expects scores to always be within the range of 0 to 100, and there are no checks for values outside this range.

The instructor concludes the session by confirming all cases work correctly and invites the audience to the next lesson.

Now that we have a solution, let's test it out.
So remember I assigned score to 85 in that letter, whatever.
Now at the end here, let's just do a console log just for testing purposes.
To see what letter we got.
You got the letter grade, whatever.
Now how do we print out the value of a variable here?
We can use string concatenation, remember?
You add a plus and then the name of the variable.
This way.
Okay, so you got the letter grade, whatever.
String concatenation.
Anyway, let's copy all this code to the JavaScript console in your browser, okay?
So let's go back here.
We go back to Firefox and I'm going to paste all that code here.
It's going to be a lot.
So here's all the code.
Keeping my score is 85.
Okay, now let's execute this.
What do you expect we get?
Let's walk through it before we execute.
85 is going to go here.
85 greater than or equal to 90.
False.
Go to the next else if check the condition.
It's the score greater than or equal to 80.
That's true.
So this is going to be letter B. Everything else gets skipped.
Then it goes to the console log and it prints out the message.
You got the letter grade B. Actually, I had already defined the letter variable in this
console.
So sorry about that.
Let me just go back and just remove this letter here with the letter because I had already
defined it and that's going to solve my problem.
Okay?
Without that, let's go.
Okay, you got the letter grade B as we expected.
Now let's try something else.
Let's go back to the code and change the score right here to a, let's see, 70.
70 would give us what?
C, right?
Oops.
I redeclared score because I had already declared before in the previous run.
Sorry about that again.
Let's remove the letter and just do like that.
Try again.
You got the letter grade C. Great.
Let's try for the F. What score would you give to get F?
Let's try 8.
You got the letter grade F. Great.
Let's try the, what else?
We didn't try D. Let's try 69.
You got the letter grade D. And finally, let's get the A. Let's do score 100.
And there you go.
You got the letter grade A. Okay?
So if that's it, all the cases working okay.
Once again, we assumed the score always holds a value between 0 and 100.
So we did not account for values greater than 100 and below 0.
So this is it for our exercise and I'll see you on the next lesson.
