Object-Oriented Javascript

PDF
Stoyan Stefanov

Scan to Download
 Object-Oriented Javascript
Master JavaScript through hands-on coding and
practical exercises.
Written by Bookey
Check more about Object-Oriented Javascript Summary
Listen Object-Oriented Javascript Audiobook

Scan to Download
About the book
This book serves as a comprehensive guide to object-oriented
programming in JavaScript, starting with foundational
concepts and progressing to advanced techniques.
Emphasizing a hands-on approach, readers are encouraged to
actively write and experiment with code using Firebug's
console, fostering a deeper understanding of the language.
Each chapter concludes with practice questions designed to
reinforce learning and encourage exploration. Aimed at both
new and intermediate JavaScript developers, this book equips
readers with the skills to tackle web development challenges
using intelligent JavaScript solutions.

Scan to Download
About the author
Stoyan Stefanov is a distinguished web developer, author, and
speaker known for his expertise in JavaScript and
object-oriented programming. With a strong background in
front-end development, he has worked on various projects for
leading tech companies and has contributed significantly to the
open-source community. Stefanov is passionate about sharing
his knowledge through his writings and has authored several
influential books, including "Object-Oriented JavaScript,"
which offers deep insights into JavaScript's object-oriented
capabilities and best practices. His work emphasizes the
importance of clean, maintainable code and the principles of
modern web development, making him a valuable resource for
developers seeking to enhance their skills in JavaScript
programming.

Scan to Download
Summary Content List
Chapter 1 : JavaScript

Chapter 2 : Data Types, Arrays, Loops, and Conditions

Chapter 3 :

Chapter 4 :

Chapter 5 :

Chapter 6 :

Chapter 7 : Browser Environment

Chapter 8 : and Design Patterns

Chapter 9 : Appendix A:Reserved Words

Chapter 10 : Appendix B:Built-in Functions

Chapter 11 : Appendix C:Built-in Objects

Chapter 12 : Appendix D:Regular Expressions

Scan to Download
 Chapter 1 Summary : JavaScript

Section Summary

Introduction to JavaScript has evolved from simple HTML scripts to a vital programming language for dynamic
JavaScript web applications, linking HTML, CSS, and behavior.

History of JavaScript Developers needed dynamic interactions on static pages, leading to the creation of JavaScript and
standards like ECMAScript for consistency across browsers.

Browser Wars The conflict between Netscape and Microsoft resulted in inconsistent JavaScript features, causing
developers to hesitate in using the language.

Post-Wars Renaissance The end of the Browser Wars led to standardization, improved usability, and notable web
applications like Gmail showcasing JavaScript's capabilities.

Current State of JavaScript is now used in various environments like browsers, servers, mobile apps, and has gained
JavaScript significant investment from browser vendors.

The Future of JavaScript JavaScript's future is bright with ongoing enhancements and the emergence of new applications,
solidifying its role in development.

ECMAScript 5 ES5 introduced important features like "strict mode" for safer coding by eliminating deprecated
features and enforcing best practices.

Object-Oriented Key OOP concepts include Objects, Classes, Encapsulation, Aggregation, Inheritance, and
Programming Concepts Polymorphism as foundational programming principles.

Setting Up Your Instructions for setting up a JavaScript development environment using browser consoles and
Environment interpreters like JavaScriptCore.

Conclusion The chapter stresses the importance of understanding JavaScript and OOP principles as a
foundation for advanced programming skills and job preparation.

Scan to Download
Summary of Chapter 1: Object-Oriented JavaScript

Introduction to JavaScript

- JavaScript has evolved from simple embedded scripts in

HTML to a robust programming language integral to
dynamic web applications.
- It acts as the binding agent for HTML (content), CSS
(presentation), and JavaScript (behavior).

History of JavaScript

- Initially, the web was composed mainly of static pages.

Developers needed a way to create dynamic interactions,
leading to the creation of JavaScript (previously LiveScript).
- The introduction of standards like ECMAScript
(ECMA-262) aimed to unify the different implementations of
JavaScript across browsers.

Browser Wars

- The rapid growth of JavaScript popularity coincided with

fierce competition between Netscape and Microsoft, leading

Scan to Download
to inconsistent provisions of JavaScript across browsers.
- This inconsistency caused many developers to shy away
from using JavaScript, seeing it as unreliable.

Post-Wars Renaissance

- The decline of the Browser Wars led to the adoption of web

standards and a focus on usability and accessibility.
- New applications like Gmail and Google Maps
demonstrated JavaScript's potential for rich web experiences,
boosting its reputation.

Current State of JavaScript

- JavaScript can be utilized across various environments: web

browsers, server-side platforms (e.g., Node.js, .NET), mobile
applications, command-line interfaces, and desktop
applications.
- The language has become ubiquitous, leading to increased
investment in its capabilities by browser vendors.

The Future of JavaScript

- JavaScript's future appears promising with ongoing

Scan to Download
enhancements and new applications emerging, ensuring its
place in web and software development.

ECMAScript 5

- Revision 5 (ES5) introduced important concepts like "strict

mode," which allows for safer coding by excluding
deprecated features and ensuring the enforcement of proper
coding practices.

Object-Oriented Programming Concepts

- Basic OOP concepts introduced include Objects, Classes,

Encapsulation, Aggregation, Inheritance, and Polymorphism:
-
Objects
: Representations of real-world entities.
-
Classes
: Blueprints for creating objects.
-
Encapsulation
: Bundling data and the methods that operate on that data.
-

Scan to Download
Aggregation
: Combining objects to create complex structures.
-
Inheritance
: Deriving new classes from existing ones.
-
Polymorphism
: Allowing the same method to behave differently based on
the object it is called upon.

Setting Up Your Environment

- The chapter concludes with instructions on how to set up a

JavaScript development environment using browser consoles
and JavaScript interpreters like JavaScriptCore on Macs.

Conclusion

- The initial chapter emphasizes that understanding

JavaScript and object-oriented principles lays a foundation
for more advanced programming concepts covered in the
subsequent chapters, preparing the reader for practical
application and potential job interviews in web development.

Scan to Download
 Chapter 2 Summary : Data Types,
Arrays, Loops, and Conditions

Section Key Points

Introduction Covers fundamentals of JavaScript: variables, primitive data types, arrays, loops, conditions.

Variables

Placeholders for data, modifiable.

Declared using `var`, can initialize in one line.
Naming conventions: letters, numbers, underscores, dollar signs (not starting with a
number).
Case-sensitive.

Operators

Types: Arithmetic, Increment/Decrement, Assignment, Logical, Comparison.

End expressions with semicolon for clarity.

Primitive Data Types

Number: integers, floats, special cases.

String: sequence of characters in quotes.
Boolean: `true` or `false`.
Undefined: declared variable without value.
Null: assigned value representing 'no value'.

Type Checking Use `typeof` operator to determine variable type.

Arrays

Holds multiple values, defined with square brackets.

Scan to Download
Section Key Points

Accessed by index (starts at 0).

Can modify, delete, or nest arrays.

Conditions and Control

Flow
if-else Statements: control flow based on conditions.
Switch Statements: alternative to multiple `if-else` statements.
Loops: while, do-while, for, for-in.

Best Practices Proper indentation, define variables at top of functions, avoid global pollution.

Summary Establishes foundational knowledge for JavaScript programming.

Exercises Included to reinforce understanding of concepts.

Chapter 2 Summary: Primitive Data Types, Arrays,

Loops, and Conditions

Introduction to JavaScript Basics

This chapter covers fundamental concepts in JavaScript,

including variables, primitive data types, arrays, loops, and
conditions essential for building JavaScript applications.

Variables

-
Definition

Scan to Download
: Variables act as placeholders for data and can be modified
after their initial assignment.
-
Declaration and Initialization
: Use the `var` statement to declare, and you can declare and
initialize in one line.
-
Naming
: Variables can use letters, numbers, underscores, and dollar
signs but cannot start with a number.
-
Case Sensitivity
: Variable names are case-sensitive.

Operators

-
Types of Operators
:
-
Arithmetic
: `+`, `-`, `*`, `/`, `%`
-
Increment/Decrement

Scan to Download
: `++`, `--`
-
Assignment
: `=`, `+=`, `-=`, etc.
-
Logical
: `!`, `&&`, `||`
-
Comparison
: `==`, `===`, `!=`, `!==`, `<`, `>`, `<=`, `>=`
- Always conclude expressions with a semicolon for clarity,
despite JavaScript's automatic semicolon insertion.

Primitive Data Types

1.
Number
: Includes integers and floats, with special cases for `NaN`,
`Infinity`, and `-Infinity`.
2.
String
: Any sequence of characters defined by single or double
quotes.
3.

Scan to Download
Boolean
: Represents `true` or `false`.
4.
Undefined
: Represents a declared variable without a value.
5.
Null
: An assigned value representing 'no value'.

Type Checking
: Use the `typeof` operator to determine a variable's type.

Arrays

- Arrays can hold multiple values and are defined using

square brackets.
- Access elements by their index, which starts at 0.
- You can modify, delete, or nest arrays within arrays.

Conditions and Control Flow

-
if-else Statements
: Control program flow based on conditions.

Scan to Download
-
Switch Statements
: An alternative to multiple `if-else` statements, using a
single variable to determine which block of code to execute.
-
Loops
:
-
while
: Executes code while a condition is true.
-
do-while
: Similar to `while`, but ensures code runs at least once.
-
for
: A more powerful loop supporting initialization, condition,
and increment.
-
for-in
: Iterates over properties of an object (mostly suited for
objects, not arrays).

Best Practices
: Use proper indentation, define variables at the top of

Scan to Download
functions, and avoid global variable pollution.

Summary
: This chapter established foundational knowledge necessary
for mastering JavaScript, focusing on variable declarations,
primitive data types, and control structures fundamental for
programming tasks.

Exercises
: Included to solidify understanding of concepts discussed in
the chapter.

Scan to Download
Chapter 3 Summary :

Functions in JavaScript

Functions are a crucial part of JavaScript programming and

are used for various purposes. This chapter focuses on the
following key topics:
-
Definition and Usage
: Understanding how to define and use functions.
-
Function Parameters
: How to pass arguments to functions.
-
Built-in Functions
: Predefined functions available in JavaScript.
-
Variable Scope
: Exploring variable scope within functions.
-
Functions as Data
: Recognizing functions as a special type of data.
Understanding these concepts lays the groundwork for more

Scan to Download
advanced applications of functions, including:
-
Anonymous Functions
: Functions without a name.
-
Callback Functions
: Functions passed as arguments to other functions.
-
Immediate Functions
: Functions that execute automatically.
-
Inner Functions
: Functions defined within other functions.
-
Functions Returning Functions
: Higher-order functions that return other functions.
-
Self-Rewriting Functions
: Functions that can redefine themselves.
-
Closures
Install that
: Functions Bookey App to
have access tovariables
UnlockfromFulltheir
Text and
containing scope. Audio

Scan to Download
 Chapter 4 Summary :
Section Summary

Introduction to Objects This chapter explores objects, building on previous knowledge of JavaScript's primitive
types, arrays, and functions.

From Arrays to Objects Distinguishes arrays as indexed lists of values and objects as user-defined key/value pairs.

Creating and Accessing Objects Objects are defined with `{}` and properties are accessed via dot notation or bracket
notation.

Object Literals and Key Quoting Keys in objects can be quoted, essential for reserved words or special characters.

Properties and Methods Objects consist of properties (values or methods), with examples of methods included.

Associative Arrays vs. Indexed Objects function as associative arrays or hashes, while standard arrays are indexed.
Arrays

Accessing and Modifying Properties are easily accessible and modifiable, including adding or deleting them.
Properties

Constructor Functions Constructor functions aid in object creation, with a customary naming convention of
capitalizing the first letter.

Global Object The global object varies across contexts and holds global variables without declaration.

Working with Objects The `this` keyword helps access object properties within methods.

Prototypes and Inheritance Every function has a prototype enabling inheritance, allowing shared properties among
instances.

Constructor Property and Each object contains a constructor property and the `instanceof` operator checks object
instanceof Operator types.

Built-in Objects JavaScript offers built-in objects enhancing functionality, such as `Object`, `Array`, and
others stated.

Conclusion Mastering JavaScript objects is essential for effective programming due to their data
encapsulation and manipulation methods.

Exercises Exercises encourage hands-on exploration of chapter concepts, including defining

constructors and object methods.

Summary of Chapter 4: Objects

Introduction to Objects

Scan to Download
- After learning about JavaScript's primitive types, arrays,
and functions, this chapter delves into objects.
- Key learning points include creating and utilizing objects,
understanding constructor functions, and exploring built-in
JavaScript objects.

From Arrays to Objects

- Arrays are lists of values indexed numerically, whereas

objects consist of user-defined keys with key/value pairs.
- Example:
```javascript
var myarr = ['red', 'blue', 'yellow', 'purple'];
var hero = { breed: 'Turtle', occupation: 'Ninja' };
```

Creating and Accessing Objects

- Objects use `{}` for definition and can contain properties

that may be functions (methods).
- Properties can be accessed using dot notation
`hero.occupation` or bracket notation `hero['occupation']`.

Scan to Download
Object Literals and Key Quoting

- Keys can be wrapped in quotes, especially if they are

reserved words, contain spaces, or special characters.
Examples of valid and invalid object declarations are
provided.

Properties and Methods

- Objects contain properties; properties may contain values or

functions (methods).
- Illustrative example of methods integrated into objects is
provided.

Associative Arrays vs. Indexed Arrays

- JavaScript uses objects as associative arrays or hashes,

while regular arrays are indexed.

Accessing and Modifying Properties

- Properties can be accessed and modified easily, including

adding new properties or deleting existing ones.

Scan to Download
Constructor Functions

- Constructor functions facilitate object creation, allowing for

parameters and methods.
- Best practice involves capitalizing the first letter of
constructor functions.

Global Object

- The global object varies by context (e.g., `window` in

browsers) and contains global variables accessible without
declaration.

Working with Objects

- The `this` keyword within methods refers to the object

itself, helping to access its properties.
- Constructor functions can create instanced objects and their
constructors.

Prototypes and Inheritance

- Every function has a prototype property, crucial for

implementing inheritance.

Scan to Download
- Properties can be shared among all instances through the
prototype.

Constructor Property and `instanceof` Operator

- Each object has a `constructor` property referring back to

the function that created it.
- The `instanceof` operator determines whether an object
belongs to a specific constructor's type.

Built-in Objects

- JavaScript provides built-in objects (e.g., `Object`, `Array`,

`Function`, `Date`, `RegExp`, `Math`) that enhance
functionality.
- Example of creating a date object and methods of
manipulating dates are discussed.

Conclusion

- Understanding JavaScript objects is pivotal for effective

programming, as they encapsulate data and provide methods
to manipulate that data.

Scan to Download
Exercises

- Exercises at the end prompt engagement with the contents

of the chapter, encouraging experimentation with concepts
learned, including defining constructors, extending objects,
and exploring methods.
This chapter sets the groundwork for utilizing objects in
JavaScript, emphasizing their importance and versatility.

Scan to Download
Example
Key Point:Understanding and utilizing objects
optimally enhances your programming efficiency
and data management skills.
Example:Imagine you're building an application to
manage a library. Instead of creating separate variables
for each book's title, author, and publication year, you
create a book object. With its properties and methods,
like `book.addCopy()` to increase the number of copies
or `book.getDetails()` to retrieve information, you
efficiently manage the data structure. This way, you not
only keep your code organized but also leverage
JavaScript’s powerful object-oriented capabilities for
better functionality.

Scan to Download
Critical Thinking
Key Point:Understanding constructor functions in
JavaScript is fundamental for efficient object
creation.
Critical Interpretation:While the chapter emphasizes
constructor functions as essential tools for
object-oriented programming, it is crucial to
acknowledge that relying solely on this approach can
lead to complexities and potential misuses in JavaScript.
Critics argue that using alternative patterns, such as
factory functions, could offer better flexibility and
simplicity in certain situations (e.g., see 'JavaScript: The
Good Parts' by Douglas Crockford). Consequently,
developers should explore various methodologies to
create objects, ensuring their designs best meet the
application's needs.

Scan to Download
Chapter 5 Summary :

Prototype Overview

In this chapter, we learn about the prototype property of

function objects in JavaScript, a core concept of its
prototype-based object model. Understanding prototypes is
crucial for deeper comprehension of JavaScript.

Key Topics Covered:

- Every function has a prototype property, which is an object.

- You can add properties and methods to the prototype object.
- Distinction between own properties and prototype
properties.
- The `__proto__` property connects every object to its
prototype.
- Methods: `isPrototypeOf()`, `hasOwnProperty()`, and
`propertyIsEnumerable()`.
- Risks of enhancing built-in objects like arrays or strings.

The Prototype Property

Scan to Download
- Functions in JavaScript are objects with properties such as
prototype, length, and constructor.
- The prototype is initially an empty object, which you can
augment with methods and properties.
- Example:
```javascript
function foo() {}
console.log(typeof foo.prototype); // "object"
```

Adding Methods and Properties

- You can define a constructor function and add

properties/methods to its prototype.
- Example:
```javascript
function Gadget(name, color) {
this.name = name;
this.color = color;
}
Gadget.prototype.price = 100;
Gadget.prototype.getInfo = function() { return this.name + '
costs ' + this.price; };
```

Scan to Download
Using Prototype Properties

- Properties and methods added to the prototype are

accessible in instances of the constructor.
- Modifications to the prototype are "live," meaning existing
instances will reflect any changes made subsequently.

Own Properties vs. Prototype Properties

- If an object has its own property, it overrides the prototype

property of the same name.
- The `hasOwnProperty()` method checks whether a property
belongs to the object directly.

Enumerating Properties

- The `for-in` loop can enumerate properties of an object,

capturing both own and prototype properties.
- Use `hasOwnProperty()` to filter only the object's own
properties.
- Property visibility in a loop depends on whether they are
enumerable.

Scan to Download
isPrototypeOf() Method

- This method checks whether a specific object is a prototype

of another object.
- Example:
```javascript
var monkey = { feeds: 'bananas' };
function Human(name) { this.name = name; }
Human.prototype = monkey;
var george = new Human('George');
console.log(monkey.isPrototypeOf(george)); // true
```

The Secret __proto__ Link

- The `__proto__` property provides access to an object's

prototype, allowing inspection of the prototype chain—but
use it cautiously for cross-browser compatibility.

Augmenting Built-in Objects

- You can extend built-in constructor functions through

prototypes, e.g., adding methods to `Array.prototype`.
- Care should be taken to avoid conflicts with potential future

Scan to Download
standard methods.

Best Practices and Prototype Gotchas

- Always check for existing properties/methods before

augmenting prototypes.
- When the prototype is replaced, existing instances still
reference the old prototype unless the constructor is
explicitly set again.

Summary

- Functions have a prototype property pointing to an object.

- You can enhance the prototype to add functionalities
available to all instances.
- Understanding the prototype chain is crucial for effective
JavaScript programming.
- Exercise caution when altering built-in prototypes to avoid
unexpected behavior in your code.

Exercises

1. Create a `shape` object with a type property and a

`getType()` method.

Scan to Download
2. Define a `Triangle()` constructor that inherits from
`shape`.
3. Add a `getPerimeter()` method to the prototype.
4. Confirm the functionality using various test cases.
5. Loop through an instance to show own properties and
methods.
6. Implement a `shuffle` method for arrays.
This provides a succinct overview of the concepts discussed
in the chapter while retaining critical details.

Scan to Download
Critical Thinking
Key Point:The importance of prototypes in
JavaScript object-oriented programming.
Critical Interpretation:While the chapter emphasizes that
prototypes are foundational to understanding
JavaScript's design pattern, one must question if this
prototype-based model is truly more advantageous than
traditional class-based systems used in other
programming languages. Critics often argue that
JavaScript’s prototype inheritance can lead to confusion,
particularly for developers transitioning from
class-oriented languages (see sources like 'Eloquent
JavaScript' by Marijn Haverbeke). Understanding
prototypes is undoubtedly valuable, but it's essential to
acknowledge the potential pitfalls and complexity they
introduce, which can be mitigated by alternative
approaches.

Scan to Download
Chapter 6 Summary :

6. Inheritance in JavaScript

Overview of Inheritance

- Inheritance allows code reuse and promotes efficient

programming by enabling new objects to inherit properties
and methods from existing objects.
- JavaScript employs several patterns for implementing
inheritance, primarily through prototype chaining.

Prototype Chaining

- Each function in JavaScript has a `prototype` property,

which points to an object. When a function is invoked with
the `new` operator, a new object is created that links to the
function’s prototype.
- This creates a prototype chain that allows newly created
objects to access properties and methods from ancestor
objects down the chain.

Scan to Download
Constructor Functions and Inheritance

- To create an inheritance hierarchy, define constructor

functions such as `Shape`, `TwoDShape`, and `Triangle`.
- For example, `TwoDShape.prototype = new Shape();` sets
up inheritance from the `Shape` constructor to `TwoDShape`.

Accessing Properties

- When an object does not have its own property, JavaScript

looks up the prototype chain to find the property in ancestor
objects.
- Using the `instanceof` operator can verify if an object is an
instance of a particular constructor.

Moving Shared Properties to the Prototype

- Shared properties (such as methods) can be added to the

prototype rather than being defined in the constructor to
increase memory efficiency.
- Own properties that vary between instances should be
Install
defined Bookey
directly in the App to Unlock Full Text and
constructor.
Audio
Patterns for Inheritance

Scan to Download
Chapter 7 Summary : Browser
Environment

The Browser Environment

JavaScript requires a host environment, and the browser is

the most common and relevant one for its applications. This
chapter will cover key components essential for
understanding JavaScript's functionality within the browser.

Key Elements Covered:

- The Browser Object Model (BOM)

- The Document Object Model (DOM)
- Browser events
- The XMLHttpRequest object

Including JavaScript in an HTML Page

To incorporate JavaScript into an HTML document, the

`<script>` tag is utilized. Here’s an example:
```html

Scan to Download
<!DOCTYPE>
<html>
<head>
<title>JS test</title>
<script src="somefile.js"></script>
</head>
<body>
<script>
var a = 1;
a++;
</script>
</body>
</html>
```

Scan to Download
Chapter 8 Summary : and Design
Patterns

Coding and Design Patterns

In this chapter, we explore common JavaScript patterns that

help solve recurring programming challenges. A pattern is
essentially a reliable solution to specific problems you may
encounter. Recognizing such patterns enables clearer
communication and thought processes when tackling similar
issues in a team environment. It is essential to note that
simply applying a pattern without appropriate context may
lead to ineffective solutions.

Types of Patterns

This chapter discusses two primary types of patterns:

-
Coding Patterns:
These are tailored best practices specific to JavaScript.
-
Design Patterns:

Scan to Download
 These are broader, language-independent solutions, widely
referenced from the "Gang of Four" book.

JavaScript-Specific Patterns

The chapter delves into several patterns reflecting

JavaScript's unique characteristics, including:
-
Separating Behavior:
This pattern emphasizes the importance of keeping the
content (HTML), presentation (CSS), and behavior
(JavaScript) distinct to enhance code organization and
maintenance.
-
Content:
Should utilize semantic HTML tags appropriately, avoiding
presentational elements.

-
Presentation:
CSS should handle all visual formatting without embedding
styles in HTML.

Scan to Download
Behavior:
JavaScript should be kept separate from both content and
presentation, typically contained within external files.
-
Examples of best practices include:

- Namespaces
- Init-time branching
- Lazy definitions
- Configuration objects
- Private variables and methods
- Privileged methods
- Private functions as public methods
- Immediate functions
- Chaining
- JSON
Ultimately, effective use of these patterns can lead to cleaner,
more efficient code, making development more manageable
and collaborative.

Scan to Download
Critical Thinking
Key Point:Misapplication of Patterns
Critical Interpretation:While recognizing and applying
coding and design patterns can indeed foster clearer
communication and improve code quality, the author's
assertion regarding their effectiveness should be
approached cautiously. Patterns may not be universally
applicable; without proper context, they can lead to
convoluted solutions. For instance, the principle of
separation of concerns, though fundamental, can
sometimes create unnecessary complexity if not
balanced with an understanding of the specific project
requirements. Critics like Martin Fowler emphasize that
patterns are not silver bullets, and their success is highly
context-dependent (Fowler, M. "Patterns of Enterprise
Application Architecture"). Thus, while Stefanov's
insights offer valuable guidelines, developers should
critically evaluate when and how to apply these patterns
to avoid pitfalls.

Scan to Download
Chapter 9 Summary : Appendix
A:Reserved Words

Reserved Words in ECMAScript 5 (ES5)

This section details the reserved keywords in ECMAScript 5,

including current, future, and previously reserved words.

Current Reserved Words

The following words are currently reserved in ES5 and

cannot be used as variable names:
- break
- delete
- case
- catch
- continue
- debugger
- default
- do
- else
- finally

Scan to Download
- for
- function
- if
- in
- instanceof
- new
- return
- switch
- this
- throw
- try
- typeof
- var
- void
- while
- with

Future Reserved Words

These keywords are reserved for future implementations but

are not in use yet:
Install Bookey App to Unlock Full Text and
- class
- const Audio
- enum

Scan to Download
Chapter 10 Summary : Appendix
B:Built-in Functions

Built-in Functions

This section outlines various built-in functions in JavaScript,

each serving specific purposes as discussed in Chapter 3.

parseInt()

- Converts input to an integer representation, requiring two

parameters: the input object and the radix.
- Default radix is 10; omitting it may lead to unexpected
results.
- Example:
- `parseInt('10e+3'); // returns 10`
- `parseInt('FF', 16); // returns 255`

parseFloat()

- Converts input to a floating-point number, supporting

exponent notation.

Scan to Download
- Example:
- `parseFloat('10e+3'); // returns 10000`
- `parseFloat('123.456test'); // returns 123.456`

isNaN()

- Determines if the input is not a valid number.

- Attempts conversion before evaluation.
- Example:
- `isNaN(NaN); // returns true`
- `isNaN(123); // returns false`

isFinite()

- Checks if the input is a finite number and not Infinity or

-Infinity.
- Returns false for non-numeric values or infinity.
- Example:
- `isFinite(-Infinity); // returns false`
- `isFinite("123"); // returns true`

encodeURIComponent()

- Encodes a URI component, transforming characters into a

Scan to Download
string suitable for URL inclusion.
- Example:
- `encodeURIComponent('http://phpied.com/'); // returns
"http%3A%2F%2Fphpied.com%2F"`

decodeURIComponent()

- Decodes a URL-encoded string back to its original form.

- Example:
- `decodeURIComponent('%20%40%20'); // returns " @"`

encodeURI()

- Encodes a complete URI, excluding the protocol and

hostname.
- Example:
- `encodeURI('http://phpied.com/'); // returns
"http://phpied.com/"`

decodeURI()

- Reverts the encoding performed by encodeURI().

- Example:
- `decodeURI("some%20script?key=v@lue"); // returns

Scan to Download
"some script?key=v@lue"`

eval()

- Executes a string of JavaScript code.

- Generally advised against due to potential security risks.
- Example:
- `eval('1 + 2'); // returns 3`
- `eval('new Array(1, 2, 3); 1 + 2;'); // returns 3`

Scan to Download
Chapter 11 Summary : Appendix
C:Built-in Objects

Built-in Objects Overview

This section summarizes the various built-in constructor

functions defined in the ECMAScript (ES) standard,
alongside their properties and methods.

Object Constructor

- The `Object()` constructor creates objects. Usage:

```javascript
var o = new Object(); // same as var o = {};
```
- Inheritance: All objects, whether built-in or user-defined,
inherit from `Object`.

Properties and Methods of Object

| Property/Method | Description |
|---------------------------|-------------|

Scan to Download
| `Object.prototype` | The prototype of all objects.
Modifications here affect all objects. |
| `constructor` | Refers back to the constructor
function of the object. |
| `toString(radix)` | Returns a string representation of the
object. If it's a number, the radix dictates the base. |
| `toLocaleString()` | Similar to `toString()`, but
localized. Typically overridden in other objects (e.g., Date,
Number, and Array). |
| `valueOf()` | Returns a primitive representation or
the object itself if none is applicable. |
| `hasOwnProperty(prop)` | Checks if a property is an own
property or inherited. |
| `isPrototypeOf(obj)` | Checks if the object is used as a
prototype for another object. |
| `propertyIsEnumerable(prop)` | Checks if a property is
enumerable in a for-in loop. |

ECMAScript 5 Enhancements

Property Descriptors

- Introduces `defineProperty()` and `defineProperties()`

Scan to Download
allowing fine control over property characteristics.
- Attributes include:
- `value`: The property value.
- `writable`: Indicates if the property can be changed.
- `enumerable`: Indicates if the property appears in loops.
- `configurable`: Indicates if the property can be deleted.
- `get()`: Function called when accessing the property.
- `set()`: Function called when updating the property.

Array Constructor

- Creates array objects with similar syntax to `Object()`:

```javascript
var a = new Array(1, 2, 3); // recommended to use literal:
var a = [1, 2, 3];
```

Array Properties and Methods

| Property/Method | Description |
|---------------------------|-------------|
| `length` | The number of elements in the array. |
| `concat()` | Merges one or more arrays. |
| `join(separator)` | Converts the array to a string with

Scan to Download
specified separator. |
| `pop()` | Removes the last element and returns it.
|
| `push()` | Adds elements to the end and returns
the new length. |
| `reverse()` | Reverses the order of elements. |
| `shift()` | Removes the first element and returns it.
|
| `slice(start, end)` | Returns a shallow copy of a portion
of the array. |
| `sort(callback)` | Sorts array elements. |
| `splice(start, deleteCount, ...items)` | Adds/removes
elements at defined positions. |
| `unshift()` | Adds elements to the start of the array.
|
| `isArray(obj)` | Returns true if the object is an array. |

Function Objects

- Functions in JavaScript are first-class objects. They can be

defined using the `Function` constructor or function literals.

Function Properties and Methods

Scan to Download
| Property/Method | Description |
|---------------------------|-------------|
| `apply()` | Invokes a function with a specified
`this` context and an array of arguments. |
| `call()` | Similar to `apply()`, but arguments are
provided individually. |
| `bind()` | Returns a new function with a specified
`this` context. |

Boolean Constructor

- Creates Boolean objects (not to be confused with primitive

Booleans).

Number Constructor

- Creates number objects. Methods like `toFixed()`,

`toExponential()`, and `toPrecision()` are available for
formatting.

String Constructor

- Creates string objects where primitive strings are treated as

objects when methods are called on them. Methods include

Scan to Download
`length`, `charAt`, `indexOf`, and `replace`.

Date Constructor

- Can be initialized with various types: year, month, day,

time, or UNIX timestamp.
- Methods include `getUTC*`, `setUTC*`, `toLocaleString()`,
and parsing capabilities.

Math Object

- Offers mathematical functions and constants, but cannot be

instantiated.

Regular Expressions (RegExp)

- Created using the `RegExp` constructor or literal notation.

They provide functionalities like `exec()` and `test()` for
pattern matching.

Error Objects

- Generated by the environment or through code. They

include standard error types such as `Error`, `TypeError`, and

Scan to Download
more.

JSON Object

- Introduced in ES5 for parsing and stringifying JSON data.

This summary condenses key information about the built-in
objects and functionalities available in JavaScript as outlined
in the source material "Object-Oriented JavaScript."

Scan to Download
Chapter 12 Summary : Appendix
D:Regular Expressions

Summary of Chapter 12: Regular Expressions in

Object-Oriented JavaScript

Introduction to Regular Expressions

Regular expressions (regex) are powerful tools for matching

patterns in strings rather than just literal character sequences.

Basic Pattern Syntax

-
Character Classes
:
- `[abc]` matches any character within the brackets.
- `[a-z]` matches a range of characters, while `[^abc]`
matches any character not in the set.
-
OR Operator

Scan to Download
:
- `a|b` matches either 'a' or 'b'.
-
Lookaheads and Lookbehinds
:
- `a(?=b)` matches 'a' only if followed by 'b', while `a(?!b)`
matches 'a' only if not followed by 'b'.

Escape Characters and Special Sequences

- The backslash (`\`) is used to escape special characters.

- Common escape sequences include:
- `\s` (whitespace), `\S` (non-whitespace), `\w` (word
characters), `\W` (non-word characters), `\d` (digits), and
`\D` (non-digits).

Anchors and Modifiers

-
Anchors
:
Install
- `^` marksBookey App`$`tomarks
the start, and Unlock Full
the end of aText
string.and
Audio
-

Scan to Download
Best Quotes from Object-Oriented
Javascript by Stoyan Stefanov with Page
Numbers
View on Bookey Website and Generate Beautiful Quote Images

Chapter 1 | Quotes From Pages 141-1086

1.Taking the time to learn JavaScript is a smart
investment; you learn one language and can then
write all kinds of different applications running on
multiple platforms, including mobile and
server-side applications.
2.JavaScript is the glue that makes everything work together
so that we can build rich web applications.
3.Nowadays, developers ship sophisticated, well designed
and architected, and extensible applications and libraries,
often supporting multiple platforms with a single codebase.
4.JavaScript is indeed taken seriously and developers are
starting to rediscover and enjoy its unique features more
and more.
5.The movement for web standards was embraced by

Scan to Download
 developers and browser vendors alike.
Chapter 2 | Quotes From Pages 1087-3511
1.Taking the time to learn JavaScript is a smart
investment; you learn one language and can then
write all kinds of different applications running on
multiple platforms, including mobile and
server-side applications.
2.In other words, JavaScript is the glue that makes everything
work together so that we can build rich web applications.
3.Once listed in the 'nice-to-have' sections of job postings,
today, the knowledge of JavaScript is often a deciding
factor when it comes to hiring web developers.
4.If you want to know the type of a variable or a value, you
use the special typeof operator.
5.A variable defined in a function is not visible outside the
function, but a variable defined in a code block (for
example an if or a for loop) is visible outside the block.
6.Every function can be considered a closure. This is because
every function maintains a secret link to the environment

Scan to Download
 (the scope) in which it was created.
7.The function will also try to convert the input to a number:
> isNaN('1.23'); false > isNaN('a1.23'); true
8.By using the modified function, all the work is done with
just one function call, which passes the start values and the
callback function.
9.If you want to have some work done without creating extra
global variables, you can have a function determine the
best way to do the work in the current browser, then
redefine itself so that the 'browser capability detection' is
done only once.
10.This is because inside the function the local scope is more
important than the global scope.
Chapter 3 | Quotes From Pages 3512-5938
1.Mastering functions is an important skill when you
learn any programming language, and even more
so when it comes to JavaScript.
2.JavaScript just uses functions.
3.Understanding these topics will provide a solid base that

Scan to Download
 will allow you to dive into the second part of the chapter...
4.A function always returns a value. If it doesn't return a
value explicitly, it implicitly returns the value undefined.
5.JavaScript is not picky at all when it comes to accepting
arguments.
6.You can create functions that are flexible about the number
of parameters they accept.
7.NaN is contagious, so if you have even one NaN in your
arithmetic operation, the whole result goes down the drain:
> 1 + 2 + NaN; NaN
8.Functions are just data, albeit a special type of data.

Scan to Download
Chapter 4 | Quotes From Pages 5939-7770
1.Objects are like arrays, but you specify the keys.
2.When you try to access a property of an object... the
JavaScript engine looks through all of the properties of the
object searching for one called <property_name>, and if it
finds it, it returns its value.
3.Every function has a property called prototype. Initially it
contains an 'empty' object.
4.If the property name is one of the reserved words in
JavaScript, it must be wrapped in quotes.
5.Use the dot notation to access methods and properties and
don't quote properties in your object literals.
6.The prototype is 'live'. Objects are passed by reference in
JavaScript, and therefore, the prototype is not copied with
every new object instance.
7.When you create an object using a function as a constructor
(with new), the object gets a secret link pointing to the
prototype of the constructor, and can access the prototype's
properties.

Scan to Download
Chapter 5 | Quotes From Pages 7771-8123
1.Understanding how the prototype works is an
important part of learning the JavaScript
language.
2.Like closures, the prototype is one of those things in
JavaScript, which once you 'get', they seem so obvious and
make perfect sense.
3.It's important to note that the prototype is 'live'. Objects are
passed by reference in JavaScript, and therefore, the
prototype is not copied with every new object instance.
4.An object's own properties take precedence over a
prototype's properties with the same name.
5.When you create an object using a function as a constructor
(with new), the object gets a secret link pointing to the
prototype of the constructor, and can access the prototype's
properties.
Chapter 6 | Quotes From Pages 8124-8721
1.Inheritance is one of the most interesting features,
as it allows you to reuse existing code, thus

Scan to Download
 promoting laziness, which is likely to be what
brought human species to computer programming
in the first place.
2.JavaScript is a dynamic language and there is usually more
than one way to achieve any given task. Inheritance is not
an exception.
3.It’s important to remember that JavaScript works with
objects, not classes.
4.When object A lacks a property but B has it, A can still
access this property as its own.
5.This is all good to know, but how does it help you?
6.Simply copying the prototype is more efficient but it has a
side effect: because all the prototypes of the children and
parents point to the same object, when a child modifies the
prototype, the parents get the changes, and so do the
siblings.
7.It’s fascinating to consider what the JavaScript engine does
when you call my.toString(): • It loops through all of the
properties of my and doesn't find a method called

Scan to Download
 toString().
8.The rationale behind this is that own properties are likely to
be too specific to be reusable.
9.It’s fun to draw these shapes.

Scan to Download
Chapter 7 | Quotes From Pages 8722-12063
1.JavaScript programs need a host environment.
2.Now, let's shift the focus to the browser, since this is the
most popular and natural host environment for JavaScript
programs.
3.To include JavaScript in an HTML page, you need to use
the <script> tag.
Chapter 8 | Quotes From Pages 12064-12660
1.A pattern is a proven and reusable solution (or an
approach to a solution) to a class of problems.
2.Sometimes just using a name helps you think more clearly
about a problem.
3.Blindly applying a pattern just for the sake of using a
pattern is not a good idea.
4.It's preferable to not use any known pattern than to try to
tweak your problem so that it fits an existing solution.
Chapter 9 | Quotes From Pages 12661-12668
1.You cannot use reserved words as variable names:
var break = 1; // syntax error

Scan to Download
2.If you use these words as object properties, you have to
quote them: var o = {break: 1}; // OK in many browsers,
error in IE
3.These keywords are not currently used, but are reserved for
future versions of the language.
4.best to stay away for the sake of older browsers.

Scan to Download
Chapter 10 | Quotes From Pages 12669-12672
1.The default radix is 10 (a decimal number).
Returns NaN on failure.
2.Omitting the radix may lead to unexpected results (for
example for inputs such as 08), so it's best to always
specify it.
3.decodeURIComponent() Takes a URL-encoded string and
decodes it.
4.eval() Accepts a string of JavaScript code and executes it.
Returns the result of the last expression in the input string.
5.To be avoided where possible.
Chapter 11 | Quotes From Pages 12673-13341
1.All other objects, built-in or custom, inherit from
Object.
2.Think of a property descriptor as an object that specifies
the features of a property.
3.The same using an ES5 data descriptor: var person = {};
Object.defineProperty(person, "legs", { value: 2, writable:
true, configurable: true, enumerable: true });

Scan to Download
4.Attempting to add properties to a non-extensible object is
not an error, but simply doesn't work.
5.The callback function receives two array elements as
arguments and should return 0 if they are equal, a positive
number if the first is greater and a negative number if the
second is greater.
6.Object.freeze(obj) Everything that seal() does plus prevents
changing the values of properties.
7.You can pass values for year, month, date of the month,
hour, minute, second, and millisecond.
8.The object and the primitive are not equal when compared
by type with ===, but they are when compared with ==
which does type coercion.
9.In ES5 you can directly ask 'Who is your prototype?' >
Object.getPrototypeOf([]) === Array.prototype; true
Chapter 12 | Quotes From Pages 13342-13348
1.But, the true power of regular expressions comes
from matching patterns, not literal strings.
2.Matching all 'r' occurrences and repeating them: > 'regular

Scan to Download
 expression'.replace(/(r)/g, '$1$1'); 'rregularr exprression'
3.(?:pattern) Non-capturing pattern, not remembered and not
available in $1, $2...
4.Keep in mind that the pattern is 'greedy', meaning it will
match as much as possible.

Scan to Download
Object-Oriented Javascript Questions
View on Bookey Website

Chapter 1 | JavaScript| Q&A

1.Question
What role does JavaScript play in modern web
development?
Answer:JavaScript serves as the programming
language of the web, enabling dynamic and
responsive interfaces that enhance user interactions
through various applications, including e-mail,
banking, and interactive gaming.

2.Question
How has JavaScript evolved since its inception?
Answer:Initially limited to simple scripts embedded in
HTML, JavaScript has evolved into a powerful,
object-oriented language that developers use to build scalable
and reusable code architectures.

3.Question
What are the three main components of web development

Scan to Download
mentioned in the text?
Answer:HTML for content, CSS for presentation, and
JavaScript for behavior.

4.Question
Why is learning JavaScript considered a smart
investment?
Answer:By learning JavaScript, you can create applications
that run on various platforms including mobile and
server-side, as JavaScript is versatile and applicable beyond
just web browsers.

5.Question
What significant shift occurred in the perception of
JavaScript due to the Browser Wars?
Answer:JavaScript experienced a backlash where serious
programmers dismissed it as a trivial language, but it
regained reputation as a powerful tool for developing robust
web applications post-Wars.

6.Question
What features does ECMAScript 5 introduce?
Answer:ES5 includes new objects, properties, and a 'strict

Scan to Download
mode' that helps to enforce better coding standards by
excluding deprecated features.

7.Question
In object-oriented programming, what is meant by
'encapsulation'?
Answer:Encapsulation is the concept that a class or object
encapsulates both its data (properties) and the operations
(methods) that manipulate that data, while hiding the
implementation details.

8.Question
How does the concept of aggregation help developers?
Answer:Aggregation allows developers to combine multiple
objects into a complex structure, making it easier to manage
and understand large systems by breaking them into smaller,
manageable parts.

9.Question
What is polymorphism in object-oriented programming?
Answer:Polymorphism allows objects of different classes to
be treated as objects of a common super class, with methods
that can be invoked on these objects responding differently

Scan to Download
based on the object’s actual class.

10.Question
What is the 'lazy evaluation' technique in JavaScript's
logical operations?
Answer:Lazy evaluation refers to the short-circuiting
behavior in logical operations, where if the result of the
operation is certain from the first operand, no further
evaluation is needed, enhancing performance.
Chapter 2 | Data Types, Arrays, Loops, and
Conditions| Q&A
1.Question
What are variables in JavaScript, and why are they
important?
Answer:Variables in JavaScript are placeholders for
data that allow you to store, modify, and retrieve
values as needed in your programs. They enable
developers to write dynamic programs that can
handle varying data.

2.Question
How does variable initialization work in JavaScript?

Scan to Download
Answer:Variable initialization involves assigning a value to a
variable after declaring it. For example, you can declare a
variable with 'var a;' and then initialize it using 'a = 1;' or
declare and initialize in one step 'var a = 1;'.

3.Question
What is the significance of data types in JavaScript?
Answer:Data types in JavaScript determine how values are
processed and manipulated in the language. They categorize
variables into types like Number, String, Boolean,
Undefined, and Null, which dictate what operations can be
performed on them.

4.Question
What operator is used in JavaScript to determine the type
of a variable?
Answer:The 'typeof' operator is used to return a string
indicating the type of the unevaluated operand.

5.Question
What are the five primitive data types in JavaScript?
Answer:The five primitive data types in JavaScript are: 1)
Number, 2) String, 3) Boolean, 4) Undefined, and 5) Null.

Scan to Download
6.Question
How can you check if a variable is defined using
JavaScript?
Answer:You can check if a variable is defined by using the
'typeof' operator. If the variable does not exist, typeof will
return 'undefined'.

7.Question
What is the difference between the '==' and '==='
operators?
Answer:'==' is the equality operator that compares values
after converting them to a common type (loose equality).
'===' is the strict equality operator that checks for both value
and type, without type conversion.

8.Question
Why should variables be declared with 'var'?
Answer:Declaring variables with 'var' prevents accidental
creation of global variables and keeps the code organized,
avoiding naming collisions and unintentional errors.

9.Question
What is a closure in JavaScript?

Scan to Download
Answer:A closure is a feature where an inner function has
access to the outer (enclosing) function's variables even after
the outer function has finished executing, allowing for
private data and encapsulation.

10.Question
What are nested functions, and why are they useful?
Answer:Nested functions are functions defined inside
another function. They are useful for maintaining private
variables and encapsulating functionality while providing a
way to create inner scopes that can access the outer function's
variables.
Chapter 3 | Q&A
1.Question
What is the importance of mastering functions in
JavaScript?
Answer:Mastering functions is crucial in JavaScript
as they form the foundation of the language's
flexibility and expressive power. Functions allow
code to be organized, reused, and maintainable by

Scan to Download
grouping related operations.

2.Question
How can you define a function in JavaScript?
Answer:You define a function using the function keyword
followed by a name, parentheses for parameters, and a code
block that contains the function code. For example: `function
sum(a, b) { return a + b; }`.

3.Question
What happens if a function is called with fewer
arguments than it expects
Answer:If a function is called with fewer arguments than
defined, JavaScript assigns the value undefined to the
missing parameters. For instance, calling `sum(1)` when
`sum` expects two parameters will result in `sum(1,
undefined)`.

4.Question
What are the key differences between parameters and
arguments in functions?
Answer:Parameters are the variables listed in a function's
definition, while arguments are the actual values passed to a

Scan to Download
function when calling it. For example, in `function sum(x, y)
{ return x + y; }` `x` and `y` are parameters; calling `sum(1,
2)` passes 1 and 2 as arguments.

5.Question
What is the purpose of the 'arguments' object in
JavaScript functions?
Answer:The 'arguments' object is an array-like object that
contains all the arguments passed to a function during its
execution. It allows functions to accept a variable number of
arguments and work with them.

6.Question
Can a function return multiple values? How?
Answer:A function can return multiple values by returning
an array or an object that contains all the desired values. For
example, you could return multiple values as follows: `return
[value1, value2];`.

7.Question
What are predefined functions in JavaScript?
Answer:Predefined functions are built-in functions that are
available in JavaScript, such as `parseInt()`, `parseFloat()`,

Scan to Download
`isNaN()`, and others that provide specific functionality
without needing to be implemented by the user.

8.Question
What does the parseInt() function do?
Answer:The `parseInt()` function converts a string to an
integer, interpreting the beginning of the string until it
reaches a character that is not a valid digit.

9.Question
Explain the concept of closures in JavaScript. Why are
they important?
Answer:Closures are functions that capture the lexical scope
in which they were defined, allowing them to access
variables from that scope even when executed outside of it.
They are important for creating private variables and help
manage state in asynchronous programming.

10.Question
How can functions be treated as data in JavaScript?
Answer:In JavaScript, functions can be assigned to variables,
passed as arguments to other functions, and returned from
other functions, making them first-class citizens within the

Scan to Download
language.

Scan to Download
Chapter 4 | Q&A
1.Question
What is an object in JavaScript?
Answer:An object in JavaScript is a collection of
key-value pairs, where keys (also known as
properties) can be strings (or Symbols) and values
can be any data type, including other objects,
arrays, and functions. It allows for structured data
representation and can encapsulate behavior
through methods (functions encapsulated within the
object).

2.Question
How do you access a property in a JavaScript object?
Answer:You can access a property in a JavaScript object
using dot notation (e.g., `object.propertyName`) or bracket
notation (e.g., `object['propertyName']`). If a property doesn't
exist, accessing it with either method will return `undefined`.

3.Question
What is the difference between dot notation and bracket
notation?

Scan to Download
Answer:Dot notation is easier to read and write (e.g.,
`object.propertyName`), but it cannot be used if the property
name is not a valid variable name (e.g., contains spaces or
special characters). Bracket notation (e.g.,
`object['propertyName']`) can be used for any string keys and
is required when the key is stored in a variable.

4.Question
What are methods in JavaScript objects?
Answer:Methods are properties of an object that hold
functions. They are defined within an object and can access
the object’s properties via the `this` keyword.

5.Question
How can you alter properties of an object after its
creation?
Answer:You can alter properties by simply assigning new
values to them or deleting existing properties using the
`delete` operator (e.g., `delete object.propertyName;`).
JavaScript allows for the addition, modification, and removal
of object properties at any time.

Scan to Download
6.Question
What are constructor functions in JavaScript?
Answer:Constructor functions are special functions used to
create and initialize objects. They are invoked with the `new`
keyword, and any properties defined within them using `this`
become properties of the new object instance being created.

7.Question
What is the role of the `this` keyword within methods?
Answer:The `this` keyword refers to the object on which a
method was invoked. It allows methods to access and
manipulate properties of the object they belong to.

8.Question
What is the prototype property of functions?
Answer:Every function in JavaScript has a `prototype`
property that refers to an object. This property can be used to
add methods and properties that can be inherited by instances
created with the function. It's commonly used in
owner-defined inheritance.

9.Question
How do you create a copy of an object?

Scan to Download
Answer:You can create a shallow copy of an object by
iterating over its properties and copying them into a new
object. However, for deep copying, where nested objects or
arrays are also copied, you would need to recursively copy
those properties too.

10.Question
Can built-in objects like Array or String be enhanced in
JavaScript?
Answer:Yes, built-in objects in JavaScript can be enhanced
by adding methods or properties to their prototypes.
However, modifying the core of built-in objects can lead to
issues and is generally discouraged unless necessary.

11.Question
Explain the importance of the constructor property.
Answer:The constructor property is a reference to the
function that created the instance. It is used to determine the
type of object and facilitates the instantiation of new objects
from existing ones.

12.Question
How does the `instanceof` operator work?

Scan to Download
Answer:The `instanceof` operator tests whether an object is
an instance of a specific constructor function, allowing you
to check the object's inheritance chain to see whether it was
created by that constructor or any of its prototypes.

13.Question
What does it mean to have an object inherit from another
object?
Answer:When an object inherits from another, it can access
the properties and methods defined on the prototype of the
parent object. This allows for sharing behaviors and
properties across different object instances.

14.Question
What is a shallow copy of an object?
Answer:A shallow copy of an object duplicates the top-level
properties, but if any of those properties are objects or arrays,
only the reference to those nested elements is copied, not
their values. As a result, changes to nested structures in the
copy will affect the original.

15.Question
What is a deep copy of an object?

Scan to Download
Answer:A deep copy creates a new object that is a complete
clone of the original object and includes cloning nested
objects or arrays, ensuring that changes to the nested
elements do not affect the original object.

16.Question
How can you add new properties to an existing object in
JavaScript?
Answer:You can add new properties to an existing object
using dot notation or bracket notation by assigning the value
directly (e.g., `object.newProperty = value;` or
`object['newProperty'] = value;`).
Chapter 5 | Q&A
1.Question
What is the prototype property in JavaScript?
Answer:The prototype property of a function object
points to another object and is essential in the
prototype-based object model of JavaScript.

2.Question
How do you add properties and methods to a
constructor's prototype?

Scan to Download
Answer:You can add properties and methods directly using
syntax like `ConstructorName.prototype.propertyName =
value;` or define multiple properties at once by overwriting
the prototype with an object.

3.Question
What happens if an object has an own property with the
same name as a prototype property?
Answer:The object's own property takes precedence, and
when accessed, the object's version of that property is
returned.

4.Question
What method can you use to differentiate between own
properties and prototype properties?
Answer:You can use the `hasOwnProperty()` method to
determine if a property is an object's own property.

5.Question
What is the significance of the `__proto__` property?
Answer:The `__proto__` property is a way to access an
object's prototype directly, but it's not recommended for use
in production code because it doesn't exist in all

Scan to Download
environments.

6.Question
What does the `isPrototypeOf()` method do?
Answer:The `isPrototypeOf()` method checks if an object
exists in another object's prototype chain.

7.Question
What should you check before augmenting built-in object
prototypes?
Answer:Before augmenting built-in object prototypes,
always check if the method or property you want to add
already exists to avoid conflicts with future JavaScript
implementations.

8.Question
How does the prototype chain work in JavaScript?
Answer:When you try to access a property that doesn't exist
on an object, JavaScript looks up the prototype chain,
checking each prototype until it either finds the property or
reaches the global Object prototype.

9.Question
Can you modify the prototype of built-in objects? What is

Scan to Download
a potential risk?
Answer:Yes, you can modify the prototypes of built-in
objects, but it can lead to unexpected behavior or conflicts,
especially if future JavaScript versions introduce methods
with the same names.

10.Question
What method would you use in ES5 to get an object's
prototype safely?
Answer:You can use `Object.getPrototypeOf()` to safely
retrieve the prototype of an object in ES5 and later
environments.
Chapter 6 | Q&A
1.Question
What is inheritance in JavaScript and why is it
important?
Answer:Inheritance is a feature in JavaScript that
allows one object to inherit properties and methods
from another object. This is crucial as it promotes
code reusability and organization, enabling

Scan to Download
developers to create a hierarchy of objects that
share common behaviors, thereby reducing
redundancy.

2.Question
What is prototype chaining and how does it work?
Answer:Prototype chaining is the primary way to implement
inheritance in JavaScript. Every function has a prototype
property, which is an object that defines properties and
methods shared by instances created from that function. An
instance can access properties of its prototype through the
'__proto__' link, allowing it to reach properties of ancestor
prototypes up the chain until the grandparent Object
prototype is reached.

3.Question
How can objects created from different constructors
share methods efficiently?
Answer:Objects can share methods by placing these methods
on the prototype of their constructor. This means all
instances will inherit the same method reference from the

Scan to Download
prototype rather than each instance having its own copy,
which is both memory-efficient and promotes method reuse.

4.Question
What is the benefit of moving shared properties to the
prototype rather than defining them in the constructor
function?
Answer:Moving shared properties to the prototype makes
memory usage more efficient, as it ensures that all instances
reference the same property rather than having individual
copies. This is ideal for properties that do not change per
instance.

5.Question
What is the role of the 'constructor' property in
prototypes, and why is it important to reset it after
inheritance?
Answer:The 'constructor' property points to the function that
created the instance. After inheritance, it's important to reset
this property to ensure it accurately reflects the child
constructor rather than the parent constructor, preserving the
integrity of instance type checks.

Scan to Download
6.Question
Can you explain the concept of 'uber' in JavaScript
prototypal inheritance?
Answer:The 'uber' property serves as a pointer to the parent
object's prototype in JavaScript. This allows child objects to
access parent methods, facilitating enhanced functionality
where a child can utilize both its methods and inherited
methods from its ancestors.

7.Question
What is the difference between shallow copy and deep
copy in object copying?
Answer:A shallow copy creates a new object, but only copies
the references to the properties of the original object,
meaning nested objects can still refer to the same example in
memory. In contrast, a deep copy recursively copies all
properties, creating completely independent copies of nested
objects, thus avoiding any shared reference issues.

8.Question
How can you implement multiple inheritance in
JavaScript?

Scan to Download
Answer:Multiple inheritance can be implemented using
object composition, where properties and methods from
multiple parent objects are combined into a single child
object. This can be achieved through a function that iterates
through multiple parent objects and copies their properties
into the child object.

9.Question
What are mixins and how can they be utilized in
JavaScript?
Answer:Mixins are objects that contain useful methods
which can be mixed into other objects or classes without
establishing a formal inheritance. This allows for the sharing
of functionality among different objects by passing them as
arguments during the creation of new objects.

10.Question
What strategies can you use for efficient property copying
when using prototypal inheritance?
Answer:To efficiently copy properties in prototypal
inheritance, you can make use of functions tailored to either

Scan to Download
shallow or deep copies, provide properties in a structured
manner, or use utility methods that streamline the process of
merging or assigning properties from one object to another.

Scan to Download
Chapter 7 | Browser Environment| Q&A
1.Question
What is the significance of the Browser Object Model
(BOM) in JavaScript programming?
Answer:The Browser Object Model (BOM) is
crucial because it allows JavaScript to interact with
the web browser itself, providing access to the
browser's features such as the window, history,
location, and navigator objects. This enables
developers to control aspects of the browser's
behavior, manage user sessions, and create highly
interactive web applications.

2.Question
How does the Document Object Model (DOM) enhance
the interaction between JavaScript and HTML?
Answer:The Document Object Model (DOM) acts as an
interface that browsers use to represent the structure of a
document as a tree of objects. This allows JavaScript to
dynamically interact with HTML content, enabling

Scan to Download
developers to add, remove, and modify elements on the web
page in real-time, making web applications more interactive
and responsive to user actions.

3.Question
What are browser events and why are they important in
JavaScript programming?
Answer:Browser events are actions that occur as a result of
user interactions or changes in the browser environment,
such as clicks, key presses, or changes in window size. They
are important because they allow developers to create an
engaging user experience by triggering functions in response
to these events, enabling dynamic content updates and
improving interactivity.

4.Question
Can you explain the role of the XMLHttpRequest object
in JavaScript?
Answer:The XMLHttpRequest object plays a critical role in
enabling asynchronous communication between the client
and server. It allows JavaScript to send and receive data from

Scan to Download
a web server without reloading the entire page, which is
essential for building modern web applications that require
dynamic data updates, such as single-page applications
(SPAs). This improves performance and user experience.

5.Question
How do you include JavaScript within an HTML
document?
Answer:JavaScript can be included in an HTML document
using the <script> tag. For instance, within the <head>
section, you can link to an external JavaScript file using
<script src='somefile.js'></script>, or you can write inline
JavaScript directly within the <script> tags, like <script> var
a = 1; a++; </script>, which initializes and modifies a
variable.

6.Question
Why is it essential to understand the relationship between
JavaScript and the browser environment?
Answer:Understanding the relationship between JavaScript
and the browser environment is essential because it

Scan to Download
empowers developers to leverage the browser's capabilities
fully. This knowledge allows for effective manipulation of
the web page, responsive interactions, and integration with
web services, ultimately leading to the creation of robust and
feature-rich web applications.
Chapter 8 | and Design Patterns| Q&A
1.Question
What is the importance of recognizing patterns in
programming?
Answer:Recognizing patterns in programming
allows developers to identify previously solved
problems and apply proven solutions effectively. It
fosters clarity in problem-solving, promotes
communication among team members through
shared terminology, and enhances code organization
and maintainability.

2.Question
What distinguishes coding patterns from design patterns?
Answer:Coding patterns are specific to JavaScript best

Scan to Download
practices that leverage the unique features of the language,
while design patterns are language-independent solutions
applicable across various programming languages,
popularized by foundational texts like the "Gang of Four"
book.

3.Question
Why is blindly applying patterns discouraged?
Answer:Blindly applying patterns is discouraged because it
can lead to ill-suited solutions that do not genuinely address
the problem at hand. It's better to adapt to the unique aspects
of a problem rather than forcing it to fit an existing pattern,
which might compromise the overall design integrity.

4.Question
How can behavior be effectively separated from content
and presentation in web development?
Answer:Behavior should be isolated through external
JavaScript files, avoiding inline event handlers and
minimizing script tags. This keeps the structure of HTML
(content) clean and semantically correct while enabling more

Scan to Download
manageable styling with CSS, promoting a clear division of
concerns in web development.

5.Question
Can you give an example of a coding pattern that helps
improve JavaScript performance?
Answer:An example of a coding pattern that improves
JavaScript performance is 'lazy definition,' where functions
or variables are created only when they are needed, thus
conserving resources and speeding up initial load times.

6.Question
What are the implications of naming patterns in
programming?
Answer:Using a specific name for a pattern can clarify
thinking about a problem or solution. It standardizes
discussions among developers, making collaboration easier
and allowing for more efficient communication about
complex issues.

7.Question
What does it mean to have private properties in
JavaScript, and why is it valuable?

Scan to Download
Answer:Private properties are member variables that are not
accessible from outside the object's context, providing
encapsulation. This approach is valuable because it protects
the integrity of the data, reducing unintended interference
and increasing modularity in code.

8.Question
How does separating behavior from content and
presentation contribute to better code practices?
Answer:By separating behavior from content and
presentation, developers can achieve a cleaner code
architecture, making it easier to maintain, test, and update.
This separation ensures that changes in one aspect do not
inadvertently affect others, enhancing reusability and
scalability.
Chapter 9 | Appendix A:Reserved Words| Q&A
1.Question
What are reserved words in JavaScript, and why can't
they be used as variable names?
Answer:Reserved words in JavaScript, as defined in

Scan to Download
ECMAScript 5 (ES5), are specific keywords that
have special meaning in the language. This means
they are used by the language's syntax and
structure, which prevents them from being used as
names for variables. For example, trying to name a
variable 'break', which is a reserved word used to
terminate loops, would result in a syntax error. In
programming terms, reserving these keywords is
crucial to maintain the integrity of the language's
functionality.

2.Question
How can you use reserved words as object properties in
JavaScript?
Answer:While you can't name variables using reserved
words, you can still use them as object properties by quoting
the names. For instance, you can define an object like `var o
= {"break": 1};`. Using quotes ensures the JavaScript engine
understands that it's a string key, not a keyword, allowing
you to access the property with `o['break']` without errors,

Scan to Download
even in older browsers like Internet Explorer.

3.Question
What are some examples of future reserved words in
JavaScript?
Answer:Future reserved words in JavaScript are keywords
that are currently not in use but are set aside for potential
features in later versions of the language. Examples include
`class`, `const`, `import`, `let`, and `static`. These words are
reserved to avoid conflicting with future syntax
enhancements to the language.

4.Question
Why is it important to be aware of previously reserved
words, even though they are no longer reserved in ES5?
Answer:Even though words like `abstract`, `float`, and `int`
are no longer reserved in ES5, it's wise to avoid using them
as variable names. This is to ensure compatibility with older
browsers that may still treat them as reserved. Awareness of
such previously reserved words helps in writing code that is
more robust and less prone to errors across different

Scan to Download
environments.

5.Question
Can you provide an example of how to handle reserved
words in code effectively?
Answer:Certainly! Let's say you need to create a JavaScript
object with property names that include reserved words.
Here's how you can do this safely:

```javascript
var myObject = {
"class": "Math101",
"switch": "On"
};

console.log(myObject["class"]); // Outputs: Math101

console.log(myObject["switch"]); // Outputs: On
```
In this example, quoting the property names avoids any
potential syntax issues that would arise from using reserved

Scan to Download
words directly.

Scan to Download
Chapter 10 | Appendix B:Built-in Functions| Q&A
1.Question
What is the purpose of the `parseInt()` function and why
should the radix parameter always be specified?
Answer:The `parseInt()` function converts a string
representation of a number into an integer, but it
does not handle exponent notation (like '10e+3'). It
takes two parameters: the input to convert and the
radix (the base of the numeral system). Specifying
the radix is crucial because omitting it can lead to
unexpected outcomes, such as interpreting '08' as 0
in decimal instead of 8, leading to erroneous results.

2.Question
How does `parseFloat()` differ from `parseInt()`?
Answer:`parseFloat()` is used to convert a string into a
floating-point number and understands exponent notation.
This means it can handle strings like '10e+3' and return
10000, while `parseInt()` would return just 10 without any
exponent handling.

Scan to Download
3.Question
What does the `isNaN()` function do, and how can you
utilize it effectively?
Answer:The `isNaN()` function checks if a value is NaN
(Not a Number) after attempting to convert it to a number. It
can be used to validate if a computation or input is valid
before processing it further, for instance, ensuring that
operations that expect numeric inputs do not encounter
invalid types.

4.Question
Explain the utility of `encodeURIComponent()` and when
it should be used. Can you give an example?
Answer:`encodeURIComponent()` is crucial for encoding
special characters in a URI component, making it safe to
transmit in URLs. For example, given the string 'some
script?key=v@lue', it would convert it to
'some%20script%3Fkey%3Dv%40lue', ensuring that spaces
and special characters do not disrupt the URL structure.

5.Question
What are the risks associated with using the `eval()`

Scan to Download
function?
Answer:Using `eval()` can introduce significant security
risks as it executes any string as JavaScript code, exposing
the application to potential code injection attacks. It is
recommended to avoid its use unless absolutely necessary
and to seek safer alternatives for parsing or evaluating
expressions.

6.Question
How do `encodeURI()` and `decodeURI()` functions
complement each other?
Answer:`encodeURI()` is used to encode an entire URI,
ensuring that the fundamental structure remains intact while
transforming certain characters, while `decodeURI()`
reverses this process, decoding the encoded URI back to its
original form. For example, given
'http://example.com/?search=some%20query', `decodeURI()`
would return 'http://example.com/?search=some query'.

7.Question
In what scenarios would you use `isFinite()` and why is it

Scan to Download
important?
Answer:`isFinite()` returns true for any number (or
convertible to a number) that is not Infinity or -Infinity. This
function is essential for validating numerical computations
and ensuring you are dealing with actual numbers in your
logic, preventing errors in calculations involving limits or
overflows.
Chapter 11 | Appendix C:Built-in Objects| Q&A
1.Question
What is the difference between using new Object() and {}
to create an object in JavaScript?
Answer:Using `new Object()` creates a new object
instance but is not recommended because it allows
for implicit type coercions, which can lead to
ambiguous behavior. In contrast, using `{}` creates
an object explicitly and is the recommended practice
because it's clear and straightforward. For example:
`var o = {};` is preferred over `var o = new
Object();`.

Scan to Download
2.Question
What does Object.prototype.custom = 1; do in
JavaScript?
Answer:Adding a property to `Object.prototype`, like
`custom`, means all objects, including instances of built-in
and user-defined types, will inherit this property. For
instance, if `s = new String('noodles');`, then `s.custom` will
return `1`, demonstrating how inheritance works in
JavaScript.

3.Question
What are property descriptors in JavaScript ES5, and
how are they useful?
Answer:Property descriptors allow you to define attributes
for properties in greater detail. Each descriptor can specify
features like whether a property can be written to
(`writable`), enumerated in loops (`enumerable`), or deleted
(`configurable`). This provides better control over property
behavior than was previously available in JavaScript,
allowing developers to prevent accidental changes and

Scan to Download
improve code reliability.

4.Question
What is the significance of Object.create() in JavaScript?
Answer:`Object.create()` is a powerful method introduced in
ES5 that allows you to create a new object with a specified
prototype object and an optional property descriptor. This is
crucial for implementing inheritance in JavaScript, allowing
the new object to inherit properties without the complexities
associated with constructor functions.

5.Question
How does the map() method differ from the forEach()
method in JavaScript arrays?
Answer:Both `map()` and `forEach()` are used for iterating
over arrays, but `map()` creates a new array populated with
the results of calling a provided function on every element in
the original array, while `forEach()` executes a provided
function once for each array element without returning
anything. For example, using `map()`, you can transform data
while iterating.

Scan to Download
6.Question
Why is it considered bad practice to use the Function
constructor?
Answer:Using the Function constructor (e.g., `var sum = new
Function('a', 'b', 'return a + b;');`) is generally discouraged
due to performance issues and security risks related to
dynamically executing code. It's often better to use function
literals, which are clearer and more performant.

7.Question
What is the use of the JSON object and its methods in
JavaScript?
Answer:The JSON object provides two key methods,
`JSON.parse()` and `JSON.stringify()`, which are essential
for working with JSON data. `JSON.parse()` allows you to
convert a JSON string into a JavaScript object, while
`JSON.stringify()` serializes a JavaScript object into a JSON
string. These methods are vital for data exchange between
web applications and servers.

8.Question
How can you check if an object is extensible in

Scan to Download
JavaScript?
Answer:You can check if an object is extensible by using
`Object.isExtensible(obj)`. This method returns `true` if
properties can be added to the object, and `false` if it has
been frozen or sealed to prevent further modifications.

9.Question
What is the difference between
Object.preventExtensions() and Object.seal()?
Answer:`Object.preventExtensions(obj)` prevents new
properties from being added to the object, while
`Object.seal(obj)` not only prevents new properties but also
makes all existing properties non-configurable, meaning you
cannot delete or reconfigure them. You can still change the
values of existing properties while the object is sealed.
Chapter 12 | Appendix D:Regular Expressions|
Q&A
1.Question
What is the primary advantage of using regular
expressions over simple string matching?
Answer:The true power of regular expressions lies

Scan to Download
in their ability to match patterns rather than just
literal strings. This allows for complex searches and
data extraction from text, enabling developers to
identify and manipulate text based on its structure
rather than just its content.

2.Question
How do character classes work in regular expressions?
Answer:Character classes are defined using square brackets,
and they match any single character contained within the
brackets. For instance, the pattern [abc] matches any one of
the characters 'a', 'b', or 'c'. Additionally, ranges can be
defined, such as [a-z], which matches any lowercase letter.

3.Question
What does the caret (^) signify in a regular expression?
Answer:The caret (^) is used to indicate the beginning of a
string. If the multiline (m) modifier is used, it matches the
beginning of each line. For example, /^r/ will match 'r' only if
it appears at the start of the string or each line.

4.Question
Can you explain the difference between the . and *

Scan to Download
operators in regular expressions?
Answer:The dot (.) matches any single character except
newlines, while the asterisk (*) matches the preceding
element zero or more times. For instance, the pattern /a*b/
will match 'b', 'ab', 'aaab', etc., but /a.b/ would match 'a1b', 'a
b', but not 'ab'.

5.Question
What is the significance of the escape character in regular
expressions?
Answer:The escape character (") is used to match special
characters literally. For example, to find a literal dot (.) in a
string, you would use the pattern /\./. Without the escape
character, the dot serves as a wildcard that matches any
character except a newline.

6.Question
Explain how capturing groups work in regular
expressions.
Answer:Capturing groups allow you to extract specific
portions of a matched string. They are defined by enclosing

Scan to Download
the pattern in parentheses. For instance, in the pattern /(abc)/,
'abc' can be remembered and referred to in substitutions
using $1, $2, etc. This is useful for reordering or modifying
parts of the matched text.

7.Question
What does the syntax (?:pattern) indicate in a regular
expression?
Answer:The syntax (?:pattern) defines a non-capturing
group. This means the group will match the specified pattern
but will not be saved for use in replacements or later queries,
unlike capturing groups which remember the matched
content.

8.Question
How can you match whitespace characters in a string
using regular expressions?
Answer:You can match whitespace characters using the
pattern \s, which represents any whitespace character,
including spaces, tabs, and newlines. For example, in the
string "Hello World!", using /\s/g would match the space

Scan to Download
between 'Hello' and 'World'.

9.Question
What role does the quantifier + play in regular
expressions?
Answer:The quantifier + matches the preceding pattern one
or more times. For example, the pattern /a+/ would match 'a',
'aa', or 'aaa', but it would not match an empty string.

10.Question
Can you give an example of how to use the range
{min,max} in a regex?
Answer:Certainly! The range {min,max} is used to specify
that the preceding character or group must appear at least
'min' times and at most 'max' times. For instance, in the
pattern /a{2,4}/, it would match 'aa', 'aaa', or 'aaaa', but not 'a'
or 'aaaaa'.

11.Question
Why is it essential to understand both capturing and
non-capturing groups in regex?
Answer:Understanding both types of groups is crucial for
efficient text processing and manipulation. Capturing groups

Scan to Download
allow you to extract and reuse matched patterns, making
complex replacements easier. Non-capturing groups allow
for grouping in patterns without cluttering the captured
matches, which is useful when grouping is necessary for
applying quantifiers or alternation.

Scan to Download
Object-Oriented Javascript Quiz and
Test
Check the Correct Answer on Bookey Website

Chapter 1 | JavaScript| Quiz and Test

1.JavaScript was originally named LiveScript before
it was renamed JavaScript.
2.JavaScript can only be used for web browsers and cannot
be utilized for server-side applications.
3.ECMAScript 5 introduced strict mode which helps in
enforcing proper coding practices.
Chapter 2 | Data Types, Arrays, Loops, and
Conditions| Quiz and Test
1.Variables in JavaScript cannot start with a
number.
2.The only primitive data types in JavaScript are Number,
String, and Boolean.
3.The `for-in` loop is primarily used for iterating over
properties of arrays.
Chapter 3 | Quiz and Test

Scan to Download
1.JavaScript functions can be defined without giving
them a name, which are called anonymous
functions.
2.In JavaScript, functions can only receive a fixed number of
parameters corresponding to their definition.
3.A closure in JavaScript allows a function to access
variables from its containing scope even after the
containing function has executed.

Scan to Download
Chapter 4 | Quiz and Test
1.JavaScript uses arrays as associative arrays or
hashes.
2.Properties of an object can be accessed using both dot
notation and bracket notation.
3.Constructor functions should begin with a lowercase letter
according to best practice.
Chapter 5 | Quiz and Test
1.Every function in JavaScript has a prototype
property that is an object.
2.The `hasOwnProperty()` method checks if a property
belongs to the prototype of an object.
3.Altering built-in objects like arrays or strings is completely
safe and doesn't lead to any risks.
Chapter 6 | Quiz and Test
1.Inheritance in JavaScript allows code reuse and
promotes efficient programming by enabling new
objects to inherit properties and methods from
existing objects.

Scan to Download
2.Prototype chaining allows newly created objects to access
properties and methods only from their constructor directly,
ignoring ancestor objects.
3.When an object does not have its own property, JavaScript
will not look up the prototype chain to find the property in
ancestor objects.

Scan to Download
Chapter 7 | Browser Environment| Quiz and Test
1.JavaScript can run without a host environment.
2.The Browser Object Model (BOM) is a key component for
understanding JavaScript in browsers.
3.The `<script>` tag is used to include CSS in an HTML
document.
Chapter 8 | and Design Patterns| Quiz and Test
1.Coding patterns are specific to programming
languages, while design patterns are universally
applicable across languages.
2.Separating behavior in code means intertwining HTML,
CSS, and JavaScript for better maintainability.
3.The use of design patterns can lead to more complex and
hard-to-manage code if applied without context.
Chapter 9 | Appendix A:Reserved Words| Quiz and
Test
1.The word 'class' is currently reserved in
ECMAScript 5 (ES5) and cannot be used as a
variable name.

Scan to Download
2.The word 'goto' is currently a reserved word in
ECMAScript 5 (ES5) and cannot be used as a variable
name.
3.In order to avoid syntax errors, reserved words can be used
as property names but should always be quoted in object
literals.

Scan to Download
Chapter 10 | Appendix B:Built-in Functions| Quiz
and Test
1.The parseInt() function in JavaScript can convert
any string into an integer without needing a radix
parameter.
2.isFinite() will return false for non-numeric values such as
strings and true for numeric strings in JavaScript.
3.The eval() function is considered safe to use in JavaScript
because it executes code without any risks.
Chapter 11 | Appendix C:Built-in Objects| Quiz and
Test
1.The `Object()` constructor can be used to create
objects in JavaScript and is equivalent to using the
object literal syntax `{}`.
2.The `isArray()` method is a property of the Array object
and returns false when checking if an object is an array.
3.Functions in JavaScript are first-class objects, meaning
they can be treated like any other object.
Chapter 12 | Appendix D:Regular Expressions| Quiz
and Test

Scan to Download
1.Regular expressions (regex) can only match literal
character sequences and not patterns in strings.
2.The `^` anchor marks the end of a string in regular
expressions.
3.The character class `[abc]` matches any character from the
set of 'a', 'b', and 'c'.

Scan to Download