Index
Symbols
- ! (NOT operator), Converting to Boolean, AND, OR, and NOT-Comma Operator
- != (abstract inequality operator), Comparison Operators
- !== (strict inequality operator), Comparison Operators
- "following a recipe" metaphor, Control Flow
- $ (dollar sign), Identifier Names, Template Strings, The Terminal
- % (remainder operator), Arithmetic Operators
- && (AND operator), AND, OR, and NOT-Comma Operator
- ' (single quote), Strings
- () (parentheses), Operator Precedence, Grouping Operator, Calling Versus Referencing
- * (asterisk), Generators, The Period Metacharacter and Escaping
- */ (close comment), A Comment on Comments
- + (addition operator), String Concatenation
- + (in regex), Repetition
- + (unary addition operator), Arithmetic Operators
- ++ (increment operator), Arithmetic Operators
- - (subtraction operator), Arithmetic Operators
- - (unary negation operator), Arithmetic Operators
- -- (decrement operator), Arithmetic Operators
- . (period), The Period Metacharacter and Escaping
- .. (periods, double), The Terminal
- / (forward slash) division operator, The Terminal
- /* (open comment), A Comment on Comments
- // (forward slashes, double) comment, A Comment on Comments, Constructing Regular Expressions
- < (less than operator), Comparison Operators
- <!-- open comment (HTML), A Comment on Comments
- <= (less than or equal to operator), Comparison Operators
- <script> tag, Getting Started
- == (abstract equality operator), Comparison Operators
- === (strict equality operator), Comparison Operators
- => (arrow notation), Arrow Notation, yield Expressions and Two-Way Communication
- > (greater than operator), Comparison Operators
- >= (greater than or equal to operator), Comparison Operators
- [] (square brackets), Metasyntax, A Review of Arrays
- (backslash character), Escaping, The Period Metacharacter and Escaping, The Terminal
- _ (underscore character), Identifier Names, Dynamic Properties
- __proto__ property, The Prototype, Polymorphism
- ` (backtick character) string interpolation, Strings, Template Strings
- { } (curly braces), Template Strings, Objects, Block Statements
- | (bar, bitwise OR operator), Alternation
- || (OR operator), AND, OR, and NOT-Comma Operator
- ~ (tilde) home directory shortcut (Unix), Math, The Terminal
- “ (double quote), Strings
- … (ellipsis) MDN metasyntax, Metasyntax
- … (spread operator), Destructuring Arguments, call, apply, and bind, Maps, DOM “Get” Methods
A
- abstract equality operator (==), Comparison Operators
- abstract inequality operator (!=), Comparison Operators
- access restriction, Dynamic Properties
- accessor properties, Dynamic Properties, Accessor Properties: Getters and Setters
- accumulator value (Array#reduce), Array Magic: reduce
- acknowledgements, Acknowledgments
- actual arguments, Function Arguments, Scope
- add() method (sets), Sets
- addEventListener method, Events
- addition operator (+), String Concatenation
- aggregate data types, Objects and Object-Oriented Programming
- Ajax
- benefits of, Ajax
- endpoints, Ajax
- executing calls, Ajax
- simple server creation, Ajax
- algebraic functions
- algorithms, Functions as Subroutines, Math
- alteration, Alternation
- ancestor nodes, Some Tree Terminology
- anchoring, Anchoring
- AND operator (&&), AND, OR, and NOT-Comma Operator
- Angular 2, Web Applications
- anonymous functions, Function Expressions and Anonymous Functions
- application development
- automating repetitive tasks, Automating Repetitive Tasks
- benefits of browser-based programs, Where to Start
- browser selection, The Tools
- code repository, Getting Started
- comment syntax, A Comment on Comments
- dependency management, Package Management: npm
- drawing graphics primitives, Drawing Graphics Primitives
- file creation, Getting Started
- file loading, Getting Started
- handling user input, Handling User Input
- Hello World program, Your First Application, Hello, World
- HTML elements, Getting Started
- JavaScript console, The JavaScript Console
- object creation, Drawing Graphics Primitives
- text editor features, The Tools
- text editor selection, The Tools
- troubleshooting, Your First Application, Your Project Root
- (see also development tools)
- version control, Prerequisites
- web applications, Web Applications
- apply keyword, call, apply, and bind
- arguments
- assigning, Drawing Graphics Primitives, Function Arguments
- default, Default Arguments
- defined, Function Arguments
- destructuring, Destructuring Arguments
- formal vs. actual, Function Arguments, Scope
- inside vs. outside functions, Function Arguments
- vs. operands, Operators
- providing multiple, Do Arguments Make the Function?
- vs. variables, Function Arguments
- arguments variable, Destructuring Arguments
- arithmetic operators, Arithmetic Operators-Arithmetic Operators
- Array constructor, Filling an Array with a Specific Value
- Array object, Arrays
- Array.prototype.forEach, The Prototype
- Array.prototype.join method, String Joining
- arrays
- adding multiple elements to ends of, Adding Multiple Elements at the End
- adding/removing elements anywhere, Adding or Removing Elements at Any Position
- adding/removing elements at either end, Adding or Removing Single Elements at the Beginning or End
- basics of, A Review of Arrays
- creating, A Review of Arrays
- cutting/replacing elements within, Cutting and Replacing Within an Array
- deleted or never-defined elements in, Array Methods and Deleted or Never-Defined Elements
- destructuring, Destructuring Arguments
- filling with specified values, Filling an Array with a Specific Value
- functions in, Functions in an Array
- getting subarrays, Getting a Subarray
- iterating over, for...in
- joining value of elements together, String Joining
- modifying in place vs. returning new, Array Content Manipulation
- vs. objects, Objects and Object-Oriented Programming
- removing unwanted items from, The Fundamental Array Operations: map and filter
- reversing/sorting, Reversing and Sorting Arrays
- searching, Array Searching
- special operators for, Object and Array Operators
- summary of Array methods, Conclusion
- transforming elements in, The Fundamental Array Operations: map and filter
- transforming entire, Array Magic: reduce-Array Magic: reduce
- arrow notation (=>), Arrow Notation, yield Expressions and Two-Way Communication
- assignment expressions, Expressions and Operators, Assignment Operators
- asterisk (*), Generators, The Period Metacharacter and Escaping
- asynchronous programming
- benefits of, Callbacks
- callbacks, Callbacks-Callback Hell
- concept of, The Analogy
- generators, Generators-Exception Handling in Generator Runners
- IIFEs and, IIFEs and Asynchronous Code
- key points, Conclusion
- managing, Pass a Function into a Function, Asynchronous Programming
- promises, Promises-Preventing Unsettled Promises
- user input and, Handling User Input
- uses for, Asynchronous Programming
- Atom text editor, The Tools
- attributes, Object Property Attributes
- autocompletion, The Tools
B
- backreferences, Backreferences
- backslash character (), Escaping, The Period Metacharacter and Escaping, The Terminal
- backtick character (`) string interpolation, Strings, Template Strings
- bar, bitwise OR operator (|), Alternation
- bash shell, The Terminal
- Bau, David, Pseudorandom Number Generation
- bignums, Math
- bind keyword, call, apply, and bind
- bitwise operators, Bitwise Operators
- block comments, A Comment on Comments
- block scope, Block Scope
- block statements, Block Statements-Whitespace
- blocking, Callbacks
- body (functions), Functions
- body (HTML), Getting Started
- boilerplate code, Drawing Graphics Primitives
- Boolean type, Number, String, and Boolean Objects
- booleans, Booleans, AND, OR, and NOT
- Bootstrap, Online Documentation
- bracket matching, The Tools
- branching statements, Control Flow Statements in JavaScript
- break statements, Control Flow Exceptions, Using break or return to Avoid Unnecessary Computation
- browser-based programs
- asynchronous communication using Ajax, Ajax-Ajax
- benefits of, Where to Start
- creating DOM elements, Creating New DOM Elements
- DOM get methods, DOM “Get” Methods
- DOM tree, The Document Object Model-Some Tree Terminology
- event handling, Events-Event Categories
- manipulating DOM elements, Manipulating DOM Elements
- modifying HTML elements, Data Attributes
- querying DOM elements, Querying DOM Elements
- styling DOM elements, Styling Elements
- browsers
- bubbling events, Event Capturing and Bubbling
C
- C Programming Language, The (Kernighan), Your First Application
- call keyword, call, apply, and bind
- call stacks, Exception Handling and the Call Stack
- callable units, Functions as Subroutines
- callbacks (cb)
- callback hell, Callback Hell, Generators
- concept of, The Analogy
- defined, Pass a Function into a Function, Callbacks
- error-first, Error-First Callbacks, Generators
- vs. promises, Promises
- scope and asynchronous execution, Scope and Asynchronous Execution
- setInterval and clearInterval, setInterval and clearInterval
- camel case, Identifier Names
- canvas graphics library, Drawing Graphics Primitives
- capturing events, Event Capturing and Bubbling
- catch blocks, Exception Handling with try and catch, try...catch...finally
- cd (current directory, Unix command), The Terminal
- chaining
- character sets, Character Sets
- child nodes, The Document Object Model
- child_process module, Child Processes
- class keyword, Classes Are Functions
- class methods
- classes
- as functions, Classes Are Functions
- creating, Class and Instance Creation
- defined, Object-Oriented Programming
- hierarchical categorization of, Object-Oriented Programming
- naming conventions, The Prototype
- representation in JavaScript, Classes Are Functions
- superclasses, Polymorphism, Multiple Inheritance, Mixins, and Interfaces
- clear() method (maps), Maps
- clearInterval, setInterval and clearInterval
- clearTimeout, setInterval and clearInterval
- click event, Events
- close comment (*/), A Comment on Comments
- closures, Functions, Closures, and Lexical Scope, Scope and Asynchronous Execution
- co generator runner, Don’t Write Your Own Generator Runner
- Coda editor, The Tools
- code folding editor feature, The Tools
- code formatting, documentation for, The this Keyword
- code points, Strings
- code repository, Getting Started
- code reuse, Functions as Subroutines, So What?
- code syntax, Linting
- collisions, Multiple Inheritance, Mixins, and Interfaces, Modules
- comma operator, Additional for Loop Patterns, Comma Operator
- command line/prompt, The Terminal
- command-line arguments, Process
- Command-Option-K shortcut, The JavaScript Console
- commas, trailing, Linting, Trailing Commas in Objects and Arrays
- comments, A Comment on Comments
- commit messages (Git), Using Git
- commits (Git), Using Git
- CommonJS, Linting
- comparison operators, Comparison Operators
- complex data types, Objects and Object-Oriented Programming
- complex numbers, Math
- compound statements, Block Statements
- computed member access operator, Objects
- concat method, Adding Multiple Elements at the End
- concatenation, Template Strings, String Concatenation, String Joining
- conditional expressions, Converting if...else Statements to Conditional Expressions
- conditional nesting, Using continue to Reduce Conditional Nesting
- conditional operators, Conditional Operator
- conditional statements, Control Flow Statements in JavaScript
- conditions, while Loops, for Loop, Metasyntax
- console
- Console Foundations (Treehouse course), The Terminal
- console.log method, The JavaScript Console, Linting
- constants, Variables and Constants, Literals, Constants
- constructors
- containers, Objects, Objects and Object-Oriented Programming
- content-delivery network (CDN), Drawing Graphics Primitives
- continue statements, Control Flow Exceptions, Using continue to Reduce Conditional Nesting
- control flow
- Coordinated Universal Time (UTC), Dates, Time Zones, Timestamps, and the Unix Epoch
- copyWithin method, Cutting and Replacing Within an Array
- core modules, Core Modules, File Modules, and npm Modules-Core Modules, File Modules, and npm Modules
- CORS (cross-origin resource sharing), Ajax
- Crockford, Douglas, Comparison Operators
- CSS selectors, Querying DOM Elements, Data Attributes
- Ctrl-Shift-K shortcut, The JavaScript Console
- cube root, Exponentiation
- curly braces ({ }), Template Strings, Objects, Block Statements
- Curry, Haskell, Return a Function from a Function
- currying, Return a Function from a Function
D
- Dahl, Ryan, Node
- dangling commas, Trailing Commas in Objects and Arrays
- data attributes, Data Attributes
- data properties, Accessor Properties: Getters and Setters
- data types
- Date object, Dates, Constructing Date Objects
- dates and times
- accessing date components, Date Components
- challenges of representing, Dates, Time Zones, Timestamps, and the Unix Epoch
- comparing dates, Comparing Dates
- constructing Date objects, Constructing Date Objects
- constructing dates, Constructing Dates
- date arithmetic, Date Arithmetic
- key points, Conclusion
- Moment.js library, Moment.js
- time zone representation, Dates, Time Zones, Timestamps, and the Unix Epoch
- transmitting dates, Transmitting Dates, Displaying Dates
- user-friendly relative dates, User-Friendly Relative Dates
- debug package, Customizing Modules with Function Modules
- decimal literals, Numbers
- decimal numbers, Fixed Decimals
- declaration statements, Expressions and Operators, Scope
- decrement operator (--), Arithmetic Operators
- default case, switch Statements
- default values, Default Arguments
- DELETE method (HTTP), Ajax
- delete() method, Maps, Sets
- dependencies, Package Management: npm
- dependency management, Package Management: npm
- depth-first, pre-order tree traversal, The Document Object Model
- descendant nodes, Some Tree Terminology
- descending indexes, Using Descending Indexes When Modifying Lists
- destructured arguments, Destructuring Arguments
- destructuring assignment operator, Destructuring Assignment
- dev dependencies, Package Management: npm
- development tools
- direct child nodes, Some Tree Terminology
- direct parent nodes, Some Tree Terminology
- directories
- discoverability, The Tools
- dispatching functions, Functions
- Dive Into HTML5 (Pilgrim), Online Documentation
- Document Object Model (DOM)
- adding data to elements, Data Attributes
- creating elements, Creating New DOM Elements
- elements of, The Document Object Model
- event handling, Events-Event Categories
- get methods, DOM “Get” Methods
- manipulating elements, Manipulating DOM Elements
- querying elements, Querying DOM Elements
- styling elements, Styling Elements
- traversing, The Document Object Model
- tree diagram, The Document Object Model
- document.getElementById, DOM “Get” Methods
- document.getElementsByClassName, DOM “Get” Methods
- document.getElementsByTagName, DOM “Get” Methods
- documentation, online, Online Documentation
- dollar sign ($), Identifier Names, Template Strings, The Terminal
- double quote (“), Strings
- double-precision floating-point format, Numbers, Math
- do…while loops, do…while Loop, Metasyntax
- drag events (HTML), Event Categories
- DRY (don't repeat yourself), So What?
- duck typing, Polymorphism
- duplex streams, Streams
- dynamic dispatch, The Prototype
- dynamic properties, Dynamic Properties, Accessor Properties: Getters and Setters
E
- EaselJS, Drawing Graphics Primitives
- ECMA-262 ECMAScript 2015 Language Specification, A Brief History of JavaScript, Online Documentation
- editor integration, Linting
- Eich, Brendan, Preface
- Electron, What Are You Trying to Do?
- elements, in DOM, The Document Object Model
- ellipsis (…) MDN metasyntax, Metasyntax
- Emacs text editor, The Tools
- entries() method, Maps
- enumeration, Property Enumeration, Enumerating Object Properties, Revisited
- equality operators, Comparison Operators
- Error object, The Error Object, Throwing Errors
- error-first callbacks, Error-First Callbacks, Generators
- errors (see exception handling)
- ES2015, A Brief History of JavaScript
- ES5 (ECMAScript 5)
- ES6 (ECMAScript 6)
- escaping, Escaping, The Period Metacharacter and Escaping
- ESLint
- event handlers
- attaching, Handling User Input
- capturing and bubbling, Event Capturing and Bubbling
- clearing timeouts, Events
- click event, Events
- emitting events, Events
- event categories, Event Categories
- event propagation, Event Capturing and Bubbling
- listening for events, Events
- multiple events, Events
- support for, Events
- EventEmitter, Events
- events, asynchronous, Handling User Input
- evergreen browsers, Web Applications
- every method (arrays), Array Searching
- exception handling
- and call stacks, Exception Handling and the Call Stack
- anticipated vs. unanticipated errors, Exceptions and Error Handling
- communicating errors, The Error Object
- computational cost of, Let Exceptions Be Exceptional
- Error object, The Error Object
- finally blocks, try...catch...finally
- generator runners and, Exception Handling in Generator Runners
- throwing errors, Throwing Errors
- unhandled/uncaught exceptions, Exception Handling and the Call Stack
- with try and catch, Exception Handling with try and catch
- exception statements, Control Flow Exceptions
- executing functions, Functions
- execution context, Scope Versus Existence
- existence, vs. scope, Scope Versus Existence
- exit codes, Process
- exponential notation, Exponential Notation
- exponentiation functions, Exponentiation
- Express, Web Servers
- expressions
- and control flow patterns, Expressions and Control Flow Patterns
- conditional, Converting if...else Statements to Conditional Expressions
- defined, Metasyntax, Expressions and Operators
- function expressions, Function Expressions and Anonymous Functions
- identifier expressions, Expressions and Operators
- in template strings, Expressions in Template Strings
- literal expressions, Expressions and Operators
- vs. non-expression statements, Expressions and Operators
- operator expressions, Expressions and Operators
- order of execution, Expressions and Operators
- types of, Expressions and Operators
- uses for, Expressions and Operators
- Extended Backus-Naur Form (EBNF), Metasyntax
- extensions, preventing, Protecting Objects: Freezing, Sealing, and Preventing Extension
F
- Fabric.js, Drawing Graphics Primitives
- fall-through execution, switch Statements
- falsy values, Truthy and Falsy Values
- fat arrow notation (=>), Arrow Notation, yield Expressions and Two-Way Communication
- fatal errors, Process
- file modules, Core Modules, File Modules, and npm Modules
- filename globbing, The Period Metacharacter and Escaping
- files
- filesystem access, Filesystem Access
- fill method (arrays), Filling an Array with a Specific Value
- filter function (arrays), The Fundamental Array Operations: map and filter
- final expressions (in for loop), for Loop
- finally blocks, try...catch...finally
- find method (arrays), Array Searching
- findIndex method (arrays), Array Searching
- first-level headers, Getting Started
- fixed-decimal numbers, Fixed Decimals
- fixed-precision numbers, Numbers, Fixed Precision
- floating-point types, Numbers, Math
- flowcharts, A Control Flow Primer, A Control Flow Primer, Conclusion
- focus events (HTML), Event Categories
- for loops, Automating Repetitive Tasks, for Loop, do...while statement
- forEach (arrays), The Prototype
- form events (HTML), Event Categories
- formal arguments, Function Arguments, Scope
- forward slash (/) division operator, The Terminal
- forward slashes, double (//) comment, A Comment on Comments, Constructing Regular Expressions
- for…in loops, for...in loop, for...in
- for…of loops, for...of loop, Maps
- FOUC (flash of unstyled content) problem, Ajax
- freezing, Protecting Objects: Freezing, Sealing, and Preventing Extension
- frontend frameworks, Web Applications
- function keyword, Generators
- function modules, Customizing Modules with Function Modules
- Function object, Functions Are Objects
- function replacements, Function Replacements
- function variables
- functions
- aliasing, Function Variables
- anonymous functions, Function Expressions and Anonymous Functions
- apply keyword and, call, apply, and bind
- arguments/parameters for, Function Arguments-Default Arguments
- arrow notation and, Arrow Notation
- as properties of objects, Functions as Properties of Objects
- bind keyword and, call, apply, and bind
- body of, Functions
- call keyword and, call, apply, and bind
- calling, Objects, Functions
- calling vs. referencing, Calling Versus Referencing
- classes as, Classes Are Functions
- declaring, Functions
- defined, Functions
- defining in specific scope, Functions, Closures, and Lexical Scope
- function expressions, Function Expressions and Anonymous Functions
- function hoisting, Function Hoisting
- vs. generators, Generators
- helper functions, Helper Functions
- identifying, Functions Are Objects
- vs. methods, Functions as Properties of Objects
- naming conventions, Functions as Subroutines, Functions as Subroutines That Return a Value
- nested, The this Keyword, Exception Handling and the Call Stack
- prototype property, The Prototype
- pure functions, Functions as…Functions-So What?
- recursive, Recursion, Generators
- referring to from within, Function Expressions and Anonymous Functions
- return keyword and, Return Values
- sort functions, Reversing and Sorting Arrays
- as subroutines, Functions as Subroutines
- subroutines that return values, Functions as Subroutines That Return a Value
- this keyword and, The this Keyword, Arrow Notation
G
- garbage collection, Scope Versus Existence
- generator runners, Generators-Exception Handling in Generator Runners
- generators
- asynchronous programming and, Generators-Exception Handling in Generator Runners
- vs. asynchronous programming, Asynchronous Programming
- benefits of, Generators, Conclusion, Generators
- co generator runner, Don’t Write Your Own Generator Runner
- creating recursive generator runners, Generators
- defined, Generators
- exception handling and, Exception Handling in Generator Runners
- vs. functions, Generators
- sequence of events, yield Expressions and Two-Way Communication
- stopping, Generators and return
- yield expressions and, yield Expressions and Two-Way Communication
- GET method (HTTP), Ajax
- get() method (maps), Maps
- getter function, Accessor Properties: Getters and Setters
- git add, Using Git
- git init, Using Git
- git status, Using Git
- Git version control tool
- .gitignore file, Using Git
- global objects, The this Keyword, setInterval and clearInterval
- global packages, Package Management: npm
- global scope, Global Scope, Functions, Closures, and Lexical Scope
- GMT (Greenwich Mean Time), Dates, Time Zones, Timestamps, and the Unix Epoch
- graphics primitives, Drawing Graphics Primitives
- graphics transformations, Functions in an Array
- grave accent mark (`), Strings
- greater than operator (>), Comparison Operators
- greater than or equal to operator (>=), Comparison Operators
- greedy matches (regexes), Lazy Matches, Greedy Matches
- Greenwich Mean Time (GMT), Dates, Time Zones, Timestamps, and the Unix Epoch
- grouping (regexes), Grouping
- grouping operators, Grouping Operator-Assignment Operators
H
- Harmony, A Brief History of JavaScript
- has() method (maps), Maps
- hasOwnProperty (objects), for...in, Enumerating Object Properties, Revisited
- head (HTML), Getting Started
- Hello World program, Your First Application, Hello, World
- hoisting, Function Scope and Hoisting
- Holowaychuk, TJ, Web Servers
- home directory, The Terminal
- HTML elements
- <script>, Getting Started
- body, Getting Started
- first-level header text, Getting Started
- head, Getting Started
- IDs for, Drawing Graphics Primitives
- in DOM, The Document Object Model
- italics tags, Getting Started
- links, Getting Started
- matching, Matching HTML
- paragraph tags, Getting Started
- HTML5, Data Attributes, Online Documentation
- HTML5 canvas, Drawing Graphics Primitives
- HTMLCollection object, DOM “Get” Methods
- HTTP request methods, Ajax
- hyperbolic functions, Hyperbolic Functions
I
- i (index) variable, for Loop, Using Value of Index After Loop Completion
- id attributes (HTML), Drawing Graphics Primitives, DOM “Get” Methods
- identifier expressions, Expressions and Operators
- identifiers, Identifier Names, Literals
- IEEE-764 double-precision floating-point format, Numbers, Math
- if statements, if Statement, Converting if Statements to Short-Circuited Logical OR Expressions, Exception Handling with try and catch
- if…else statements, if…else Statement, Chaining if...else Statements, Metasyntax, Converting if...else Statements to Conditional Expressions
- IIFE (immediately invoked function expressions), Function Expressions and Anonymous Functions, Immediately Invoked Function Expressions, Dynamic Properties, Weak Maps, IIFEs and Asynchronous Code
- immutability, Primitive Types and Objects
- implicit globals, Strict Mode
- increment (++) operator, Arithmetic Operators
- index.html files, Getting Started
- indexOf method, Array Searching
- infinite loops, Additional for Loop Patterns
- infinity, Numbers
- inherited properties, for...in, Inheritance
- initializers, for Loop
- injecting functionality, Pass a Function into a Function
- inline comments, A Comment on Comments
- input consumption, Input Consumption-Input Consumption
- input device events, Event Categories
- instance methods, Static Methods
- instanceof operator, Class and Instance Creation
- instances (of objects)
- integer types, Numbers
- interfaces, Multiple Inheritance, Mixins, and Interfaces
- internal variables, Identifier Names
- interpolation, Template Strings
- invoking functions, Functions
- isNaN function, Comparing Numbers
- italic tags (HTML), Getting Started
- iteration
L
- lazy matches (regexes), Lazy Matches, Greedy Matches
- Learning Web App Development (Purewal), Conclusion
- length property (arrays), A Review of Arrays
- less than operator (<), Comparison Operators
- less than or equal to operator (<=), Comparison Operators
- let keyword, Variables and Constants, Function Scope and Hoisting, The Temporal Dead Zone
- lexical scoping, Lexical Versus Dynamic Scoping, Functions, Closures, and Lexical Scope
- links (HTML), Getting Started
- linting tools, Linting, Strict Mode, The Prototype
- literal arrays, A Review of Arrays
- literal expressions, Expressions and Operators
- literals, Literals
- LiveScript, A Brief History of JavaScript
- local packages, Package Management: npm
- Loeliger, Jon, Using Git
- logarithmic functions, Logarithmic Functions
- logical operators, Logical Operators
- lookaheads (regexes), Lookaheads
- loop statements, Control Flow Statements in JavaScript
- (see also individual loops)
- loose typing, The Tools
M
- macros, Functions as Subroutines
- map function (arrays), The Fundamental Array Operations: map and filter
- Map object
- Markdown format, Using Git
- masking, of variables, Variable Masking
- matching, Regular Expressions
- (see also regular expressions)
- math functions
- Math object, Math
- Math.js, Math
- media events, Event Categories
- member access operator, Objects
- members, Objects
- (see also object properties)
- metasyntax, Metasyntax
- methods
- adding to object literals, Functions as Properties of Objects
- defined, The this Keyword, Object-Oriented Programming
- defining on instances, The Prototype
- dynamic invocation of, The Prototype
- vs. functions, Functions as Properties of Objects
- instance, Static Methods
- prototype, The Prototype
- static, Static Methods, Math
- Meyer, Eric A., Conclusion
- mixins, Multiple Inheritance, Mixins, and Interfaces
- mkdir (make directory, Unix command), The Terminal
- Mocha, A Brief History of JavaScript
- modules, Modules
- Moment.js library, Moment.js
- Mozilla Developer Network (MDN)
- multiline strings, Multiline Strings
- multiple inheritance, Multiple Inheritance, Mixins, and Interfaces
- multiplication operators, Expressions and Operators
- multitasking, Asynchronous Programming
- multithreaded programming, Asynchronous Programming
N
- namespacing, Function Variables, Math, Modules
- naming rules and conventions, Identifier Names, The Prototype
- NaN (not a number), Numbers, Comparing Numbers
- negated character sets (regexes), Character Sets
- negative infinity, Numbers
- nested control flow, Using continue to Reduce Conditional Nesting
- nested functions, The this Keyword, Exception Handling and the Call Stack
- nested scope, Variable Masking
- new keyword, The Prototype
- next() method (iterators), Functions as…Functions
- nfcall (Node function call), Generators
- Node
- benefits of, What Are You Trying to Do?, Node
- child_process module, Child Processes
- creation of, Node
- documentation, Core Modules, File Modules, and npm Modules, Online Documentation
- filesystem access, Filesystem Access
- fundamentals of, Node Fundamentals
- installing, Installing Node
- module customization, Customizing Modules with Function Modules
- module types, Core Modules, File Modules, and npm Modules-Core Modules, File Modules, and npm Modules
- modules and namespacing in, Modules
- os module, Operating System
- process variable, Process-Process
- running JavaScript programs with, Running JavaScript Programs with Node
- streams in, Streams
- web server configuration, Web Servers
- Node objects, The Document Object Model
- Node.ELEMENT_NODE, The Document Object Model
- Node.TEXT_NODE, The Document Object Model
- nodes (HTML DOM), The Document Object Model
- node_modules directory, Package Management: npm
- non-expression statements, Expressions and Operators
- nonboolean logical operands, Logical Operators with Nonboolean Operands
- nonhomogeneous arrays, A Review of Arrays
- nonprintable characters, Special Characters
- NOT operator (!), Converting to Boolean, AND, OR, and NOT-Comma Operator
- Notepad++, The Tools
- npm package manager
- null type, null and undefined
- number formatting
- Number type, Number, String, and Boolean Objects
- Number.EPSILON constant, Comparing Numbers
- Number.prototype.toFixed, Fixed Decimals
- numbers
- Numeral.js, Advanced Number Formatting
- numeric literals, Literals
O
- Object class, Polymorphism
- object instances, Object-Oriented Programming
- object property configuration
- Object.defineProperty, Object Property Attributes
- Object.keys, Object.keys, Enumerating Object Properties, Revisited
- objects
- adding properties to, Objects
- Array, Arrays
- vs. arrays, Objects and Object-Oriented Programming
- basics of, Objects
- contents of, Objects
- creating, Drawing Graphics Primitives
- Date, Dates
- defined, Object-Oriented Programming
- displaying properties of, Objects
- flexibility of, Primitive Types and Objects
- functions as properties of, Functions as Properties of Objects
- functions in, Objects
- listing contents of, Property Enumeration
- Map and WeakMap, Maps and Sets, Maps-Weak Sets
- vs. maps, Breaking the Object Habit
- modifying, Function Arguments
- naming conventions, Objects
- Number, String, and Boolean types, Number, String, and Boolean Objects
- vs. primitives, Objects, Function Arguments
- RegExp, Regular Expressions
- special operators for, Object and Array Operators
- string representation of, String Representation
- trailing commas in, Trailing Commas in Objects and Arrays
- OOP (object-oriented programming)
- basic vocabulary of, Object-Oriented Programming
- basics of, Object-Oriented Programming
- benefits of, Conclusion
- class and instance creation, Class and Instance Creation
- classes as functions, Classes Are Functions
- dynamic properties, Dynamic Properties, Accessor Properties: Getters and Setters
- hierarchical categorization in, Object-Oriented Programming
- inheritance, Inheritance
- multiple inheritance, Multiple Inheritance, Mixins, and Interfaces
- polymorphism, Polymorphism
- property enumeration, Enumerating Object Properties, Revisited
- prototype methods, The Prototype
- static methods, Static Methods, Math
- string representation, String Representation
- open comment (/*), A Comment on Comments
- open comment (HTML) (<!--), A Comment on Comments
- operands, Expressions and Operators
- operation expressions, Expressions and Operators
- operator precedence, Operator Precedence
- operators
- AND, OR, and NOT, AND, OR, and NOT-Comma Operator
- arithmetic, Arithmetic Operators-Arithmetic Operators
- comma, Additional for Loop Patterns, Comma Operator
- comparison, Comparison Operators
- conditional, Conditional Operator
- defined, Operators
- destructuring assignment, Destructuring Assignment
- grouping, Grouping Operator-Assignment Operators
- logical, Logical Operators
- multiplication, Expressions and Operators
- object and array, Object and Array Operators
- operator precedence, Expressions and Operators, Operator Precedence
- postfix and prefix, Arithmetic Operators
- relational, Comparison Operators
- ternary, Conditional Operator
- optional elements, Metasyntax
- OR operator (||), AND, OR, and NOT-Comma Operator
- os module, Operating System
P
- package management, Package Management: npm-Package Management: npm
- package.json file, Package Management: npm
- Paper.js, Drawing Graphics Primitives, Handling User Input
- paragraph tags (HTML), Getting Started
- parameters (see arguments)
- parentheses (), Operator Precedence, Grouping Operator, Calling Versus Referencing
- parseFloat function, Converting to Numbers
- parseInt function, Converting to Numbers
- parsing (HTML), Matching HTML
- periods (.), The Period Metacharacter and Escaping
- periods, double (..), The Terminal
- Pilgrim, Mark, Online Documentation
- pipelines, Functions in an Array
- piping, Streams
- plus, in regex (+), Repetition
- polymorphism, Polymorphism
- Pop Art, Acknowledgments
- pop method (arrays), Adding or Removing Single Elements at the Beginning or End
- POST method (HTTP), Ajax
- postfix operators, Arithmetic Operators
- precedence levels, Operator Precedence
- preemptive multitasking, Asynchronous Programming
- prefix operators, Arithmetic Operators
- primitive types
- privacy, enforcing, Dynamic Properties
- private keys, Weak Maps
- procedures, Functions as Subroutines
- process variable, Process-Process
- programming languages
- progress events, Event Categories
- project root, Your Project Root, Linting
- promises
- basics of, Promises
- benefits of, Promises
- vs. callbacks, Promises
- chaining, Promise Chaining
- concept of, The Analogy
- creating, Creating Promises
- events and, Events
- preventing unsettled, Preventing Unsettled Promises
- turning error-first callbacks into, Generators
- using, Using Promises
- properties
- accessor, Dynamic Properties, Accessor Properties: Getters and Setters
- adding to objects, Objects
- data, Accessor Properties: Getters and Setters
- defining on instances, The Prototype
- dynamic, Dynamic Properties, Accessor Properties: Getters and Setters
- enumeration of, Property Enumeration, Enumerating Object Properties, Revisited
- inherited, for...in, Inheritance
- parts of, Objects and Object-Oriented Programming
- prototype, The Prototype
- restricting access to, Dynamic Properties
- symbols as names of, Dynamic Properties, Accessor Properties: Getters and Setters
- property attributes, Object Property Attributes
- property configuration, Object Property Attributes
- property descriptors, Object Property Attributes
- prototypal inheritance, Enumerating Object Properties, Revisited
- prototype chains, Inheritance
- prototype methods, The Prototype
- proxies, Proxies
- pseudorandom number generation, Pseudorandom Number Generation
- pure functions, Functions as…Functions-So What?
- Purewal, Semmy, Conclusion
- push method, Adding or Removing Single Elements at the Beginning or End
- pwd (print working directory), The Terminal
R
- random number generators, Pseudorandom Number Generation
- React, Web Applications
- read streams, Streams
- read-only properties, Object Property Attributes
- recipe metaphor, Control Flow
- recursion, Function Expressions and Anonymous Functions, Recursion
- reduce method (arrays), Array Magic: reduce-Array Magic: reduce
- reference types, Function Arguments
- referencing functions, Calling Versus Referencing
- regex/regexp (see regular expressions)
- RegExp class, Constructing Regular Expressions
- RegExp object, Regular Expressions
- RegExp.prototype.exec, Searching with Regular Expressions
- RegExp.prototype.test, Searching with Regular Expressions
- regular expressions
- alterations, Alternation
- anchoring, Anchoring
- backreferences, Backreferences
- benefits of, Regular Expressions
- character sets and, Character Sets
- concept of, Input Consumption
- constructing, Constructing Regular Expressions
- constructing dynamically, Constructing Regexes Dynamically
- constructing subexpressions, Grouping
- escaping characters, The Period Metacharacter and Escaping
- function replacements, Function Replacements
- input consumption, Input Consumption-Input Consumption
- key point, Conclusion
- lazy vs. greedy matches, Lazy Matches, Greedy Matches
- limitations of, Matching HTML
- lookaheads, Lookaheads
- match anything except newlines, The Period Metacharacter and Escaping
- match anything including newlines, A True Wildcard
- matching HTML, Matching HTML
- metalanguage, Searching with Regular Expressions
- named character sets (abbreviations), Named Character Sets
- negating (ignoring) characters, Character Sets
- regex testers, Conclusion
- repetition metacharacters, Repetition
- replacing groups, Replacing Groups
- replacing with, Replacing with Regular Expressions
- searching with, Searching with Regular Expressions
- specifying ranges, Character Sets
- substring matching/replacing, Substring Matching and Replacing
- troubleshooting, Grouping, Function Replacements
- word boundary matching, Word Boundary Matching
- relational operators, Comparison Operators
- remainder operator (%), Arithmetic Operators
- repetition modifiers (regexes), Repetition, Lazy Matches, Greedy Matches
- repetition, avoiding, Drawing Graphics Primitives, So What?
- repetitive tasks, automating, Drawing Graphics Primitives
- repositories, initializing (Git), Using Git
- reserved words, Identifier Names, Reserved Words-Reserved Words
- resources
- return keyword, Return Values
- return statements, Control Flow Exceptions, Generators and return
- return values, Return Values
- reusable subroutines, Functions as Subroutines
- reverse method (arrays), Reversing and Sorting Arrays
- Ritchie, Dennis, Your First Application
- routines, Functions as Subroutines
- running functions, Functions
S
- scaffold applications, Web Applications
- Scheme language, A Brief History of JavaScript
- scope
- asynchronous execution and, Scope and Asynchronous Execution
- block, Block Scope
- closure and, Functions, Closures, and Lexical Scope, Scope and Asynchronous Execution
- defined, Scope
- vs. existence, Scope Versus Existence
- function hoisting, Function Hoisting
- function scope and hoisting, Function Scope and Hoisting
- global, Global Scope, Functions, Closures, and Lexical Scope
- IIFEs and, Immediately Invoked Function Expressions
- lexical, Functions, Closures, and Lexical Scope
- lexical vs. dynamic, Lexical Versus Dynamic Scoping
- nested, Variable Masking
- scope chains, Variable Masking
- strict mode and, Strict Mode, Object Property Attributes
- temporal dead zone and, The Temporal Dead Zone
- variable masking, Variable Masking
- sealing, Protecting Objects: Freezing, Sealing, and Preventing Extension
- search and replace functionality, Substring Matching and Replacing
- searching arrays, Array Searching
- seeded pseudorandom numbers, Pseudorandom Number Generation
- seedrandom.js, Pseudorandom Number Generation
- Self language, A Brief History of JavaScript
- Set object
- set() method (maps), Maps
- setInterval, setInterval and clearInterval
- sets, defined, Sets
- setter function, Accessor Properties: Getters and Setters
- setTimeout, Callbacks
- shadowing, of variables, Variable Masking
- shell (terminal interface), The Terminal
- shift method (arrays), Adding or Removing Single Elements at the Beginning or End
- short-circuit evaluation, Short-Circuit Evaluation, Converting if Statements to Short-Circuited Logical OR Expressions
- side effects, Short-Circuit Evaluation, Functions as…Functions
- signatures (of functions), Do Arguments Make the Function?
- Simpson, Kyle, Generators
- simulations, A Control Flow Primer
- single inheritance, Multiple Inheritance, Mixins, and Interfaces
- single quote ('), Strings
- single-threaded applications, Asynchronous Programming
- size property (maps and sets), Maps, Sets
- slice method (arrays), Getting a Subarray
- Smith, Ken, Date and Time
- some method (arrays), Array Searching
- sort method (arrays), Reversing and Sorting Arrays
- special characters, Special Characters
- splice method (arrays), Using Descending Indexes When Modifying Lists, Adding or Removing Elements at Any Position
- spread operator (…), Destructuring Arguments, call, apply, and bind, Maps, DOM “Get” Methods
- square brackets ([]), Metasyntax, A Review of Arrays
- square root, Exponentiation
- Stack Overflow, Stack Overflow
- standalone blocks, Block Scope
- starting/stopping conditions (loops), A Control Flow Primer
- static methods, Static Methods, Math
- Steele, Guy, A Brief History of JavaScript
- stopping conditions (recursion), Recursion
- streams, Streams
- strict equality, Comparison Operators
- strict mode, Strict Mode, Object Property Attributes
- string (text) variables, Variables and Constants
- string literals, Literals
- String type, Number, String, and Boolean Objects
- String.prototype, Substring Matching and Replacing
- String.prototype.match, Searching with Regular Expressions
- String.prototype.replace, Substring Matching and Replacing
- strings
- concatenation of, String Concatenation, String Joining
- converting objects to, Converting to String
- converting to numbers, Converting to Numbers
- defined, Strings
- escaping, Escaping
- matching/replacing, Regular Expressions
- multiline, Multiline Strings
- numbers as, Numbers as Strings
- representation of objects, String Representation
- special characters, Special Characters
- template strings, Template Strings, Expressions in Template Strings
- subarrays, Getting a Subarray
- subexpressions (regexes), Grouping
- Sublime Text, The Tools
- subprograms, Functions as Subroutines
- subroutines, Functions as Subroutines-Functions as Subroutines That Return a Value
- subtraction operator (-), Arithmetic Operators
- superclasses, Polymorphism, Multiple Inheritance, Mixins, and Interfaces
- Sussman, Gerald, A Brief History of JavaScript
- switch statements, switch Statements
- symbols, Symbols, Multiple Inheritance, Mixins, and Interfaces, Accessor Properties: Getters and Setters
- syntax highlighting, The Tools
T
- TDZ (temporal dead zone), The Temporal Dead Zone
- template strings, Template Strings, Expressions in Template Strings
- terminal commas, Trailing Commas in Objects and Arrays
- Terminal program, The Terminal
- ternary operators, Conditional Operator
- text editors
- TextPad, The Tools
- this keyword, The this Keyword, Arrow Notation, Class and Instance Creation
- throw statements, Control Flow Exceptions, Throwing Errors
- tilde (~) home directory shortcut (Unix), Math, The Terminal
- time zones (TZs), Dates, Time Zones, Timestamps, and the Unix Epoch, Displaying Dates
- (see also dates and times)
- times, Dates
- toString() method, Converting to String, String Representation
- touch events (HTML), Event Categories
- trailing commas, Linting, Trailing Commas in Objects and Arrays
- transcompilers, Web Applications
- transformations, Functions in an Array
- traversal functions (trees), The Document Object Model
- Treehouse, The Terminal
- TreeWalker object (HTML), The Document Object Model
- trigonometric functions, Trigonometric Functions
- troubleshooting
- application development, Your Project Root
- bind keyword, call, apply, and bind
- class names, The Prototype
- code syntax, Your First Application
- debugging with toString method, String Representation
- generator values, Generators and return
- implicit globals, Strict Mode
- initial data values on instances, The Prototype
- literals vs. identifiers, Literals
- regular expressions, Grouping, Function Replacements
- throwing exceptions, Let Exceptions Be Exceptional
- unique IDs, DOM “Get” Methods
- variable names, Variables and Constants
- truth tables, AND, OR, and NOT
- truthy values, Truthy and Falsy Values
- try…catch statements, Exception Handling with try and catch, try...catch...finally
- two-way communication (generators), yield Expressions and Two-Way Communication
- typeof operator, typeof Operator, The Temporal Dead Zone, The Error Object
- typeof v, Functions Are Objects
- typographical conventions, Conventions Used in This Book
U
- unary addition operator (+), Arithmetic Operators
- unary negation operator (-), Arithmetic Operators
- uncaught exceptions, Exception Handling and the Call Stack
- undefined types, null and undefined
- underscore character (_), Identifier Names, Dynamic Properties
- Underscore package, Package Management: npm
- unhandled exceptions, Exception Handling and the Call Stack
- Unicode characters, Identifier Names, Strings, Special Characters
- unique IDs (HTML), DOM “Get” Methods
- unique tokens, Symbols
- unsettled promises, Preventing Unsettled Promises
- unshift method (arrays), Adding or Removing Single Elements at the Beginning or End
- user input, asynchronous nature of, Handling User Input, Asynchronous Programming
- UTC (Coordinated Universal Time), Dates, Time Zones, Timestamps, and the Unix Epoch
V
- value types, Function Arguments
- valueOf() method, Converting to Numbers
- values, Objects and Object-Oriented Programming
- values() method (maps), Maps
- var keyword, Function Scope and Hoisting
- variable masking, Variable Masking
- variables
- vs. arguments, Function Arguments
- changing contents of, Primitive Types and Objects, Function Arguments
- vs. constants, Literals
- declaration vs. definition of, Scope
- declaring, Variables and Constants
- declaring multiple, Variables and Constants, Additional for Loop Patterns
- i (index), for Loop, Using Value of Index After Loop Completion
- internal, Identifier Names
- vs. literals, Literals
- masking, Variable Masking
- naming conventions, Identifier Names
- shadowing, Variable Masking
- undefined, Variables and Constants, Additional for Loop Patterns, Return Values
- version control, Using Git-Using Git
- Version Control with Git (Loeliger), Using Git
- vi/vim text editor, The Tools
- visibility, Scope Versus Existence
- Visual Studio, The Tools
- void operator, void Operator
- Vue, Web Applications
W
- W3C website, Online Documentation
- WeakMap object, Maps and Sets, Dynamic Properties, Weak Maps
- WeakSet object, Maps and Sets, Weak Sets
- Web 2.0, Ajax
- web applications, Web Applications
- Web Development with Node and Express (Brown), Additional Resources
- web servers, Web Servers
- WHATWG, Online Documentation
- while loops, while Loops-Whitespace
- while statements, Metasyntax
- whitespace, Whitespace, switch Statements, Named Character Sets
- windowed editors, The Tools
- word boundaries (regexes), Word Boundary Matching
- word completion, The Tools
- write streams, Streams
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.