JavaScript Programming Beginner to Professional (BASIC + ADVANCE) GUIDE TO LEARN JAVASCRIPT IN 7 DAYS (Maurya, Rahul [Maurya, Rahul]) (Z-Library)
JavaScript
No Description
377
Views
5
Downloads
Registered users can read the full content for free
Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.
Page
1
(This page has no text content)
Page
2
(This page has no text content)
Page
3
(This page has no text content)
Page
4
Contents About ...................................................................................... ...................................................................................... ....... 1 Chapter 1: Getting started with JavaScript ...................................................................................... ............... 2 Section 1.1: Using console.log() ............................................................................................................... ...................... 2 Section 1.2: Using the DOM API ............................................................................................................... ..................... 4 Section 1.3: Using window.alert() ............................................................................................................... ................... 5 Section 1.4: Using window.prompt() ............................................................................................................... .............. 6 Section 1.5: Using window.confirm() ............................................................................................................... ............. 7 Section 1.6: Using the DOM API (with graphical text: Canvas, SVG, or image file) ................................................. 8 Chapter 2: JavaScript Variables ...................................................................................... ................................... 10
Page
5
Section 2.1: Defining a Variable ............................................................................................................... .................. 10 Section 2.2: Using a Variable ............................................................................................................... ...................... 10 Section 2.3: Types of Variables ............................................................................................................... ................... 10 Section 2.4: Arrays and Objects ............................................................................................................... ................. 11 Chapter 3: Built-in Constants ...................................................................................... .......................................... 12 Section 3.1: null ............................................................................................................... .............................................. 12 Section 3.2: Testing for NaN using isNaN() .............................................................................................................. 12 Section 3.3: NaN ............................................................................................................... ........................................... 13 Section 3.4: undefined and null ............................................................................................................... ................... 14 Section 3.5: Infinity and -Infinity ............................................................................................................... .................. 15 Section 3.6: Number constants ............................................................................................................... ................... 15 Section 3.7: Operations that return NaN
Page
6
............................................................................................................... .... 16 Section 3.8: Math library functions that return NaN ................................................................................................ 16 Chapter 4: Comments ...................................................................................... ........................................................ 17 Section 4.1: Using Comments ............................................................................................................... ...................... 17 Section 4.2: Using HTML comments in JavaScript (Bad practice) ........................................................................ 17 Chapter 5: Console ...................................................................................... ............................................................... 19 Section 5.1: Measuring time - console.time() ............................................................................................................ 22 Section 5.2: Formatting console output ............................................................................................................... ..... 23 Section 5.3: Printing to a browser's debugging console ......................................................................................... 24 Section 5.4: Including a stack trace when logging - console.trace() ..................................................................... 26 Section 5.5: Tabulating values - console.table() ...................................................................................................... 26 Section 5.6: Counting - console.count() ............................................................................................................... ..... 28 Section 5.7: Clearing the console - console.clear() .................................................................................................. 30
Page
7
Section 5.8: Displaying objects and XML interactively - console.dir(), console.dirxml() ...................................... 30 Section 5.9: Debugging with assertions - console.assert() ..................................................................................... 32 Chapter 6: Datatypes in JavaScript ...................................................................................... ........................... 33 Section 6.1: typeof ............................................................................................................... ........................................ 33 Section 6.2: Finding an object's class ............................................................................................................... ......... 34 Section 6.3: Getting object type by constructor name ............................................................................................ 34 Chapter 7: Strings ...................................................................................... ................................................................. 37 Section 7.1: Basic Info and String Concatenation ..................................................................................................... 37 Section 7.2: Reverse String ............................................................................................................... .......................... 38 Section 7.3: Comparing Strings Lexicographically ................................................................................................... 39 Section 7.4: Access character at index in string ....................................................................................................... 40 Section 7.5: Escaping quotes ............................................................................................................... ....................... 40 Section 7.6: Word Counter
Page
8
............................................................................................................... ........................... 41 Section 7.7: Trim whitespace ............................................................................................................... ....................... 41 Section 7.8: Splitting a string into an array .............................................................................................................. 41 Section 7.9: Strings are unicode ............................................................................................................... .................. 42 Section 7.10: Detecting a string ............................................................................................................... ................... 42 Section 7.11: Substrings with slice ............................................................................................................... ................ 43 Section 7.12: Character code ............................................................................................................... ....................... 43 Section 7.13: String Representations of Numbers .................................................................................................... 43 Section 7.14: String Find and Replace Functions ...................................................................................................... 44 Section 7.15: Find the index of a substring inside a string ....................................................................................... 45 Section 7.16: String to Upper Case ............................................................................................................... .............. 45 Section 7.17: String to Lower Case ............................................................................................................... .............. 46 Section 7.18: Repeat a String ............................................................................................................... ....................... 46
Page
9
Chapter 8: Date ...................................................................................... ..................................................................... 47 Section 8.1: Create a new Date object ............................................................................................................... ........ 47 Section 8.2: Convert to a string format ............................................................................................................... ..... 49 Section 8.3: Creating a Date from UTC ............................................................................................................... ...... 50 Section 8.4: Formatting a JavaScript date ............................................................................................................... 53 Section 8.5: Get the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC ................................. 55 Section 8.6: Get the current time and date ............................................................................................................... 55 Section 8.7: Increment a Date Object ............................................................................................................... ........ 56 Section 8.8: Convert to JSON ............................................................................................................... ...................... 57 Chapter 9: Date Comparison ...................................................................................... .......................................... 58 Section 9.1: Comparing Date values ............................................................................................................... ........... 58 Section 9.2: Date Di ☐erence Calculation
Page
10
............................................................................................................... ... 59 Chapter 10: Comparison Operations ...................................................................................... .......................... 60 Section 10.1: Abstract equality / inequality and type conversion ........................................................................... 60 Section 10.2: NaN Property of the Global Object ..................................................................................................... 61 Section 10.3: Short-circuiting in boolean operators ................................................................................................. 63 Section 10.4: Null and Undefined ............................................................................................................... ................ 65 Section 10.5: Abstract Equality (==) ............................................................................................................... ............ 65 Section 10.6: Logic Operators with Booleans ........................................................................................................... 66 Section 10.7: Automatic Type Conversions ............................................................................................................... 67 Section 10.8: Logic Operators with Non-boolean values (boolean coercion) ....................................................... 67 Section 10.9: Empty Array ............................................................................................................... ............................ 68 Section 10.10: Equality comparison operations ........................................................................................................ 68 Section 10.11: Relational operators (<, <=, >, >=) ........................................................................................................ 70 Section 10.12: Inequality ...............................................................................................................
Page
11
............................... 71 Section 10.13: List of Comparison Operators ............................................................................................................ 72 Section 10.14: Grouping multiple logic statements ................................................................................................... 72 Section 10.15: Bit fields to optimise comparison of multi state data ...................................................................... 72 Chapter 11: Conditions ...................................................................................... ........................................................ 74 Section 11.1: Ternary operators ............................................................................................................... ................... 74 Section 11.2: Switch statement ............................................................................................................... ..................... 75 Section 11.3: If / Else If / Else Control ............................................................................................................... .......... 77 Section 11.4: Strategy ............................................................................................................... .................................... 78 Section 11.5: Using || and && short circuiting ............................................................................................................. 79 Chapter 12: Arrays ...................................................................................... ................................................................ 80 Section 12.1: Converting Array-like Objects to Arrays ............................................................................................. 80
Page
12
Section 12.2: Reducing values ............................................................................................................... ..................... 82 Section 12.3: Mapping values ............................................................................................................... ...................... 84 Section 12.4: Filtering Object Arrays ............................................................................................................... ........... 84 Section 12.5: Sorting Arrays ............................................................................................................... ......................... 86 Section 12.6: Iteration ............................................................................................................... ................................... 88 Section 12.7: Destructuring an array ............................................................................................................... .......... 92 Section 12.8: Removing duplicate elements ............................................................................................................. 93 Section 12.9: Array comparison ............................................................................................................... .................. 93 Section 12.10: Reversing arrays ............................................................................................................... ................... 94 Section 12.11: Shallow cloning an array ............................................................................................................... ...... 95 Section 12.12: Concatenating Arrays ............................................................................................................... .......... 95 Section 12.13: Merge two array as key value pair .................................................................................................... 97 Section 12.14: Array spread / rest ...............................................................................................................
Page
13
............... 97 Section 12.15: Filtering values ............................................................................................................... ...................... 98 Section 12.16: Searching an Array ............................................................................................................... ............... 99 Section 12.17: Convert a String to an Array ............................................................................................................ 100 Section 12.18: Removing items from an array ........................................................................................................ 100 Section 12.19: Removing all elements ............................................................................................................... ....... 101 Section 12.20: Finding the minimum or maximum element .................................................................................. 102 Section 12.21: Standard array initialization ............................................................................................................. 103 Section 12.22: Joining array elements in a string .................................................................................................. 104 Section 12.23: Removing/Adding elements using splice() .................................................................................... 105 Section 12.24: The entries() method ............................................................................................................... ......... 105 Section 12.25: Remove value from array ............................................................................................................... . 105 Section 12.26: Flattening Arrays ............................................................................................................... ............... 106 Section 12.27: Append / Prepend items to Array ................................................................................................... 107 Section 12.28: Object keys and values to array ..................................................................................................... 107
Page
14
Section 12.29: Logical connective of values ........................................................................................................... 108 Section 12.30: Checking if an object is an Array .................................................................................................... 108 Section 12.31: Insert an item into an array at a specific index .............................................................................. 109 Section 12.32: Sorting multidimensional array ....................................................................................................... 109 Section 12.33: Test all array items for equality ...................................................................................................... 110 Section 12.34: Copy part of an Array ............................................................................................................... ....... 110 Chapter 13: Objects ...................................................................................... ............................................................ 112 Section 13.1: Shallow cloning ............................................................................................................... ...................... 112 Section 13.2: Object.freeze ............................................................................................................... ......................... 112 Section 13.3: Object cloning ............................................................................................................... ....................... 113 Section 13.4: Object properties iteration ............................................................................................................... .. 114 Section 13.5: Object.assign ............................................................................................................... ......................... 115 Section 13.6: Object rest/spread (...) ...............................................................................................................
Page
15
......... 116 Section 13.7: Object.defineProperty ............................................................................................................... .......... 116 Section 13.8: Accesor properties (get and set) ....................................................................................................... 117 Section 13.9: Dynamic / variable property names ................................................................................................ 117 Section 13.10: Arrays are Objects ............................................................................................................... .............. 118 Section 13.11: Object.seal ............................................................................................................... ............................ 119 Section 13.12: Convert object's values to array ...................................................................................................... 120 Section 13.13: Retrieving properties from an object ............................................................................................... 120 Section 13.14: Read-Only property ............................................................................................................... ............ 123 Section 13.15: Non enumerable property ............................................................................................................... . 123 Section 13.16: Lock property description ............................................................................................................... .. 123 Section 13.17: Object.getOwnPropertyDescriptor ................................................................................................... 124 Section 13.18: Descriptors and Named Properties ................................................................................................. 124 Section 13.19: Object.keys ............................................................................................................... .......................... 126 Section 13.20: Properties with special characters or reserved words .................................................................. 126 Section 13.21: Creating an Iterable object
Page
16
............................................................................................................... 127 Section 13.22: Iterating over Object entries - Object.entries() .............................................................................. 127 Section 13.23: Object.values() ............................................................................................................... .................... 128 Chapter 14: Arithmetic (Math) ...................................................................................... ..................................... 129 Section 14.1: Constants ............................................................................................................... ............................... 129 Section 14.2: Remainder / Modulus (%) ............................................................................................................... ... 129 Section 14.3: Rounding ............................................................................................................... ............................... 130 Section 14.4: Trigonometry ............................................................................................................... ........................ 132 Section 14.5: Bitwise operators ............................................................................................................... ................. 133 Section 14.6: Incrementing (++) ............................................................................................................... ................. 135 Section 14.7: Exponentiation (Math.pow() or **) ..................................................................................................... 135 Section 14.8: Random Integers and Floats ............................................................................................................. 136 Section 14.9: Addition (+)
Page
17
............................................................................................................... ........................... 137 Section 14.10: Little / Big endian for typed arrays when using bitwise operators .............................................. 137 Section 14.11: Get Random Between Two Numbers ............................................................................................... 138 Section 14.12: Simulating events with di ☐erent probabilities ................................................................................. 139 Section 14.13: Subtraction (-) ............................................................................................................... ..................... 140 Section 14.14: Multiplication (*) ............................................................................................................... .................. 140 Section 14.15: Getting maximum and minimum ..................................................................................................... 140 Section 14.16: Restrict Number to Min/Max Range ................................................................................................ 141 Section 14.17: Ceiling and Floor ............................................................................................................... ................. 141 Section 14.18: Getting roots of a number ............................................................................................................... . 142 Section 14.19: Random with gaussian distribution ................................................................................................. 142 Section 14.20: Math.atan2 to find direction ............................................................................................................ 143 Section 14.21: Sin & Cos to create a vector given direction & distance ............................................................... 143 Section 14.22: Math.hypot ............................................................................................................... .......................... 144 Section 14.23: Periodic functions using Math.sin .................................................................................................... 145 Section 14.24: Division (/)
Page
18
............................................................................................................... .......................... 146 Section 14.25: Decrementing (--) ............................................................................................................... .............. 146 Chapter 15: Bitwise operators ...................................................................................... ...................................... 148 Section 15.1: Bitwise operators ............................................................................................................... .................. 148 Section 15.2: Shift Operators ............................................................................................................... ..................... 150 Chapter 16: Constructor functions ...................................................................................... ............................. 151 Section 16.1: Declaring a constructor function ........................................................................................................ 151 Chapter 17: Declarations and Assignments ...................................................................................... .......... 152 Section 17.1: Modifying constants ............................................................................................................... ............. 152 Section 17.2: Declaring and initializing constants .................................................................................................. 152 Section 17.3: Declaration ...............................................................................................................
Page
19
............................ 152 Section 17.4: Undefined ............................................................................................................... .............................. 153 Section 17.5: Data Types ............................................................................................................... ............................ 153 Section 17.6: Mathematic operations and assignment .......................................................................................... 153 Section 17.7: Assignment ............................................................................................................... ............................ 155 Chapter 18: Loops ...................................................................................... ............................................................... 156 Section 18.1: Standard "for" loops ............................................................................................................... ............. 156 Section 18.2: "for ... of" loop ............................................................................................................... ....................... 157 Section 18.3: "for ... in" loop ............................................................................................................... ........................ 159 Section 18.4: "while" Loops ............................................................................................................... ........................ 159 Section 18.5: "continue" a loop ............................................................................................................... .................. 160 Section 18.6: Break specific nested loops ............................................................................................................... 161 Section 18.7: "do ... while" loop
Page
20
............................................................................................................... ................... 161 Section 18.8: Break and continue labels ............................................................................................................... .. 161 Chapter 19: Functions ...................................................................................... ....................................................... 163 Section 19.1: Function Scoping ............................................................................................................... ................... 163 Section 19.2: Currying ............................................................................................................... ................................. 164 Section 19.3: Immediately Invoked Function Expressions ..................................................................................... 165 Section 19.4: Named Functions ............................................................................................................... ................. 166 Section 19.5: Binding `this` and arguments ............................................................................................................. 169 Section 19.6: Functions with an Unknown Number of Arguments (variadic functions) ..................................... 171 Section 19.7: Anonymous Function ............................................................................................................... ........... 172 Section 19.8: Default parameters ............................................................................................................... ............. 174 Section 19.9: Call and apply ............................................................................................................... ....................... 176 Section 19.10: Partial Application
The above is a preview of the first 20 pages. Register to read the complete e-book.
AI Reading Assistant
Whole-book reading guide from stratified index samples; jump to passages in the text
AI guide
# JavaScript Programming: Beginner to Professional (BASIC + ADVANCE) GUIDE TO LEARN JAVASCRIPT IN 7 DAYS
## 【One-Line Pitch】
A fast-paced, hands-on JavaScript crash course that walks complete beginners from their first `console.log()` through DOM manipulation and browser APIs—all structured around a 7-day learning plan. Ideal for absolute newcomers who want immediate, practical coding experience rather than deep computer science theory.
## 【Book Arc】
- **Opening (~0%–4%)**: Getting started with JavaScript—covers the absolute basics of running your first scripts using `console.log()`, the DOM API, and browser dialog methods like `window.alert()`, `window.prompt()`, and `window.confirm()`. This stage solves the "where do I even type code?" problem for true beginners.
- **Early (~4%–11%)**: JavaScript variables and fundamental syntax—defines how to declare, assign, and use variables, introducing the core building blocks of the language. Also covers comments (including a warning against using HTML comments in JavaScript, flagged as bad practice).
- **Early (~11%–25%)**: Console mastery—a deep dive into the browser's debugging console, covering time measurement with `console.time()`, output formatting, stack traces via `console.trace()`, tabular data with `console.table()`, counting with `console.count()`, and clearing with `console.clear()`. This section treats the console as a serious development tool, not just a print statement.
- **Middle (~25%–50%)**: Advanced console techniques and beyond—continues building on debugging and output practices, transitioning toward more sophisticated JavaScript usage as the 7-day plan progresses.
- **Late (~50%–75%)**: Advanced JavaScript concepts—the "ADVANCE" portion of the book kicks in, moving beyond beginner syntax into more complex language features and patterns.
- **Ending (~75%–100%)**: Professional-level JavaScript—wraps up with the most advanced topics, aiming to bring readers from novice to "professional" level within the 7-day framework.
## 【Key Takeaways】
- **Start with the browser console** (Opening): The book's first practical step is running JavaScript in the browser's debugging console, giving instant feedback without needing a complex development environment. This lowers the barrier to entry for complete beginners.
- **Master the DOM API early** (Opening): Direct manipulation of page elements is introduced as a core skill from day one, showing readers how JavaScript interacts with HTML—a fundamental concept for any web developer.
- **Browser dialogs are beginner-friendly tools** (Opening): `alert()`, `prompt()`, and `confirm()` provide simple, visual ways to interact with users before learning more sophisticated UI techniques. These are stepping stones, not production patterns.
- **Variables are the foundation of JavaScript** (Early): The book dedicates a full chapter to variable declaration and usage, emphasizing that understanding data storage is prerequisite to everything else in the language.
- **Comments matter—but use the right syntax** (Early): The book explicitly warns against using HTML comments (`<!-- -->`) inside JavaScript, a common beginner mistake that can cause silent bugs. This attention to bad practices is valuable for self-taught learners.
- **The console is a full debugging toolkit** (Early): Beyond simple logging, the book covers `console.time()`, `console.trace()`, `console.table()`, `console.count()`, and `console.clear()`—turning the console into a comprehensive development instrument. This is practical knowledge that many intermediate developers still lack.
- **Formatting console output improves readability** (Early): Learning to structure and format debug output is presented as a professional skill, not an afterthought—useful for maintaining sanity in real projects.
## 【Reading Tips】
- **Skim the table of contents first**: The book is structured as a 7-day plan with clear section headers. Use the TOC to plan which chapters to tackle each day and track your progress.
- **Code along actively**: Every section is built around executable examples. Open your browser's developer tools (F12) and type every example yourself—don't just read. The book is designed for hands-on learning.
- **Deep-read the console chapter**: The console techniques (Chapter 5) are the most universally useful content in the early sections. Master `console.table()` and `console.time()`—they'll serve you in every future JavaScript project.
- **Pay attention to "bad practice" warnings**: The book explicitly flags anti-patterns like HTML comments in JavaScript. These warnings are gold for avoiding bugs that plague self-taught developers.
- **Don't rush the 7-day schedule**: If a day's material feels overwhelming, take an extra day. The structure is a guide, not a strict deadline—retention matters more than speed.
## 【Coverage Limits】
The excerpts primarily cover the book's opening chapters (getting started, variables, and console techniques) plus the table of contents. The advanced JavaScript topics promised in the title (the "ADVANCE" and "professional" sections) are not detailed in the available material, so this guide cannot assess their depth or quality.
##
Passage locations
Excerpt 1
书名: Understanding Generative AI Business Applications A Guide to Technical Principles and Real-World Applications (Irena Cronin) (Z-Library) 作者: Irena Cronin...
View in text
Excerpt 2
responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained here...
View in text
Recommended for You
{{#thumbnailUrl}}
{{/thumbnailUrl}}
{{^thumbnailUrl}}
{{/thumbnailUrl}}
Loading recommended books...
Failed to load, please try again later
Tip the Site
Scan the WeChat Pay or Alipay code to tip. No login required.
WeChat Pay
Alipay