Intermediate JavaScript Nanodegree

助教微信

udacity公众号

Nanodegree key: nd032
Version: 5.0.0
Locale: en-us
The goal of the this program is to prepare students for roles in web development, server-side application development, and desktop development that require advanced JavaScript skills.

Content

Part 01 : Welcome to the Intermediate JavaScript Nanodegree Program

• Module 01: Welcome to the Intermediate JavaScript Nanodegree Program

  • Lesson 01: Welcome to Udacity
    • Concept 01: Welcome to Udacity
    • Concept 02: The Udacity Experience
    • Concept 03: How to Succeed
  • Lesson 02: Knowledge, Community, and CareersYou are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
    • Concept 01: What It Takes
    • Concept 02: Getting Help
    • Concept 03: Knowledge
    • Concept 04: Student Hub
    • Concept 05: Community Initiatives
    • Concept 06: Career Services

      Part 02 : Object Oriented JavaScript

• Module 01: Object Oriented JavaScript

  • Lesson 01: Objects in DepthObjects in JavaScript encapsulate both data and functionality. You’ll create, access, and modify objects to build a solid foundation for object-oriented programming.
    • Concept 01: Introduction
    • Concept 02: Create and Modify Properties
    • Concept 03: Invoking Object Methods
    • Concept 04: Beware of Globals
    • Concept 05: Extracting Properties and Values
    • Concept 06: Lesson Summary
  • Lesson 02: Functions at RuntimeFunctions are one of most important data structures. Learn what a “first-class function” is, learn about scope, dig into closures, and use immediately-invoked function expressions for private state.
    • Concept 01: Introduction
    • Concept 02: First-Class Functions
    • Concept 03: Callbacks
    • Concept 04: Scope
    • Concept 05: Closures
    • Concept 06: Immediately-Invoked Function Expressions (IIFE)
    • Concept 07: Lesson Summary
  • Lesson 03: Classes and ObjectsCreating objects individually isn’t sustainable. Learn how to create similar objects with ease using Classes. You’ll also learn how object inheritance works through Prototypal Inheritance.
    • Concept 01: Introduction
    • Concept 02: Constructor Functions
    • Concept 03: The this Keyword
    • Concept 04: Setting Our Own this
    • Concept 05: Prototypal Inheritance
    • Concept 06: Prototypal Inheritance: Subclasses
    • Concept 07: Lesson Summary
    • Concept 08: Course Outro
  • Lesson 04: Object-Oriented Design PatternsDiscover object-oriented design patterns that can be used to create an object — all without involving its prototype. What’s more: you’ll also learn how to implement private properties in objects.
    • Concept 01: Introduction
    • Concept 02: Mixins / Extending Object Functionality with Mixins
    • Concept 03: Functional Mixins
    • Concept 04: The Module Pattern
    • Concept 05: The Revealing Module Pattern
    • Concept 06: Lesson Summary
    • Concept 07: Course Outro
  • Lesson 05: Project: DinosaursProject Description - DinosaursProject Rubric - Dinosaurs
    • Concept 01: Project Summary
    • Concept 02: Project Rubric
    • Concept 03: Get the Starter Code
    • Concept 04: Object-Oriented Javascript
    • Concept 05: Development Strategy
    • Concept 06: Version Control
    • Concept 07: Udacity Style Guides
    • Concept 08: Still Not Sure How to Begin?

      Part 03 : Functional Programming

• Module 01: Functional Programming

  • Lesson 01: Course Introduction - Functional ProgrammingIntroduction to the course on Functional Programming with JavaScript
    • Concept 01: Introduction
    • Concept 02: FP Basics
    • Concept 03: FP History
    • Concept 04: Course Overview & Tools
    • Concept 05: Baseline Questions
    • Concept 06: Intro Recap
  • Lesson 02: Introduction to Functional ProgrammingFoundational Introduction to Functional Programming in JavaScript
    • Concept 01: Programming Paradigms
    • Concept 02: Why Learn Paradigms?
    • Concept 03: Comparing Paradigms
    • Concept 04: Exercise: Compare Paradigms
    • Concept 05: Paradigms Review
    • Concept 06: Foundations of FP
    • Concept 07: Exercise: Foundation Concepts
    • Concept 08: FP & Pure Functions Review
    • Concept 09: Why FP?
    • Concept 10: Exercise: Basic FP
    • Concept 11: Basic FP Review
    • Concept 12: Lesson Recap
  • Lesson 03: Functional JS SyntaxExperience writing functional programming with JavaScript & ES6 syntax
    • Concept 01: Functional JS Syntax Intro
    • Concept 02: Array Methods
    • Concept 03: The Map Method
    • Concept 04: Exercise: Map Method
    • Concept 05: Advanced Map Method
    • Concept 06: Exercise: Advanced Map Method
    • Concept 07: Map Method Review
    • Concept 08: The Filter Method
    • Concept 09: Exercise: Filter Method
    • Concept 10: Filter Method Review
    • Concept 11: The Reduce Method
    • Concept 12: Exercise: Reduce Method
    • Concept 13: Reduce Review
    • Concept 14: Array Methods for Selection
    • Concept 15: Exercise: Array Methods (Flat, Find, Include)
    • Concept 16: Array Method Problem Set
    • Concept 17: Variables
    • Concept 18: ES6 Object Methods & Freeze
    • Concept 19: Exercise: Object Method - Freeze
    • Concept 20: Object Method - Keys
    • Concept 21: Exercise: Object Method - Keys
    • Concept 22: Object Method - Assign
    • Concept 23: Exercise: Object Method - Assign
    • Concept 24: Object Methods Problem Set
    • Concept 25: Exercise: Putting it All Together
    • Concept 26: Lesson Recap
  • Lesson 04: Functional Programming in JSPractice applying what you’ve learned so far into creating functional programs and bring clarity to how React works behind the scenes.
    • Concept 01: Intro to FP in JS
    • Concept 02: Higher-Order Function Intro
    • Concept 03: Exercise: Higher-Order Functions 1
    • Concept 04: Higher-Order Functions
    • Concept 05: Exercise: Higher-Order Functions 2
    • Concept 06: Higher-Order Functions Review
    • Concept 07: Functional Data Manipulations
    • Concept 08: Exercise: Data Manipulations
    • Concept 09: Data Manipulations Problem Set
    • Concept 10: Functional DOM Manipulations
    • Concept 11: Exercise: Render Method
    • Concept 12: Holding Application State
    • Concept 13: Exercise: Application State
    • Concept 14: Functional DOM Manipulation Problem Set
    • Concept 15: Lesson Recap
  • Lesson 05: Going Further with Functional JSGoing further with Functional Programming and common tools to solve traditional problems in web development.
    • Concept 01: Going Further with Functional JS Intro
    • Concept 02: Persistent Data Structures
    • Concept 03: ImmutableJS
    • Concept 04: Exercise: ImmutableJS
    • Concept 05: ImmutableJS Review
    • Concept 06: Implementing ImmutableJS
    • Concept 07: Exercise: Implementing ImmutableJS
    • Concept 08: Implementing ImmutableJS Review
    • Concept 09: RxJS and Rambda
    • Concept 10: Functional Redux
    • Concept 11: Exercise: Build Your Own Reducer
    • Concept 12: Functional Redux Review
    • Concept 13: Lesson Recap
    • Concept 14: Course Recap
  • Lesson 06: Mars DashboardIn this project, you will create a dashboard that consumes the NASA API and applies all the functional programming learned throughout this course.Project Description - Mars DashboardProject Rubric - Mars Dashboard
    • Concept 01: Project Overview
    • Concept 02: Project Instructions
    • Concept 03: Workspace

      Part 04 : Asynchronous Programming with JavaScript

• Module 01: Asynchronous Programming with JavaScript

  • Lesson 01: Introduction to Asynchronous ProgrammingIntroduction to the course and concepts to be covered in this course.
    • Concept 01: Meet your Instructor
    • Concept 02: Course Goals and Outline
    • Concept 03: Prerequisites
    • Concept 04: Introduction to Asynchronous Programming
    • Concept 05: Exercise: Asynchronous Programming
    • Concept 06: Solution: Asynchronous Programming
    • Concept 07: Why Asynchronous Programming Is Important
    • Concept 08: Tools, Environment & Dependencies
    • Concept 09: Project: UdaciRacer Simulator
    • Concept 10: Recap
    • Concept 11: Good Luck!
  • Lesson 02: Synchronous Concepts and Asynchronous CallbacksTo create a foundation for asynchronous programming concepts, we start with a discussion of synchronous code and the concepts of blocking vs non-blocking, then learn to use asynchronous callbacks.
    • Concept 01: Lesson Introduction
    • Concept 02: Synchronous Programming
    • Concept 03: Introduction to Single Threaded Programming
    • Concept 04: Blocking vs Non-Blocking
    • Concept 05: Blocking vs Non-Blocking Code
    • Concept 06: Exercise: Blocking vs Non-Blocking
    • Concept 07: Solution: Blocking vs Non-Blocking
    • Concept 08: Asynchronous, Concurrent, or Parallel?
    • Concept 09: Quizzes: Synchronous Programming
    • Concept 10: Introduction to Sequencing Events - Callbacks
    • Concept 11: Callbacks Best Practices - Chaining
    • Concept 12: Callbacks Best Practices - Error Handling
    • Concept 13: Cons of Callbacks
    • Concept 14: Exercise: Callbacks
    • Concept 15: Solution: Callbacks
    • Concept 16: Callbacks Recap
    • Concept 17: Lesson Conclusion
    • Concept 18: Lesson Glossary
  • Lesson 03: Sequencing Events - PromisesThis lesson goes from basic Promise syntax all the way to implementing Promises, Fetch, and Promise methods.
    • Concept 01: Lesson Introduction
    • Concept 02: Introduction to Promises
    • Concept 03: Promise Chaining
    • Concept 04: Promises as the Answer to Callbacks
    • Concept 05: Exercise: Promises I
    • Concept 06: Solution: Promises I
    • Concept 07: Quizzes: Promises I
    • Concept 08: Using Promises with Fetch
    • Concept 09: Exercise: Fetch Request Practice
    • Concept 10: Solution: Fetch Practice
    • Concept 11: Promises Best Practices and Error Handling
    • Concept 12: Promises Helpful Tips
    • Concept 13: Exercise: Promises II
    • Concept 14: Solution: Promises II
    • Concept 15: Advanced Promise Syntax
    • Concept 16: Promise.allSettled
    • Concept 17: Promise.all
    • Concept 18: Promise.race
    • Concept 19: Exercise: Promises III
    • Concept 20: Solution: Promises III
    • Concept 21: Quizzes: Promises II
    • Concept 22: Lesson Conclusion
    • Concept 23: Lesson Glossary
  • Lesson 04: Sequencing Events - Async/AwaitThis lesson will get you acquainted with the Async/Await syntax introduced in ES8. Let’s master the code and principles behind this helpful addition designed to make asynchronous flows easier.
    • Concept 01: Lesson Introduction
    • Concept 02: Getting Started with Try/Catch
    • Concept 03: Exercise: Try/Catch Practice
    • Concept 04: Solution: Try/Catch Practice
    • Concept 05: Why Async/Await is Important
    • Concept 06: Introduction to Async/Await
    • Concept 07: Exercise: Async/Await I
    • Concept 08: Solution: Async/Await I
    • Concept 09: Error Handling with Async/Await
    • Concept 10: When (and When Not) to Use Async/Await
    • Concept 11: Exercise: Async/Await II
    • Concept 12: Solution: Async/Await II
    • Concept 13: Quizzes: Async/Await
    • Concept 14: Lesson Conclusion
    • Concept 15: Lesson Glossary
    • Concept 16: Course Recap
    • Concept 17: Congratulations!
  • Lesson 05: Project: UdaciRacer SimulatorProject Description - UdaciRacer SimulatorProject Rubric - UdaciRacer Simulator
    • Concept 01: Introduction
    • Concept 02: Instructions

【点击购买】