Alana learns to code

Definition and Usage 

The parseFloat() function parses a string and returns a floating point number.

This function determines if the first character in the specified string is a number. If it is, it parses the string until it reaches the end of the number, and returns the number as a number, not as a string.

Note: Only the first number in the string is returned.

Note: Leading and trailing spaces are allowed.

Note: If the first character cannot be converted to a number, parseFloat() returns NaN. 

Syntax: 

parseFloat(string)

Example

Parse different strings:

JavaScript includes operators as in other languages. An operator performs some operation on single or multiple operands (data value) and produces a result. For example 1 + 2, where + sign is an operator and 1 is left operand and 2 is right operand. + operator adds two numeric values and produces a result which is 3 in this case.

Syntax:

<Left operand> operator <right operand>

<Left operand> operator

JavaScript includes the following categories of operators:

1. Arithmetic Operators

2. Comparison Operators

3. Logical Operators

4. Assignment Operators

5. Conditional Operators

Arithmetic Operators

Arithmetic operators are used to perform mathematical operations between numeric operands.

+ Adds two numeric operands.

- Subtract right operand from left operand.

* Multiply two numeric operands.

/ Divide left operand by right operand.

% Modulus operator. Returns remainder of two operands.

++ Increment operator. Increase operand value by one.

-- Decrement operator. Decrease value by one.

The following example demonstrates how arithmetic operators perform different tasks on operands.

Example: Arithmetic Operator

var x = 5, y = 10, z = 15;

x + y; // returns 15

y - x; // returns 5

x * y; // returns 50

y / x; // returns 2

x % 2; // returns 1

x++; // returns 6

x--; // returns 4

 + operator performs concatenation operation when one of the operands is of string type.

The following example shows how + operator performs operation on operands of different data types.

Example: + operator

var a = 5, b = “Hello ”, c = “World!”, d = 10;

a + b; // “5Hello ”

b + c; // “Hello World!”

The if statement executes a statement if a specified condition is truthy. If the condition is falsy, another statement can be executed. 

Example:

function testNum(a) { let result; if (a > 0) { result = ‘positive’; } else { result = ‘NOT positive’; } return result; } console.log(testNum(-5)); // expected output: "NOT positive"

Syntax

if (condition) {

statement1 

} else {

statement2

}

condition 

An expression that is considered to be either truthy or falsy.

statement1 

Statement that is executed if condition is truthy. Can be any statement, including further nested if statements. To execute multiple statements, use a block statement ({ ... }) to group those statements. To execute no statements, use an empty statement. 

statement2

Statement that is executed if condition is falsy and the else clause exists. Can be any statement, including block statements and further nested if statements. 

Description 

Multiple if...else statements can be nested to create an else if clause. Note that there is no elseif (in one word) keyword in JavaScript. 

if (condition1) 

statement1

else if (condition2)

statement2

else if (condtion3)

statement3

...

else

statementN

To see how this works, this is how it would look if the nesting were properly indented:

if (condition1)

statement1

else

if (condition2)

statement2

else

if (condition3)

...

To execute multiple statements within a clause, use a block statement ({ ... }) to group those statements. In general, it is a good practice to always use block statements, especially in code involving nested if statements:

if (condition) {

statements1

} else {

statements2

}

Do not confuse the primitive Boolean values true and false with truthiness or falsiness of the Boolean object. Any value that is not false, undefined, null, 0, -0, NaN, or the empty string (” “), and any object including a Boolean object whose value is false, is considered truthy when used as the condition. For example:

var b = new Boolean(false);

if (b) // this condition is truthy

Examples:

Using if...else

if (cipher_char === from_char) {

result = result + to_char;

x++;

} else {

result = result + clear_char;

}

Using else if

Note that there is no elseif syntax in JavaScript. However, you can write it with a space between else and if:

if (x > 50) {

/* do something */

} else if (x > 5) {

/* do something */

} else {

/* do something */

window.prompt( ) instructs the browser to display a dialog with an optional message prompting the user to input some text, and to wait until the user either submits the text or cancels the dialog. 

Under some conditions - for example, when the user switches tabs - the browser may not actually display a dialog, or may not wait for the user to submit text or to cancel the dialog. 

Syntax

result = windows.prompt(message, default);

Parameters

message optional

A string of text to display to the user. Can be omitted if there is nothing to show in the prompt window. 

default optional

A string containing the default value displayed in the text input field. Note that in Internet Explorer 7 and 8, if you do not provide this parameter, the string “undefined” is the default value.

Return value

A string containing the text entered by the user, or null.

Example:

let sign = prompt(”What’s your sign?”);

if (sign.toLowerCase() == “scorpio”) {

alter(”Wow! I’m a Scorpio too!”);

Many programming languages have the concept of a constant - a value that once declared can’t be changed. There are many reasons why you’d want to do this, from security (if a third party script changed such values it could cause problems) to debugging and code comprehension (it is harder to accidentally change values that shouldn’t be changed and mess things up). 

In the early days of JavaScript, constants didn’t exist. In modern JavaScript, we have the keyword const, which lets us store values that can never be changed:

const daysInWeek = 7;

const hoursInDay = 24;

const works in exactly the same way as let, except that you can’t give a const a new value. In the following example, the second line would throw an error:

const daysInWeek = 7

JavaScript is a “dynamically typed language”, which means that, unlike some other languages, you don’t need to specify what data type a variable will contain (numbers, strings, arrays, etc).

For example, if you declare a variable and give it a value enclosed in quotes, the browser treats the variable as a string:

let myString = ‘Hello’;

Even if the value contains numbers, it is still a string, so be careful:

let myNumber = ‘500′; // oops, this is still a string

typeof myNumber;

myNumber = 500; // much better - now this is a number

typeof myNumber;

Numbers

You can store numbers in variables, either whole numbers like 30 (also called integers) or decimal numbers like 2.456 (also called floats or floating point numbers). You don’t need to declare variable types in JavaScript, unlike some other programming languages. When you give a variable a number value, you don’t include quotes:

let myAge = 17;

Strings

Strings are pieces of text. When you give a variable a string value, you need to wrap it in single or double quote marks, otherwise, JavaScript tries to interpret it as another variable name. 

let dolphinGoodbye = ‘So long and thanks for all the fish’;

Booleans

Booleans are true/false values - they can have two values, true or false. These are generally used to test a condition, after which code is run as appropriate. So for example, a simple case would be:

let iAmAlive = true;

Whereas in reality it would be used more like this:

let test = 6 < 3;

This is using the “less than” operator ( < ) to test whether 6 is less than 3. As you might expect, it returns false, because 6 is not less than 3! You will learn a lot more about such operators later on in the course. 

Arrays

An array is a single object that contains multiple values enclosed in square brackets and separated by commas. Try entering the following lines into your console: 

let myNameArray = [’Chris’, ‘Bob’, ‘Jim’];

let myNumberArray = [10, 15, 40];

Once these arrays are defined, you can access each value by their location within the array. Try these lines:

myNameArray[0]; // should return ‘Chris’

myNumberArray[2] // should return 40

The square brackets specify an index value corresponding to the position of the value you want returned. You might have noticed that arrays in JavaScript are zero-indexed: the first element is at index 0.

Objects

In programming, an object is a structure of code that models a real-life object. You can have a simple object that represents a box and contains information about its width, length, and height, or you could have an object that represents a person, and contains data about their name, height, weight, what language they speak, how to say hello to them, and more.

Try entering the following line into your console: 

let dog = { name: ‘Spot’, breed: ‘Dalmatian’};

To retrieve the information stored in the object, you can use the following syntax:

At this point you may be thinking “why do we need two keywords for defining variables? Why have var and let?”.

The reasons are somewhat historical. Back when JavaScript was first created, there was only var. This works basically fine in most cases, but it has some issues in the way it works - its design can sometimes be confusing or downright annoying. So, let was created in modern versions of JavaScript, a new keyword for creating variables that works somewhat differently to var, fixing its issues in the process.

For a start, if you write a multiline JavaScript program that declares and initialises a variable, you can actually declare a variable with var after you initialise it and it will still work. For example:

myName = ‘Chris’;

function logName( ) {

console.log(myName);

}

logName ( );

var myName;

Note: This won’t work when typing individual lines into a JavaScript console, just when running multiple lines of JavaScript in a web document. 

This works because of hoisting. Hoisting no longer works with let. If we changed var to let in the above example, it would fail with an error. This is a good thing - declaring a variable after you initialise it results in confusing, harder to understand code. 

Secondly, when you use var, you can declare the same variable as many times as you like, but with let you can’t. The following would work:

var myName = ‘Chris’;

var myName = ‘Bob’;

But the following would throw an error on the second line:

let myName = ‘Chris’;

let myName = ‘Bob’;

You’d have to do this instead:

let myName = ‘Chris’;

myName = ‘Bob’;

Again, this is a sensible language decision. There is no reason to redeclare variables - it just makes things more confusing. 

A variable is a container for a value, like a number we might use in a sum, or a string we might use as part of a sentence. One special thing about variables is that their contained values can change.

Another special thing about variables is that they can contain just about anything - not just strings and numbers. Variables can also contain complex data and even entire functions to do amazing things. You’ll learn more about this as you go along.

Note: We say variables contain values. This is an important distinction to make. Variables aren’t the values themselves, they are containers for values. You can think of them being like little cardboard boxes that you can store things in. 

Note:

Don't confuse a variable that exists but has no defined value with a variable that doesn't exist at all — they are very different things. In the box analogy you saw above, not existing would mean there's no box (variable) for a value to go in. No value defined would mean that there IS a box, but it has no value inside it.

An aside on variable naming rules

You can call a variable pretty much anything you like, but there are limitations. Generally, you should stick to just using Latin characters (0-9, a-z, A-Z) and the underscore character.

You shouldn't use other characters because they may cause errors or be hard to understand for an international audience.

Don't use underscores at the start of variable names — this is used in certain JavaScript constructs to mean specific things, so may get confusing.

Don't use numbers at the start of variables. This isn't allowed and causes an error.

A safe convention to stick to is so-called "lower camel case", where you stick together multiple words, using lower case for the whole first word and then capitalise subsequent words. We've been using this for our variable names in the article so far.

Make variable names intuitive, so they describe the data they contain. Don't just use single letters/numbers, or big long phrases.

Variables are case sensitive — so myage is a different variable from myAge.

One last point: you also need to avoid using JavaScript reserved words as your variable names — by this, we mean the words that make up the actual syntax of JavaScript! So, you can't use words like var, function, let, and for as variable names. Browsers recognise them as different code items, and so you'll get errors.

Note: You can find a fairly complete list of reserved keywords to avoid at Lexical grammar — keywords.

Good name examples:

age myAge init initialColor finalOutputValue audio1 audio2

Bad name examples:

One way to think of a multi-dimensional array, is as an array of arrays. When you use brackets to access your array, the first set of brackets refers to the entires in the outer-most (the first level) array, and each additional pair of brackets refers to the next level of entries inside.

Example:

var arr = [

[1,2,3],

[4,5,6],

[7,8,9],

[[10,11,12], 13, 14]

];

arr[3];

arr[3][0];

arr[3][0][1];

arr[3] is [[10, 11, 12], 13, 14], arr[3][0] is [10, 11, 12], and arr[3][0][1] is 11. 

Unlike strings, the entries of arrays are mutable and can be changed freely.

Example:

var ourArray = [50,40,30];

ourArray[0] = 15;

ourArray now has the value [15, 40, 30].

We can access the data inside arrays using indexes.

Array indexes are written in the same bracket notation that strings use, except that instead of specifying a character, they are specifying an entry in the array. Like strings, arrays use zero-based indexing, so the first element in an array has an index of 0.

Example:

var array = [50,60,70];

array[0];

var data = array[1];

array[0] is now 50, and data has the value of 60.

You can also nest arrays within other arrays, like below:

[[”Bulls”, 23], [”White Sox”, 45]]

With JavaScript array variables, we can store several pieces of data in one place.

You start an array declaration with an opening square bracket, end it with a closing square bracket, and put a comma between each entry, like this:

You can use the same principle we just used to retrieve the last character in a string to retrieve the Nth-to-last character.

For example, you can get the value of the third-to-last letter of the var firstName = “Charles” string by using firstName[firstName.length - 3].

Example:

var firstName = “Charles”;

var thirdToLastLetter = firstName[firstName.length - 3];

In order to get the last letter of a string, you can subtract one from the string’s length.

For example, if var firstName = “Charles”, you can get the value of the last letter of the string by using firstName[firstName.length - 1].

Example:

var firstName = “Charles”;

var lastLetter = firstName[firstName.length - 1];

You can also use bracket notation to get the character at other positions within a string. 

Remember that computers start counting at 0, so the first character is actually the zeroth character.

Example:

var firstName = “Ada”;

var secondLetterOfFirstName = firstName[1];