Learning JavaScript
(JAVASCRIPT.AE1)/ISBN:978-1-64459-473-5
Prepare for a dynamic career in web development with our JavaScript course. Learn the JavaScript language and understand its real-world applications, gaining the skills needed to thrive in a rapidly evolving environment. Discover how JavaScript interacts with web browsers, mobile devices, servers, and more. Explore popular libraries and frameworks, adapt to new technologies, and become a versatile JavaScript programmer. Interactive lessons and hands-on labs provide the keys to your success in this course.
Lessons
43+ Lessons | 89+ Exercises | 257+ Quizzes | 265+ Flashcards | 265+ Glossary of terms
Hands-On Labs
76+ LiveLab | 76+ Video tutorials | 02:44+ Hours
Need guidance and support? Click here to check our Instructor Led Course.
Here's what you will learn
Download Course OutlineLessons 1: Introduction
- Why This Course?
- Conventions Used in This Course
- Foolish Assumptions
- Icons Used in This course
- Beyond the Course
- Where to Go from Here
Lessons 2: Jumping into JavaScript
- JavaScript, the Basics
- Reading and Copying JavaScript Code
- Starting Your Development Environment
- Writing Your First JavaScript Program
- Running Code in the Console
- Rerunning Commands in the Console
- Running Code in a Browser Window
Lessons 3: Filling Your JavaScript Toolbox
- Installing Node.js
- Configuring Visual Studio Code
- Documenting Your Code
- Coding Responsibly with Git
Lessons 4: Using Data
- Making Variables with let
- Making Constants with const
- Taking a Look at the Data Types
- Wrangling the Object: The Complex Data Type
- Examining the Array — a Special Kind of Object
- Getting a Handle on Scope
Lessons 5: Working with Operators and Expressions
- Building Expressions
- Operators: The Lineup
- Other Operators
Lessons 6: Controlling Flow
- Choosing a Path
- Making Loops
Lessons 7: Using Arrays
- Introducing Arrays
- Creating Arrays
- Accessing Array Elements
- Modifying Arrays
- Deleting Array Elements
- Programming with Array Methods
- Looping with Array Methods
- Destructuring Arrays
- Spreading Arrays
Lessons 8: Making and Using Objects
- Objects: The Basics
- Creating Objects
- Modifying Objects
- Comparing and Copying Objects
- Understanding Prototypes
- Deleting Object Properties
Lessons 9: Writing and Running Functions
- Functions: An Introduction
- Writing Functions
- Writing Methods
- Understanding Context and this
- Chaining Functions
Lessons 10: Getting Oriented with Classes
- Encapsulation
- Abstraction
- Inheritance
- Polymorphism
- Base Classes
- Derived Classes
- Constructors
- Properties and Methods
- Practicing and Becoming comfortable with Classes
Lessons 11: Making Things Happen with Events
- Understanding the JavaScript Runtime Model
- The Event Loop
- Listening for Events
Lessons 12: Writing Asynchronous JavaScript
- Understanding Asynchronous JavaScript
- Making Promises
- Using AJAX
Lessons 13: Using JavaScript Modules
- Defining Modules
- Exporting Modules
- Importing Modules
- Renaming Exports and Imports
- Importing a Module Object
- Loading Dynamic Modules
- Importing Modules into HTML
Lessons 14: What a Web Browser Does
- Interfacing with a Browser
- Introducing the Browser Engine
- The Rendering Engine
- Networking
Lessons 15: Programming the Browser
- Understanding Web APIs and Interfaces
- Getting Around the Navigator
- Stealing a Glimpse Through the Window
- Introducing the HTML DOM
- Knowing Your History
Lessons 16: Getting Started with React
- Understanding ReactJS
- Initializing a Project with Vite
- Introducing ReactDOM and the Virtual DOM
Lessons 17: Writing JSX
- Learning the Fundamentals of JSX
- Using JavaScript Expressions in JSX
- Conditionally Rendering JSX
- Making a List
- Styling React Apps and Components
Lessons 18: Building React Components
- Thinking in Components
- Recognizing the Two Types of Data
- Function Components
- Class Components
- The Component Lifecycle
- Using the Lifecycle in Function Components
- Composing Components
Lessons 19: Using Data and Events in React
- Event Handling in React
- Making Forms with React
Lessons 20: Getting an Overview of Vue
- Comparing Vue to React
- Scaffolding Your First Vue.js Application
- Mounting a Root Component
- Exploring Vue's Two Styles
- Installing Vue DevTools
Lessons 21: Introducing Vue Components
- Introducing the Single-File Component
- Naming Components
- Following the Component Lifecycle
- Handling Errors in Components
Lessons 22: Making Vue Templates
- Writing HTML Templates
- Using JavaScript in Templates
- Introducing Directives
- Conditional Rendering
- Rendering Lists
- Composing with Slots
- Adding Style to Components
Lessons 23: Using Data and Reactivity
- Passing and Using Props
- Binding Data to Templates
- Initializing and Changing Reactive Data
- Introducing ref()
- Computing Properties
- Reacting to State Changes with Watch()
Lessons 24: Responding to Events
- Setting Listeners with v-on
- Using Event Modifiers
- Binding Forms to Events and Data
Lessons 25: Getting Started with Svelte
- What Makes Svelte Different?
- Building Your Scaffolding
- Getting the Svelte for VS Code Extension
- Exploring a Svelte App
- Playing with Svelte
Lessons 26: Building with Components
- Writing Lean Components
- Identifying What's in a Component
- Adding Style to a Component
Lessons 27: Designing Templates
- Elements Are the Building Blocks
- Documenting Svelte with Comments
- Choosing a Path
- Creating Loops
- Writing Text Expressions
- Composing with Slots
Lessons 28: Using Directives
- Listening for Events with on:
- Creating Two-Way Bindings with :bind
- Using Transition Animations
Lessons 29: Using the Component Lifecycle
- The Svelte Lifecycle
- Fetching Data in Svelte
Lessons 30: Advanced Svelte Reactivity
- Constructing and Stocking the Store
- Getting and Setting Context
Lessons 31: Building from Scratch
- Why You Need a Build Tool
- Managing Dependencies with npm
- Writing Your First Files
- Writing a dev Script
- Making Modules
Lessons 32: Optimizing and Bundling
- Automating Your Build Script
- Converting to React
Lessons 33: Testing Your JavaScript
- Using a Linter
- Debugging in Chrome
- Unit Testing
Lessons 34: Node.js Fundamentals
- Learning What Makes Node.js Tick
- Learning the Parts of Node.js
- Introducing the Node.js Core Modules
- Recognizing What Node.js Is Good For
- Working with Node.js
- Using REPL
- Making and Using Node.js Modules
- Getting Data to Node Modules
- Node's Callback Pattern
Lessons 35: Streaming
- Jumping into Streams
- Creating Readable Streams
- Creating Writable Streams
- Producing Duplex Streams
- Transforming Streams
- Chaining Streams
Lessons 36: Working with Buffers
- Knowing Your Buffer Basics
- Decoding Buffers
- Creating Buffers
- Using Other Buffer Methods
- Iterating over Buffers
Lessons 37: Accessing the File System
- Importing the fs module
- Reading Files
- Writing Files
- Using Paths
- Getting File and Directory Information
Lessons 38: Networking with Node
- A Note about Security
- Making a Web Server
Lessons 39: Using Events
- Introducing EventEmitter
- Understanding and Using maxListeners
- Removing Listeners
- Emitting Once
Lessons 40: Error Handling and Debugging
- Knowing the Types of Errors
- Understanding Node.js's Error Object
- Exceptions versus Errors
- Handling Exceptions
- Debugging Node.js Programs
Lessons 41: Accessing Databases
- Getting Started with MongoDB
- Starting MongoDB
- Using Mongosh
- Using MongoDB from Node.js
Lessons 42: Riding on the Express Train
- Installing Express
- Server-Side Routing with Express
- Using Express Middleware
- Analyzing a Complete Express Server
- Serving a View
- Using the Express Application Generator
Lessons 43: Registration and Authentication
- Making and Configuring the Directory
- Adding the App and Server Modules
- Making Some Basic Routes
- Testing Your Routes
- Making a Schema with Mongoose
- Implementing User Registration
- Handling Authentication
- Generating and Using Tokens
- Finishing the Login Route
Hands-on LAB Activities
Jumping into JavaScript
- Creating an HTML Page Using JavaScript
Using Data
- Using Primitive Data Types
- Using Special Characters
Working with Operators and Expressions
- Using Comparison Operators
- Using Arithmetic Operators
- Using Logical Operators
Controlling Flow
- Using Conditional Statements
- Using the Ternary Operator
- Using the switch Statement
- Using the break Statement
- Using Loops
- Using the continue Statement
Using Arrays
- Generating an HTML List from an Array
- Creating a Shallow Copy of an Array
Making and Using Objects
- Printing the Properties of an Object
Writing and Running Functions
- Using Pass By Reference
- Creating a Movie Picker App
- Creating a Bookstore App
Getting Oriented with Classes
- Overriding a Method
- Accessing the static Member of a Class
Making Things Happen with Events
- Setting an Event Listener
- Using Event Bubbling
- Firing a Built-in Event
Writing Asynchronous JavaScript
- Creating an Asynchronous User Interface
- Creating a Synchronous User Interface
- Creating an Asynchronous Function
- Creating a Promise Chain
- Creating a Promise
Programming the Browser
- Using the Navigator userAgent Property
- Using the getElementById() Method
- Using the querySelectorAll() Method
- Creating and Appending Element Nodes
Writing JSX
- Creating a React Component
- Performing Conditional Rendering Using the Logical && Operator
- Performing Conditional Rendering Using the Conditional Operator
- Performing Conditional Rendering Using the Element Variable
Building React Components
- Using State
- Using props in a Class Component
- Using Props in a Function Component
- Creating a Class Component
Using Data and Events in React
- Handling an Event in React
- Creating a Form in React
Getting an Overview of Vue
- Creating a Vue Component Using the Composition API
- Creating a Vue Component Using the Options API
Introducing Vue Components
- Using the setup Attribute
Making Vue Templates
- Creating a Custom Directive
Using Data and Reactivity
- Using Props in Vue
Responding to Events
- Handling Events in Vue
Getting Started with Svelte
- Creating a Svelte Component
Building with Components
- Creating a Svelte Counter Component
- Creating a Prop in Svelte
- Using Reactive Statements in Svelte
Designing Templates
- Performing Conditional Rendering in Svelte
- Creating a Loop in Svelte
Using Directives
- Creating Transition in Svelte
Using the Component Lifecycle
- Using the tick() Method
Advanced Svelte Reactivity
- Creating a Store in Svelte
Building from Scratch
Optimizing and Bundling
Testing Your JavaScript
Node.js Fundamentals
- Using the os Module
- Creating a Web Server in Node.js
- Creating ES Modules
- Creating CommonJS Modules
Streaming
- Working with a Stream in the Paused Mode
- Working with a Stream in the Flowing Mode
- Creating a Streaming Counter
Working with Buffers
- Creating a Buffer
- Iterating over a Buffer
Accessing the File System
- Reading Data from a File
- Writing Data to a File
Networking with Node
- Creating a Web Server that Returns Information about Each Server Request
Using Events
- Creating an Instance of EventEmitter
- Finding the Default Number of Listeners for an Emitter
Error Handling and Debugging
- Creating an Error Object and Displaying its Properties
- Handling an Exception
Accessing Databases
- Creating a Collection in MongoDB
Riding on the Express Train
- Creating an Express Application
- Handling Route Parameters in Express