JavaScript Concepts Every Frontend Developer Should Know

JavaScript is one of the most important programming languages for modern frontend development.

HTML gives a webpage its structure. CSS controls its appearance. JavaScript adds behavior, logic, interaction, and dynamic functionality.

If you want to become a frontend developer, you should understand JavaScript beyond simply knowing how to write a few functions.

This guide covers the JavaScript concepts you should learn before moving deeply into frameworks such as React, Vue, or Angular.

You will learn:

Variables and data types
Operators
Conditions
Loops
Functions
Scope
Arrays
Objects
Destructuring
Spread and rest operators
Array methods
DOM manipulation
Events
Callbacks
Higher-order functions
Closures
this
Promises
Async/await
Error handling
Modules
Modern JavaScript
Common mistakes
A practical learning roadmap

1. Why JavaScript Matters

JavaScript allows web applications to respond to user actions and work with dynamic data.

For example:

javascript

const button = document.querySelector("#loginButton");

button.addEventListener("click", () => {
  console.log("Login button clicked");
});

JavaScript can control:

Buttons
Forms
Menus
Modals
API requests
Authentication flows
Dynamic content
Animations
Browser storage
Application state
Data processing

Modern JavaScript is also used outside the browser with runtimes such as Node.js.

2. Variables

Variables store values.

JavaScript commonly uses:

javascript

let
const

Example:

javascript

let username = "Rahul";
const age = 24;

Use const when the variable should not be reassigned.

javascript

const country = "India";

Use let when the value needs to change.

javascript

let score = 0;

score = 10;

Avoid using var in modern JavaScript unless you specifically need to understand legacy code.

3. Data Types

JavaScript has several important data types.

String

javascript

const name = "Rahul";

Number

javascript

const age = 24;
const price = 999.99;

Boolean

javascript

const isLoggedIn = true;

Undefined

javascript

let result;

console.log(result);

Null

javascript

const selectedUser = null;

Object

javascript

const user = {
  name: "Rahul",
  age: 24
};

Array

javascript

const skills = [
  "HTML",
  "CSS",
  "JavaScript"
];

BigInt

javascript

const largeNumber = 9007199254740991n;

Symbol

javascript

const id = Symbol("id");

For frontend development, focus heavily on:

text

String
Number
Boolean
Null
Undefined
Object
Array

4. Primitive vs Reference Values

JavaScript values are commonly discussed as primitive values and objects.

Primitive examples:

javascript

const name = "Rahul";
const age = 24;
const active = true;

Objects include:

javascript

const user = {
  name: "Rahul"
};

Arrays are also objects:

javascript

const skills = ["HTML", "CSS", "JavaScript"];

Understanding this distinction becomes important when learning how JavaScript handles values and references.

5. Operators

JavaScript provides operators for performing calculations and comparisons.

Arithmetic

javascript

const total = 10 + 5;
const difference = 10 - 5;
const product = 10 * 5;
const division = 10 / 5;

Comparison

javascript

Equality

Prefer strict equality:

javascript

10 === 10

and:

javascript

10 !== 5

Strict equality avoids many unexpected type-conversion behaviors.

6. Logical Operators

JavaScript provides:

javascript

&&
||
!

Example:

javascript

const age = 25;
const hasExperience = true;

if (age >= 18 && hasExperience) {
  console.log("Eligible");
}

OR:

javascript

const isAdmin = false;
const isOwner = true;

if (isAdmin || isOwner) {
  console.log("Access granted");
}

NOT:

javascript

const isLoggedIn = false;

if (!isLoggedIn) {
  console.log("Please log in");
}

7. Conditional Statements

Conditional statements allow your program to make decisions.

Example:

javascript

const age = 20;

if (age >= 18) {
  console.log("Adult");
} else {
  console.log("Minor");
}

Multiple conditions:

javascript

const score = 85;

if (score >= 90) {
  console.log("Excellent");
} else if (score >= 75) {
  console.log("Good");
} else {
  console.log("Needs improvement");
}

8. Ternary Operator

For simple conditions, the ternary operator can be useful.

Instead of:

javascript

let message;

if (isLoggedIn) {
  message = "Welcome";
} else {
  message = "Please log in";
}

You can write:

javascript

const message = isLoggedIn
  ? "Welcome"
  : "Please log in";

Avoid using deeply nested ternaries because they can make code difficult to read.

9. Loops

Loops allow you to repeat operations.

For loop

javascript

for (let i = 0; i < 5; i++) {
  console.log(i);
}

While loop

javascript

let count = 0;

while (count < 5) {
  console.log(count);
  count++;
}

For arrays, modern JavaScript commonly uses methods such as:

javascript

map()
filter()
forEach()
find()
reduce()

10. Functions

Functions allow you to organize reusable logic.

Example:

javascript

function greet(name) {
  return `Hello, ${name}`;
}

console.log(greet("Rahul"));

A function can:

Receive input
Perform logic
Return a value

11. Function Parameters and Return Values

Example:

javascript

function add(a, b) {
  return a + b;
}

const result = add(10, 20);

console.log(result);

Here:

text

a and b → parameters
10 and 20 → arguments
return → returned value

Understanding this distinction is useful when reading larger applications.

12. Arrow Functions

Modern JavaScript frequently uses arrow functions.

Traditional function:

javascript

function add(a, b) {
  return a + b;
}

Arrow function:

javascript

const add = (a, b) => {
  return a + b;
};

Short version:

javascript

const add = (a, b) => a + b;

Arrow functions are especially common in frontend frameworks.

13. Scope

Scope determines where variables can be accessed.

Example:

javascript

const username = "Rahul";

function greet() {
  console.log(username);
}

greet();

The function can access the variable from its outer scope.

Block scope:

javascript

if (true) {
  const message = "Hello";

  console.log(message);
}

Outside the block:

javascript

console.log(message);

would not work because message is block-scoped.

14. Global Scope vs Local Scope

A variable declared outside functions or blocks can be accessible from broader scopes.

Example:

javascript

const appName = "Karyvio";

function showAppName() {
  console.log(appName);
}

A variable declared inside a function is local to that function:

javascript

function calculate() {
  const result = 100;

  console.log(result);
}

The result variable cannot be directly accessed outside the function.

15. Arrays

Arrays store ordered collections of values.

Example:

javascript

const skills = [
  "HTML",
  "CSS",
  "JavaScript"
];

Access an item:

javascript

console.log(skills[0]);

Output:

text

HTML

Add an item:

javascript

skills.push("React");

Remove the last item:

javascript

skills.pop();

16. map()

map() creates a new array based on another array.

Example:

javascript

const numbers = [1, 2, 3, 4];

const doubled = numbers.map(number => {
  return number * 2;
});

console.log(doubled);

Result:

javascript

[2, 4, 6, 8]

A common frontend use case is transforming API data into UI-friendly structures.

17. filter()

filter() creates a new array containing elements that satisfy a condition.

Example:

javascript

const numbers = [1, 2, 3, 4, 5];

const evenNumbers = numbers.filter(number => {
  return number % 2 === 0;
});

console.log(evenNumbers);

Result:

javascript

[2, 4]

18. find()

find() returns the first matching element.

Example:

javascript

const users = [
  { id: 1, name: "Rahul" },
  { id: 2, name: "Anita" },
  { id: 3, name: "Aman" }
];

const user = users.find(user => user.id === 2);

console.log(user);

Result:

javascript

{
  id: 2,
  name: "Anita"
}

19. reduce()

reduce() can be used to combine array values into a single result.

Example:

javascript

const numbers = [10, 20, 30];

const total = numbers.reduce(
  (sum, number) => sum + number,
  0
);

console.log(total);

Result:

text

reduce() is powerful, but beginners should first become comfortable with map(), filter(), and find().

20. Objects

Objects store related data using key-value pairs.

Example:

javascript

const developer = {
  name: "Rahul",
  role: "Frontend Developer",
  experience: 2
};

Access properties:

javascript

console.log(developer.name);

or:

javascript

console.log(developer["role"]);

Modify:

javascript

developer.experience = 3;

Add:

javascript

developer.skills = [
  "JavaScript",
  "React"
];

21. Nested Objects

Real-world API responses frequently contain nested objects.

Example:

javascript

const user = {
  name: "Rahul",
  profile: {
    city: "Bangalore",
    country: "India"
  }
};

Access:

javascript

console.log(user.profile.city);

Optional chaining can make nested access safer:

javascript

console.log(user.profile?.city);

22. Destructuring

Destructuring allows you to extract values from arrays and objects.

Object example:

javascript

const user = {
  name: "Rahul",
  role: "Developer"
};

const { name, role } = user;

console.log(name);
console.log(role);

Array example:

javascript

const skills = [
  "JavaScript",
  "React"
];

const [firstSkill, secondSkill] = skills;

Destructuring is extremely common in modern frontend code.

23. Spread Operator

The spread operator is:

javascript

...

It can copy or combine arrays and objects.

Example:

javascript

const frontend = ["HTML", "CSS"];
const programming = ["JavaScript"];

const skills = [
  ...frontend,
  ...programming
];

Result:

javascript

[
  "HTML",
  "CSS",
  "JavaScript"
]

Object example:

javascript

const user = {
  name: "Rahul",
  role: "Developer"
};

const updatedUser = {
  ...user,
  role: "Senior Developer"
};

This pattern is common when working with immutable state.

24. Rest Parameters

The same ... syntax can also collect multiple function arguments.

Example:

javascript

function sum(...numbers) {
  return numbers.reduce(
    (total, number) => total + number,
    0
  );
}

console.log(sum(10, 20, 30));

Result:

text

Remember:

text

Spread → expands values
Rest → collects values

25. Template Literals

Template literals use backticks.

Example:

javascript

const name = "Rahul";
const role = "Frontend Developer";

const message = `I am ${name}, a ${role}.`;

console.log(message);

This is usually cleaner than manually concatenating strings.

26. Optional Chaining

Optional chaining uses:

javascript

?.

Example:

javascript

const user = {
  profile: {
    name: "Rahul"
  }
};

console.log(user.profile?.name);

If profile does not exist, optional chaining can prevent an immediate property-access error.

It is especially useful when working with API responses where some nested data may be missing.

27. Nullish Coalescing

The nullish coalescing operator is:

javascript

??

Example:

javascript

const username = null;

const displayName = username ?? "Guest";

console.log(displayName);

Result:

text

Guest

It uses the fallback when the left side is null or undefined.

28. DOM

DOM stands for:

Document Object Model

The browser represents the webpage as a document structure that JavaScript can interact with.

Example HTML:

html

<button id="saveButton">
  Save
</button>

JavaScript:

javascript

const button = document.querySelector("#saveButton");

console.log(button);

JavaScript can then modify the page.

29. Selecting Elements

Common methods include:

javascript

document.querySelector()
document.querySelectorAll()
document.getElementById()

Example:

javascript

const heading = document.querySelector("h1");

Multiple elements:

javascript

const buttons = document.querySelectorAll("button");

30. Changing Content

Example:

javascript

const heading = document.querySelector("h1");

heading.textContent = "Welcome to Karyvio";

You can also modify classes:

javascript

heading.classList.add("active");

Remove:

javascript

heading.classList.remove("active");

Toggle:

javascript

heading.classList.toggle("active");

31. Events

Events allow JavaScript to respond to user actions.

Examples include:

click
submit
input
change
mouseover
keydown
load

Example:

javascript

const button = document.querySelector("#saveButton");

button.addEventListener("click", () => {
  console.log("Saved");
});

32. Event Object

Event handlers can receive an event object.

Example:

javascript

button.addEventListener("click", event => {
  console.log(event);
});

For forms:

javascript

form.addEventListener("submit", event => {
  event.preventDefault();

  console.log("Form submitted");
});

preventDefault() can stop the browser's default form submission behavior.

33. Callbacks

A callback is a function passed to another function.

Example:

javascript

function processUser(name, callback) {
  console.log(`Processing ${name}`);

  callback();
}

processUser("Rahul", () => {
  console.log("Finished");
});

Callbacks are fundamental to understanding asynchronous JavaScript.

34. Higher-Order Functions

A higher-order function either:

Receives a function as an argument
Returns a function

For example:

javascript

const numbers = [1, 2, 3];

const doubled = numbers.map(number => number * 2);

Here:

javascript

map()

receives a function.

This is a higher-order function pattern.

35. Closures

Closures are one of the most important JavaScript concepts.

A closure occurs when a function retains access to variables from its surrounding lexical scope.

Example:

javascript

function createCounter() {
  let count = 0;

  return function () {
    count++;

    return count;
  };
}

const counter = createCounter();

console.log(counter());
console.log(counter());
console.log(counter());

Output:

text

1
2
3

The returned function continues to access count.

A simplified mental model:

Diagram / Architecture

Closures are useful in many JavaScript patterns and are commonly discussed in interviews.

36. The `this` Keyword

this is another important JavaScript concept.

Its value depends on how a function is called.

Example:

javascript

const user = {
  name: "Rahul",

  greet() {
    console.log(this.name);
  }
};

user.greet();

Here, this refers to the object used to call the method.

Arrow functions behave differently because they do not create their own this binding.

Example:

javascript

const user = {
  name: "Rahul",

  greet: () => {
    console.log(this.name);
  }
};

This is one reason you should understand the difference between regular functions and arrow functions.

37. Promises

JavaScript frequently performs asynchronous operations.

Examples:

API requests
Timers
File operations
Browser APIs

A Promise represents the eventual result of an asynchronous operation.

Basic example:

javascript

const promise = new Promise((resolve, reject) => {
  const success = true;

  if (success) {
    resolve("Operation successful");
  } else {
    reject("Operation failed");
  }
});

A Promise can be:

text

Pending
Fulfilled
Rejected

38. Using `.then()` and `.catch()`

Example:

javascript

promise
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.error(error);
  });

The basic flow is:

text

Promise
   ↓
Pending
   ↓
Success → then()
   or
Failure → catch()

39. Async/Await

Async/await provides a cleaner syntax for working with Promises.

Example:

javascript

async function loadUser() {
  const response = await fetch("/api/user");

  const user = await response.json();

  console.log(user);
}

The async keyword marks an asynchronous function.

The await keyword waits for a Promise to settle before continuing within that async function.

40. Handling API Errors

A production application should not assume every request succeeds.

Example:

javascript

async function loadJobs() {
  try {
    const response = await fetch("/api/jobs");

    if (!response.ok) {
      throw new Error(`Request failed: ${response.status}`);
    }

    const data = await response.json();

    return data;
  } catch (error) {
    console.error("Unable to load jobs:", error);
  }
}

This pattern is extremely useful for frontend applications.

41. Promise Flow

A typical API request looks like:

Diagram / Architecture

The frontend must handle:

text

Loading
Success
Error

42. Modules

Modern JavaScript supports modules.

Export:

javascript

export function add(a, b) {
  return a + b;
}

Import:

javascript

import { add } from "./math.js";

console.log(add(10, 20));

Modules make large applications easier to organize.

A project might have:

text

src/
├── components/
├── services/
├── utils/
├── hooks/
└── pages/

The exact structure depends on the framework and project.

43. Default Exports

You can also use a default export.

javascript

export default function greet(name) {
  return `Hello ${name}`;
}

Import:

javascript

import greet from "./greet.js";

Named and default exports are both common in modern JavaScript projects.

44. JavaScript and APIs

Frontend applications frequently consume REST APIs.

Example:

javascript

async function getPosts() {
  const response = await fetch("/api/posts");

  if (!response.ok) {
    throw new Error("Failed to fetch posts");
  }

  const result = await response.json();

  return result.data;
}

The flow is:

text

Frontend
   ↓
fetch()
   ↓
API
   ↓
JSON
   ↓
JavaScript object
   ↓
UI

This is one of the most important practical uses of JavaScript in frontend development.

45. Array Methods You Should Know

A frontend developer should become comfortable with:

javascript

map()
filter()
find()
findIndex()
some()
every()
includes()
forEach()
reduce()
sort()

For example:

javascript

const jobs = [
  { title: "Frontend Developer", remote: true },
  { title: "Backend Developer", remote: false },
  { title: "React Developer", remote: true }
];

const remoteJobs = jobs.filter(job => job.remote);

console.log(remoteJobs);

46. Immutability

Modern frontend development frequently emphasizes avoiding unnecessary direct mutation of state.

Instead of:

javascript

user.name = "Aman";

you may create a new object:

javascript

const updatedUser = {
  ...user,
  name: "Aman"
};

For arrays:

javascript

const updatedSkills = [
  ...skills,
  "TypeScript"
];

This pattern is especially important when working with UI state libraries and frameworks.

47. Shallow Copy vs Deep Copy

The spread operator creates a shallow copy.

Example:

javascript

const user = {
  name: "Rahul",
  profile: {
    city: "Bangalore"
  }
};

const copy = {
  ...user
};

The top-level object is copied, but nested objects can still share references.

This becomes important when working with deeply nested data.

Do not assume:

javascript

{ ...object }

creates a complete deep clone.

48. Error Handling

JavaScript provides:

javascript

try
catch
finally

Example:

javascript

try {
  const result = JSON.parse("invalid json");

  console.log(result);
} catch (error) {
  console.error("Parsing failed");
} finally {
  console.log("Finished");
}

Error handling is essential when working with:

APIs
User input
JSON
Async operations
External services

49. JSON.parse() and JSON.stringify()

APIs frequently exchange JSON.

Convert JSON text to a JavaScript value:

javascript

const json = '{"name":"Rahul"}';

const user = JSON.parse(json);

console.log(user.name);

Convert a JavaScript object into JSON text:

javascript

const user = {
  name: "Rahul"
};

const json = JSON.stringify(user);

console.log(json);

Remember:

text

JSON.parse()
JSON → JavaScript value

JSON.stringify()
JavaScript value → JSON

50. Local Storage

Browsers provide storage mechanisms such as localStorage.

Example:

javascript

localStorage.setItem(
  "theme",
  "dark"
);

Read:

javascript

const theme = localStorage.getItem("theme");

Remove:

javascript

localStorage.removeItem("theme");

Be careful about storing sensitive information in browser storage.

Never treat client-side storage as a secure place for secrets.

51. Debouncing

Debouncing is useful when an event may fire many times in a short period.

A common example is a search input.

Instead of sending an API request for every keystroke:

text

J
Ja
Jav
Java
Javas
JavaScript

you can wait until the user pauses typing.

Conceptually:

Diagram / Architecture

Debouncing can reduce unnecessary work and API requests.

52. Event Loop Basics

JavaScript in browsers uses an event-driven execution model.

A simplified mental model:

text

Call Stack
    ↓
Web APIs
    ↓
Task / Microtask Queues
    ↓
Event Loop
    ↓
Call Stack

For example:

javascript

console.log("A");

setTimeout(() => {
  console.log("B");
}, 0);

console.log("C");

The output is:

text

A
C
B

Even though the timer is set to 0, its callback does not immediately interrupt the currently executing code.

You do not need to master the entire event loop on day one, but understanding the basic model is valuable.

53. Common JavaScript Mistakes

Mistake 1: Using `==` without understanding coercion

Prefer:

javascript

value === expected

when strict equality is appropriate.

Mistake 2: Mutating data unnecessarily

Be careful with:

javascript

array.push(...)

or direct object mutation when working with state-driven UI systems.

Mistake 3: Ignoring asynchronous errors

Do not write API code that assumes every request succeeds.

Always consider:

text

Network failure
4xx response
5xx response
Invalid JSON
Unexpected data

Mistake 4: Writing huge functions

Avoid functions that handle everything:

text

Fetch API
Validate data
Transform data
Update UI
Show notifications
Handle errors

Break responsibilities into smaller functions.

Mistake 5: Overusing global variables

Keep variables close to where they are needed.

Mistake 6: Ignoring browser DevTools

When something goes wrong, inspect:

text

Console
Network
Elements
Sources
Application

DevTools is one of the most useful tools for frontend developers.

54. JavaScript Debugging

Use:

javascript

console.log()

when appropriate.

For example:

javascript

console.log("API response:", data);

You can also use:

javascript

console.error()
console.warn()
console.table()

And browser breakpoints:

text

Developer Tools
→ Sources
→ Add breakpoint

Debugging is a skill you develop through practice.

55. What JavaScript Skills Should a Frontend Developer Have?

A job-ready frontend developer should understand:

Fundamentals

Variables
Data types
Operators
Conditions
Loops

Functions

Regular functions
Arrow functions
Parameters
Return values
Scope
Closures

Data

Arrays
Objects
Destructuring
Spread/rest
Array methods

Browser

DOM
Events
Forms
Browser storage
DevTools

Asynchronous JavaScript

Callbacks
Promises
async/await
Fetch API
Error handling

Modern JavaScript

Modules
Optional chaining
Nullish coalescing
Template literals
Modern array/object patterns

56. JavaScript Learning Roadmap

A practical learning order is:

Diagram / Architecture

Do not rush directly into a framework without understanding the JavaScript underneath it.

57. Projects to Practice

Beginner Projects

Build:

Calculator
Counter
Digital clock
To-do list
Random quote generator

Intermediate Projects

Build:

Weather application
Movie search application
Expense tracker
Job search interface
Blog frontend

Advanced Projects

Build:

Authentication dashboard
Job board
E-commerce frontend
Admin dashboard
Full-stack blog platform

Each project should gradually introduce more complex concepts.

58. A Good JavaScript Practice Routine

Instead of only watching tutorials, divide your learning time between:

text

Learn
  ↓
Code
  ↓
Break
  ↓
Debug
  ↓
Improve
  ↓
Build

For example:

Week 1

Learn:

Variables
Data types
Operators
Conditions

Build:

text

Simple calculator

Week 2

Learn:

Functions
Arrays
Objects
Loops

Build:

text

Todo application

Week 3

Learn:

DOM
Events
Forms

Build:

text

Interactive form

Week 4

Learn:

Promises
async/await
Fetch
REST APIs

Build:

text

Job search application

59. JavaScript Interview Topics

Before a frontend interview, make sure you can explain:

let vs const vs var
Primitive vs object values
== vs ===
Scope
Closures
Hoisting
Functions
Arrow functions
this
Arrays
Objects
map()
filter()
reduce()
Promises
async/await
Event loop
DOM
Event handling
Event delegation
Modules
Fetch API
Error handling

You do not need to memorize textbook definitions.

Focus on understanding how the concepts behave in real code.

60. Final JavaScript Checklist

Before moving deeply into a frontend framework, you should be comfortable with:

61. Final Thoughts

JavaScript can feel difficult because it contains many concepts that interact with each other.

Do not try to memorize everything at once.

Build your understanding in layers:

text

JavaScript Basics
       ↓
Functions
       ↓
Arrays + Objects
       ↓
Modern JavaScript
       ↓
DOM + Events
       ↓
Async JavaScript
       ↓
APIs
       ↓
Projects
       ↓
Frontend Framework

The goal is not to know every JavaScript feature.

The goal is to understand the concepts well enough to build, debug, and improve real applications.

If you can take an API response, process the data, handle loading and errors, respond to user actions, update the interface, and organize your code into reusable modules, you are developing the practical JavaScript skills needed for modern frontend development.

Learn the fundamentals. Build real projects. Debug your own code. Then move to frameworks.

JavaScript Concepts Every Frontend Developer Should Know

JavaScript Concepts Every Frontend Developer Should Know

1. Why JavaScript Matters

2. Variables

3. Data Types

String

Number

Boolean

Undefined

Null

Object

Array

BigInt

Symbol

4. Primitive vs Reference Values

5. Operators

Arithmetic

Comparison

Equality

6. Logical Operators

7. Conditional Statements

8. Ternary Operator

9. Loops

For loop

While loop

10. Functions

11. Function Parameters and Return Values

12. Arrow Functions

13. Scope

14. Global Scope vs Local Scope

15. Arrays

16. map()

17. filter()

18. find()

19. reduce()

20. Objects

21. Nested Objects

22. Destructuring

23. Spread Operator

24. Rest Parameters

25. Template Literals

26. Optional Chaining

27. Nullish Coalescing

28. DOM

29. Selecting Elements

30. Changing Content

31. Events

32. Event Object

33. Callbacks

34. Higher-Order Functions

35. Closures

36. The this Keyword

37. Promises

38. Using .then() and .catch()

39. Async/Await

40. Handling API Errors

41. Promise Flow

42. Modules

43. Default Exports

44. JavaScript and APIs

45. Array Methods You Should Know

46. Immutability

47. Shallow Copy vs Deep Copy

48. Error Handling

49. JSON.parse() and JSON.stringify()

50. Local Storage

51. Debouncing

52. Event Loop Basics

53. Common JavaScript Mistakes

Mistake 1: Using == without understanding coercion

Mistake 2: Mutating data unnecessarily

Mistake 3: Ignoring asynchronous errors

Mistake 4: Writing huge functions

Mistake 5: Overusing global variables

Mistake 6: Ignoring browser DevTools

54. JavaScript Debugging

55. What JavaScript Skills Should a Frontend Developer Have?

Fundamentals

Functions

Data

36. The `this` Keyword

38. Using `.then()` and `.catch()`

Mistake 1: Using `==` without understanding coercion