Cheatsheets / Learn JavaScript
Introduction
Assignment Operators
An assignment operator assigns a value to its left let number = 100;
operand based on the value of its right operand. Here
are some of them:
+= addition assignment // Both statements will add 10
-= subtraction assignment number = number + 10;
*= multiplication assignment number += 10;
/= division assignment
[Link](number);
// Prints: 120
String Interpolation
String interpolation is the process of evaluating string let age = 7;
literals containing one or more placeholders
(expressions, variables, etc).
It can be performed using template literals: text // String concatenation
${expression} text . 'Tommy is ' + age + ' years old.';
// String interpolation
`Tommy is ${age} years old.`;
Variables
Variables are used whenever there’s a need to store a const currency = '$';
piece of data. A variable contains data that can be used
let userIncome = 85000;
in the program elsewhere. Using variables also ensures
code re-usability since it can be used to replace the
same value in multiple places. [Link](currency + userIncome + ' is
more than the average income.');
// Prints: $85000 is more than the
average income.
Undefined
undefined is a primitive JavaScript value that var a;
represents lack of defined value. Variables that are
declared but not initialized to a value will have the value
undefined . [Link](a);
// Prints: undefined
Learn Javascript: Variables
A variable is a container for data that is stored in // Examples of variables
computer memory. It is referenced by a descriptive
let name = "Tammy";
name that a programmer can call to assign a specific
value and retrieve it. const found = false;
var age = 3;
[Link](name, found, age);
// Prints: Tammy false 3
Declaring Variables
To declare a variable in JavaScript, any of these three var age;
keywords can be used along with a variable name:
let weight;
var is used in pre-ES6 versions of JavaScript.
let is the preferred way to declare a variable const numberOfFingers = 20;
when it can be reassigned.
const is the preferred way to declare a
variable with a constant value.
Template Literals
Template literals are strings that allow embedded let name = "Codecademy";
expressions, ${expression} . While regular strings use
[Link](`Hello, ${name}`);
single ' or double " quotes, template literals use
backticks instead. // Prints: Hello, Codecademy
[Link](`Billy is ${6+8} years
old.`);
// Prints: Billy is 14 years old.
let Keyword
let creates a local variable in JavaScript & can be re- let count;
assigned. Initialization during the declaration of a let
[Link](count); // Prints: undefined
variable is optional. A let variable will contain
undefined if nothing is assigned to it. count = 10;
[Link](count); // Prints: 10
const Keyword
A constant variable can be declared using the keyword const numberOfColumns = 4;
const . It must have an assignment. Any attempt of re-
numberOfColumns = 8;
assigning a const variable will result in JavaScript
runtime error. // TypeError: Assignment to constant
variable.
String Concatenation
In JavaScript, multiple strings can be concatenated let service = 'credit card';
together using the + operator. In the example,
let month = 'May 30th';
multiple strings and variables containing string values
have been concatenated. After execution of the code let displayText = 'Your ' + service + '
block, the displayText variable will contain the bill is due on ' + month + '.';
concatenated string.
[Link](displayText);
// Prints: Your credit card bill is due
on May 30th.
[Link]()
The [Link]() method is used to log or print [Link]('Hi there!');
messages to the console. It can also be used to print
// Prints: Hi there!
objects and other info.
JavaScript
JavaScript is a programming language that powers the
dynamic behavior on most websites. Alongside HTML
and CSS, it is a core technology that makes the web
run.
Methods
Methods return information about an object, and are // Returns a number between 0 and 1
called by appending an instance with a period . , the
[Link]();
method name, and parentheses.
Built-in Objects
Built-in objects contain methods that can be called by [Link]();
appending the object name with a period . , the
method name, and a set of parentheses.
// ☝️ Math is the built-in object
Numbers
Numbers are a primitive data type. They include the set let amount = 6;
of all integers and floating point numbers.
let price = 4.99;
String .length
The .length property of a string returns the number let message = 'good nite';
of characters that make up the string.
[Link]([Link]);
// Prints: 9
[Link]('howdy'.length);
// Prints: 5
Data Instances
When a new piece of data is introduced into a
JavaScript program, the program keeps track of it in an
instance of that data type. An instance is an individual
case of a data type.
Booleans
Booleans are a primitive data type. They can be either let lateToWork = true;
true or false .
[Link]()
The [Link]() method returns a floating-point, [Link]([Link]());
random number in the range from 0 (inclusive) up to
// Prints: 0 - 0.9999999999999999
but not including 1.
[Link]()
The [Link]() function returns the largest integer [Link]([Link](5.95));
less than or equal to the given number.
// Prints: 5
Single Line Comments
In JavaScript, single-line comments are created with // This line will denote a comment
two consecutive forward slashes // .
Null
Null is a primitive data type. It represents the let x = null;
intentional absence of value. In code, it is represented
as null .
Strings
Strings are a primitive data type. They are any grouping let single = 'Wheres my bandit hat?';
of characters (letters, spaces, numbers, or symbols)
let double = "Wheres my bandit hat?";
surrounded by single quotes ' or double quotes " .
Arithmetic Operators
JavaScript supports arithmetic operators for: // Addition
+ addition
5 + 5
- subtraction
* multiplication // Subtraction
/ division 10 - 5
% modulo // Multiplication
5 * 10
// Division
10 / 5
// Modulo
10 % 5
Multi-line Comments
In JavaScript, multi-line comments are created by /*
surrounding the lines with /* at the beginning and */
The below configuration must be
at the end. Comments are good ways for a variety of
reasons like explaining a code block or indicating some changed before deployment.
hints, etc. */
let baseUrl =
'localhost/taxwebapp/country';
Remainder / Modulo Operator
The remainder operator, sometimes called modulo, // calculates # of weeks in a year,
returns the number that remains after the right-hand
rounds down to nearest integer
number divides into the left-hand number as many
times as it evenly can. const weeksInYear = [Link](365/7);
// calcuates the number of days left over
after 365 is divded by 7
const daysLeftOver = 365 % 7 ;
[Link]("A year has " + weeksInYear +
" weeks and " + daysLeftOver + " days");
Print Share