Table of Contents
Advanced Vue.js Features from the Ground Up
Reactivity
Introducing Reactivity
After clarifying the term reactivity in the context of working in Vue.js as changing the state and how the state reflects the update the DOM system, Evan walks through a simple example of how Vue.js's rendering system works.
Challenge 1: Getters and Setters
Evan reviews Object.defineProperty() and its get and set functions. In this challenge, students implement observe() and autorun(), which triggers re-computation when object is mutated.
Challenge 1: Solution
Evan provides a starting point to the Challenge 1 by showing dependency tracking, when an inner update function executes, the dependency class has access to the currently active update.
Challenge 2: Dependency Tracker
Evan walks through the solution to Challenge 1.
Challenge 3: Mini Observer
In this challenge, students combine the previous two solutions to create a mini observer.
Writing Plugins
Introducing Writing Plugins
After reviewing a high-level understanding, Evan examines the makeup of a Vue plugin.
Challenge 4: Writing a Simple Plugin
In this challenge, students write a plugin that teaches Vue components to handle a custom "rules" option.
Challenge 4: Solution
Evan walks through the solution to Challenge 4.
Render Functions
Introducing Render Functions
Evan illustrates how Render Functions help in the process of managing state by tracking changes from DOM and virtual DOM.
Virtual DOM
Evan reviews virtual DOM, which is a lightweight representation of what actual DOM should like at a given point in time. Virtual decouples rendering logic from actual DOM allowing rendering capabilities in non-browser environments such as server-side and native mobile rendering.
Putting Everything Together
Evan illustrates how to render function and reactivity work together.
JSX vs. Templates
While templates are the default API, Evan explains why Vue.js supports both templates and JSX in reviewing their respective benefits.
Render Function API
Evan reviews the Render Function API by examining a component with an "h" function. The "h" function is a convention based on hyperscript, a method for writing HTML through JavaScript. Evan takes questions from students.
Challenge 5: Dynamically Render Tags
In this challenge, students implement an example component to render HTML output.
Challenge 5: Solution
Evan walks through the solution to Challenge 5.
Challenge 6: Dynamically Render Components
In this challenge, students iterate through implementations of rendering a component.
Challenge 6: Solution
After discussing functional components prompted by a student question, Evan walks through the solution to Challenge 6.
Challenge 7: Higher-Order Components
In this challenge, students create a helper that takes an inner component that expects prop and returns a higher-order component.
Q&A: Higher-Order Components
Evan takes questions from students about mixins and higher order component.
Challenge 7: Solution
Evan walks to the solution to Challenge 7 and takes questions from students. Then Evan adds a class to util.js that will be needed later.
State Management
Introducing State Management
Evan reviews the problems and evolution of state management as applications grow in more complexity.
Challenge 8: Passing Props
In this challenge, students pass props to control states in small component structures.
Challenge 8: Solution
Evan walks through the solution to Challenge 8.
Challenge 9: Shared Object
In this challenge, students create a counter component where all its instances share the same count state.
Challenge 9: Solution
Evan walks through the solution to Challenge 9.
Challenge 10: Shared Instance
In this challenge, students employ a Vue instance as a shared store.
Challenge 10: Solution
Evan walks through the solution to Challenge 10.
Challenge 11: Mutations
In this challenge, students use a Vue instance to fit the API requirements.
Challenge 11: Solution
Evan walks through the solution to Challenge 11.
Challenge 12: Functional
In this challenge, students manage state with functional JavaScript.
Q&A: Type-based API and Nested Objects
Evan takes questions from students about type-based API and nested objects.
Challenge 12: Solution
Evan walks through the solution to Challenge 12.
Routing
Challenge 13: Basic Hash Router
In this challenge, students build a simple hash routing system.
Challenge 13: Solution
Evan walks through the solution to Challenge 13.
Challenge 14: Route Table
In this challenge, students implement a route table.
Challenge 14: Solution
Evan walks through the solution to Challenge 14.
Path to Regular Expressions
Evan illustrates the need to convert a path string such as `/user/:username` using regular expressions for web applications to use.
Challenge 15: Dynamic Routes
In this challenge, students create a dynamic routing system with regular expressions.
Challenge 15: Solution
Evan walks through the solution to Challenge 15.
Form Validation
Markup-based vs. Model-based
Evan reviews form validation in markup-based and model-based different styles.
Validation Library
Evan creates a simple model-based form validation library.
Internationalization
Internationalization Approaches
Evan introduces three approaches to add internationalization to Vue applications.
Internationalization Plugin
Evan demonstrates how to set up an internalization plugin.
Wrapping Up Advanced Vue.js
Q&A: Onboarding Speed and Web Components
Evan takes questions from students about onboarding speed and how important it is when selecting a framework, leveraging features in web components, and when to use Vuex.
Q&A: SSR and Vue Custom Element
Evan reviews the benefits of Server Side Rendering (SSR), Vue Custom Element, and future of Vue.js.
Wrapping Up
Wrapping up the "Advanced Vue.js Features from the Ground Up" course, Evan talks about financial sponsorship of Vue.js help move the open source project forward.