JavaScript: Understanding the Weird Parts

JavaScript: Understanding the Weird Parts
JavaScript: Understanding the Weird Parts

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 11.5 Hours | 0.97 GB
eLearning | Skill level: All Levels | by Anthony Alicea


An advanced JavaScript course for everyone! Scope, closures, prototypes, ‘this’, build your own framework, and more.

Javascript is the language that modern developers need to know, and know well. Truly knowing Javascript will get you a job, and enable you to build quality web and server applications.

NOTE: This course includes information on ECMAScript 6 (ES6) the next version of Javascript!

In this course you will gain a deep understanding of Javascript, learn how Javascript works under the hood, and how that knowledge helps you avoid common pitfalls and drastically improve your ability to debug problems. You will find clarity in the parts that others, even experienced coders, may find weird, odd, and at times incomprehensible. You’ll learn the beauty and deceptive power of this language that is at the forefront of modern software development today.

This course will cover such advanced concepts as objects and object literals, function expressions, prototypical inheritance, functional programming, scope chains, function constructors (plus new ES6 features), immediately invoked function expressions (IIFEs), call, apply, bind, and more.

We’ll take a deep dive into the source code of popular frameworks such as jQuery and Underscore to see how you can use your understanding of Javascript to learn (and borrow) from other’s good code.

Finally, you’ll learn the foundations of how to build your own Javascript framework or library.

What you’ll learn in this course will make you a better Javascript developer, and improve your abilities in AngularJS, NodeJS, jQuery, React, Ember, MongoDB, and all other Javascript-based technologies!

Learn to love Javascript, and code in it well.

Note: In this course you’ll also get downloadable source code. You will often be provided with ‘starter’ code, giving you the base for you to start writing your code, and ‘finished’ code to compare your code to.

+

Table of Contents

Section 1: Getting Started
1 Introduction and The Goal of This Course
2 Setup
3 Big Words and Javascript
4 Watching this Course in High Definition – Testo
5 Understanding, Frameworks, and The Weird Parts

Section 2: Execution Contexts and Lexical Environments
6 Conceptual Aside: Syntax Parsers, Execution Contexts, and Lexical Environments
7 Conceptual Aside: Name/Value Pairs and Objects
8 Downloading Source Code for This Course – Testo
9 The Global Environment and The Global Object
10 The Execution Context – Creation and Hoisting
11 Conceptual Aside: Javascript and ‘undefined’
12 The Execution Context – Code Execution
13 Conceptual Aside: Single Threaded, Synchronous Execution
14 Function Invocation and the Execution Stack
15 Functions, Context, and Variable Environments
16 The Scope Chain
17 Scope, ES6, and let
18 What About Asynchronous Callbacks?

Section 3: Types and Operators
19 Conceptual Aside: Types and Javascript
20 Primitive Types
21 Conceptual Aside: Operators
22 Operator Precedence and Associativity
23 Operator Precedence and Associativity Table – Testo
24 Conceptual Aside: Coercion
25 Comparison Operators
26 Equality Comparisons Table – Testo
27 Existence and Booleans
28 Default Values
29 Framework Aside: Default Values

Section 4: Objects and Functions
30 Objects and the Dot
31 Objects and Object Literals
32 Framework Aside: Faking Namespaces
33 JSON and Object Literals
34 Functions are Objects
35 Function Statements and Function Expressions
36 Conceptual Aside: By Value vs By Reference
37 Objects, Functions, and ‘this’
38 Conceptual Aside: Arrays – Collections of Anything
39 ‘arguments’ and spread
40 Framework Aside: Function Overloading
41 Conceptual Aside: Syntax Parsers
42 Dangerous Aside: Automatic Semicolon Insertion
43 Framework Aside: Whitespace
44 Immediately Invoked Functions Expressions (IIFEs)
45 Framework Aside: IIFEs and Safe Code
46 Understanding Closures
47 Understanding Closures – Part 2
48 Framework Aside: Function Factories
49 Closures and Callbacks
50 call(), apply(), and bind()
51 Functional Programming
52 Functional Programming – Part 2

Section 5: Object-Oriented Javascript and Prototypal Inheritance
53 Conceptual Aside: Classical vs Prototypal Inheritance
54 Understanding the Prototype
55 Everything is an Object (or a primitive)
56 Reflection and Extend

Section 6: Building Objects
57 Function Constructors, ‘new’, and the History of Javascript
58 Function Constructors and ‘.prototype’
59 Dangerous Aside: ‘new’ and functions
60 Conceptual Aside: Built-In Function Constructors
61 Dangerous Aside: Built-In Function Constructors
62 Dangerous Aside: Arrays and for..in
63 Object.create and Pure Prototypal Inheritance
64 ES6 and Classes

Section 7: Odds and Ends
65 Initialization
66 ‘typeof’ , ‘instanceof’, and Figuring Out What Something Is
67 Strict Mode
68 Strict Mode Reference – Testo

Section 8: Examining Famous Frameworks and Libraries
69 Learning From Other’s Good Code
70 Deep Dive into Source Code: jQuery – Part 1
71 Deep Dive into Source Code: jQuery – Part 2
72 Deep Dive into Source Code: jQuery – Part 3

Section 9: Let’s Build a Framework / Library!
73 Requirements
74 Structuring Safe Code
75 Our Object and Its Prototype
76 Properties and Chainable Methods
77 Adding jQuery Support
78 Good Commenting
79 Let’s Use Our Framework
80 A Side Note

Section 10: BONUS Lectures
81 TypeScript, ES6, and Transpiled Languages
82 Transpiled Languages References – Testo

Section 11: BONUS: Getting Ready for ECMAScript 6
83 Existing and Upcoming Features
84 ES6 Features Reference – Testo

Section 12: Conclusion
85 Learning to Love the Weird Parts