JavaScript

In JavaScript, there are seven fundamental data types:

• Number: Number in JavaScript is similar to an int or a float data type in most other programming languages.
• String: In JavaScript strings can be surrounded by single quotes: ' … ' or double quotes " … ". Though we prefer single quotes.
• Boolean: In JavaScript booleans are just standard booleans described in the data types guide.
• Undefined: This data type is denoted by the keyword undefined (without quotes). It also represents the absence of a value though it has a different use than null.
• Null: This data type represents the intentional absence of a value, and is represented by the keyword null (without quotes).
• Symbol: A newer feature to the language, symbols are unique identifiers, useful in more complex coding. No need to worry about these for now.
• BigInt: BigInt in JavaScript is similar to a double data type in most other programming languages.

These datatypes are considered primitive data types. They are the most basic data types in the language. Objects are more complex, and we'll cover them later on.

Its also important to note that JavaScript has dynamic typing. This means we do not have to manually define the type of data we will store in each variable. Instead data types are determined automatically.

Tips

• You can use the keyword typeof to see what data type a value or variable is.
• Since JavaScript variables are dynamic you can change a variables data type but assigning it a value of a new data type and it will be updated on the fly.

JavaScript uses // for its Comment notation and /* */ for its Block Comment notation.

Declaring variables in JavaScript can be done with the let, const, and var keywords. The let and const variables were added in ES6+ (modern JavaScript). Again I want to point out that JavaScript uses dynamic variable declaration so we don't actually have to define what data type our variable is. This also means we can reassign a different value to the variable and it will change the variables data type for us.

• let allows you to mutate (change) the variable:

  let age = 30;
  age = 31;
  

• const makes a variable immutable (unchangable):

  const year = 2021;
  // This would throw an error
  year = 2022;
  

  It is worth noting that when using const the variable has to be assigned a value or JavaScript will throw an error about const missing a declaration.

• var is more of a legacy feature of JavaScript and works pretty much the same as let:

  var job = 'programmer';
  job = 'teacher';
  

  Usage of var should be mostly avoided as it is a legacy feature and has mostly been replaced by let.

In JavaScript operators are treated just like they are in most other languages and JavaScript also suppports the ++ and -- operators.

Operators allow us to change or work with values to put it simply. Let's look at an example of some simple arithmetic operators:

const now = 2037;
const ageJonas = now - 1991;
const ageSarah = now - 2018;
console.log(ageJonas, ageSarah);
// Prints: 46 19

console.log(ageJonas * 2, ageJonas / 10, 2 ** 3);
// Prints: 92 4.6 8
// 2 ** 3 means 2 to the power of 3

const firstName = 'Jonas';
const lastName = 'Cuomo';
console.log(firstName + ' ' + lastName);
// Prints: Jonas Cuomo

Now let's look at some assignment operators:

let x = 10 + 5; // 15
x += 10; // 25
x *= 4; // 100
x ++; // 101
x --; // 100

Let's also show some comparison operators:

console.log(ageJonas > ageSarah);
// Prints: true

console.log(ageSarah >= 18);
// Prints: true

Tips

• Here is a guide on operator precedence which describes the order in which operators get executed when combined together in one statement: Operator Precedence.

In JavaScript functions work pretty standard to most other programming languages. Please refer to the functions guide if you are unfamiliar with the concept of functions. JavaScript does not require us to define a return type for our functions as JavaScript is a dynamic type language. In JavaScript we also don't have to define a data type for any arguments we assign to our functions. It is important to note that we define functions with the function keyword in JavaScript. Let's look at some examples of functions in JavaScript:

function fullName (first, last) {
  console.log(first, last);
  return first + last;
}

console.log(fullName('Jonas', 'Cuomo'));
// Prints: Jonas Cuomo

You will notice that we can also nest functions which will use the output of the inner function as an input argument for the outter function. In this case I am referring to how we nested our call to the fullName function in console.log. console.log is a built in operator in JavaScript, which although isn't technically a function it can be thought of as one. Refer to my operators guide for a more indepth look at what operators are and they differ from functions.

In JavaScript we have many data structures available to us to use in our programs. The simplest of these are arrays.

Strict mode is a feature in JavaScript that will cause more errors and fail our program when we do things wrong whereas without it JavaScript will silently fail and continue running our program. Using strict mode will force us to write more secure JavaScript applications. To use strict mode add 'use strict'; to the beginning of your program.