book

JavaScript : Object-Oriented Programming

Name: JavaScript : Object-Oriented Programming
Author: Kumar Chetan Sharma et al
ISBN: 9781787123595

by Kumar Chetan Sharma et al

August 2016

Beginner to intermediate

847 pages

17h 28m

English

Packt Publishing

Read now

Unlock full access

Javascript: Object-Oriented Programming
Table of Contents
Javascript: Object Oriented Programming
Javascript: Object Oriented Programming
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions

I. Module 1
1. JavaScript Primer
A little bit of history
How to use this book
Hello World
An overview of JavaScriptCommentsVariablesConstantsNumberStringUndefined valuesBooleansThe instanceof operatorDate objectsThe + operatorThe ++ and -- operatorsBoolean operatorsEqualityStrict equality using ===Weak equality using ==JavaScript typesAutomatic semicolon insertionJavaScript style guideWhitespacesParentheses, line breaks, and bracesQuotesEnd of lines and empty linesType checkingType castingConditional evaluationNamingThe eval() method is evilThe strict modeEnabling the strict mode for an existing code can break itPackage with careVariables must be declared in strict modeThe eval() function is cleaner in strict modeFeatures that are blocked in strict modeRunning JSHint
Summary
2. Functions, Closures, and Modules
A function literalA function declaration
Functions as data
Scoping
Global scopeLocal scopeFunction-level scope versus block-level scopeInline function expressionsBlock scopes
Function declarations versus function expressions
The arguments parameter
The this parameterInvocation as a functionInvocation as a methodInvocation as a constructorInvocation using apply() and call() methods
Anonymous functions
Anonymous functions while creating an objectAnonymous functions while creating a listAnonymous functions as a parameter to another functionAnonymous functions in conditional logic
Closures
Timers and callbacks
Private variables
Loops and closures
Modules
Stylistic considerations
Summary
3. Data Structures and Manipulation
Regular expressions
Exact match
Match from a class of characters
Repeated occurrences
Alternatives – OR
Beginning and end
Backreferences
Greedy and lazy quantifiers
Arrays
Maps
Sets
A matter of style
Summary
4. Object-Oriented JavaScript
Understanding objectsBehavior of JavaScript objectsPrototypes
Instance properties versus prototype properties
Inheritance
Getters and setters
Summary
5. JavaScript Patterns
Design patterns
The namespace pattern
The module pattern
ES6 modules
The factory pattern
The mixin pattern
The decorator pattern
The observer pattern
JavaScript Model-View-* patterns
Model-View-ControllerModelsViewsControllers
The Model-View-Presenter pattern
Model-View-ViewModel
Summary
6. Testing and Debugging
Unit testingTest-driven developmentBehavior-driven development
JavaScript debugging
Syntax errorsUsing strictRuntime exceptionsConsole.log and assertsChrome DevTools
Summary
7. ECMAScript 6
Shims or polyfills
Transpilers
ES6 syntax changes
Block scopingDefault parametersSpread and restDestructuringObject literalsTemplate literalsMaps and SetsSymbolsIteratorsFor..of loopsArrow functions
Summary
8. DOM Manipulation and Events
DOMAccessing DOM elementsAccessing specific nodes
Chaining
Traversal and manipulation
Working with browser events
Propagation
jQuery event handling and propagation
Event delegation
The event object
Summary
9. Server-Side JavaScript
An asynchronous evented-model in a browser
Callbacks
Timers
EventEmitters
Modules
Creating modules
npm
Installing packages
JavaScript performance
JavaScript profilingThe CPU profileThe Timeline view
Summary
II. Module 2
1. Objects Everywhere
Recognizing objects from nouns
Generating blueprints for objects
Recognizing attributes/fields
Recognizing actions from verbs – methods
Organizing the blueprints – classes
Object-oriented approaches in Python, JavaScript, and C#
Summary
2. Classes and Instances
Understanding classes and instances
Understanding constructors and destructors
Declaring classes in Python
Customizing constructors in Python
Customizing destructors in Python
Creating instances of classes in Python
Declaring classes in C#
Customizing constructors in C#
Customizing destructors in C#
Creating instances of classes in C#
Understanding that functions are objects in JavaScript
Working with constructor functions in JavaScript
Creating instances in JavaScript
Summary
3. Encapsulation of Data
Understanding the different members of a class
Protecting and hiding data
Working with properties
Understanding the difference between mutability and immutability
Encapsulating data in Python
Adding attributes to a classHiding data in Python using prefixesUsing property getters and setters in PythonUsing methods to add behaviors to classes in Python
Encapsulating data in C#
Adding fields to a classUsing access modifiersUsing property getters and setters in C#Working with auto-implemented propertiesUsing methods to add behaviors to classes in C#
Encapsulating data in JavaScript
Adding properties to a constructor functionHiding data in JavaScript with local variablesUsing property getters and setters in JavaScriptUsing methods to add behaviors to constructor functions
Summary
4. Inheritance and Specialization
Using classes to abstract behavior
Understanding inheritance
Understanding method overloading and overriding
Understanding operator overloading
Taking advantage of polymorphism
Working with simple inheritance in Python
Creating classes that specialize behavior in PythonUsing simple inheritance in PythonOverriding methods in PythonOverloading operators in PythonUnderstanding polymorphism in Python
Working with simple inheritance in C#
Creating classes that specialize behavior in C#Using simple inheritance in C#Overloading and overriding methods in C#Overloading operators in C#Understanding polymorphism in C#
Working with the prototype-based inheritance in JavaScript
Creating objects that specialize behavior in JavaScriptUsing the prototype-based inheritance in JavaScriptOverriding methods in JavaScriptOverloading operators in JavaScriptUnderstanding polymorphism in JavaScript
Summary
5. Interfaces, Multiple Inheritance, and Composition
Understanding the requirement to work with multiple base classes
Working with multiple inheritance in Python
Declaring base classes for multiple inheritanceDeclaring classes that override methodsDeclaring a class with multiple base classesWorking with instances of classes that use multiple inheritanceWorking with abstract base classes
Interfaces and multiple inheritance in C#
Declaring interfacesDeclaring classes that implement interfacesWorking with multiple inheritanceWorking with methods that receive interfaces as arguments
Working with composition in JavaScript
Declaring base constructor functions for compositionDeclaring constructor functions that use compositionWorking with an object composed of many objectsWorking with instances composed of many objects
Summary
6. Duck Typing and Generics
Understanding parametric polymorphism and duck typing
Working with duck typing in Python
Declaring a base class that defines the generic behaviorDeclaring subclasses for duck typingDeclaring a class that works with duck typingUsing a generic class for multiple typesWorking with duck typing in mind
Working with generics in C#
Declaring an interface to be used as a constraintDeclaring an abstract base class that implements two interfacesDeclaring subclasses of an abstract base classDeclaring a class that works with a constrained generic typeUsing a generic class for multiple typesDeclaring a class that works with two constrained generic typesUsing a generic class with two generic type parameters
Working with duck typing in JavaScript
Declaring a constructor function that defines the generic behaviorWorking with the prototype chain and duck typingDeclaring methods that work with duck typingUsing generic methods for multiple objectsWorking with duck typing in mind
Summary
7. Organization of Object-Oriented Code
Thinking about the best ways to organize code
Organizing object-oriented code in Python
Working with source files organized in foldersImporting modulesWorking with module hierarchies
Organizing object-oriented code in C#
Working with foldersUsing namespacesWorking with namespace hierarchies in C#
Organizing object-oriented code in JavaScript
Working with objects to organize codeDeclaring constructor functions within objectsWorking with nested objects that organize code
Summary
8. Taking Full Advantage of Object-Oriented Programming
Putting together all the pieces of the object-oriented puzzle
Refactoring existing code in Python
Refactoring existing code in C#
Refactoring existing code in JavaScript
Summary
III. Module 3
1. Object-oriented JavaScript
A bit of historyBrowser wars and renaissanceThe presentThe future
ECMAScript 5
Object-oriented programming
Setting up your training environment
WebKit's Web InspectorJavaScriptCore on a MacMore consoles
Summary
2. Primitive Data Types, Arrays, Loops, and Conditions
VariablesVariables are case sensitive
Operators
Primitive data types
Finding out the value type – the typeof operatorNumbersOctal and hexadecimal numbersExponent literalsInfinityNaN
Strings
String conversionsSpecial strings
Booleans
Logical operators
Operator precedenceLazy evaluation
Comparison
Undefined and null
Primitive data types recap
Arrays
Adding/updating array elementsDeleting elementsArrays of arrays
Conditions and loops
The if conditionThe else clause
Code blocks
Checking if a variable existsAlternative if syntax
Switch
Loops
While loopsDo-while loopsFor loopsFor-in loops
Comments
Summary
Exercises
3. Functions
What is a function?Calling a functionParametersPredefined functionsparseInt()parseFloat()isNaN()isFinite()Encode/decode URIseval()A bonus – the alert() function
Scope of variables
Variable hoisting
Functions are data
Anonymous functionsCallback functionsCallback examplesImmediate functionsInner (private) functionsFunctions that return functionsFunction, rewrite thyself!
Closures
Scope chainBreaking the chain with a closureClosure #1Closure #2A definition and closure #3Closures in a loopGetter/setterIterator
Summary
Exercises
4. Objects
From arrays to objectsElements, properties, methods, and membersHashes and associative arraysAccessing an object's propertiesCalling an object's methodsAltering properties/methodsUsing the this valueConstructor functionsThe global objectThe constructor propertyThe instanceof operatorFunctions that return objectsPassing objectsComparing objectsObjects in the WebKit consoleconsole.log
Built-in objects
ObjectArrayA few array methodsFunctionProperties of function objectsPrototypeMethods of function objectsCall and applyThe arguments object revisitedInferring object typesBooleanNumberStringA few methods of string objectsMathDateMethods to work with date objectsCalculating birthdaysRegExpProperties of RegExp objectsMethods of RegExp objectsString methods that accept regular expressions as argumentssearch() and match()replace()Replace callbackssplit()Passing a string when a RegExp is expectedError objects
Summary
Exercises
5. Prototype
The prototype propertyAdding methods and properties using the prototype
Using the prototype's methods and properties
Own properties versus prototype propertiesOverwriting a prototype's property with an own propertyEnumerating propertiesisPrototypeOf()The secret __proto__ link
Augmenting built-in objects
Augmenting built-in objects – discussionPrototype gotchas
Summary
Exercises
6. Inheritance
Prototype chainingPrototype chaining exampleMoving shared properties to the prototype
Inheriting the prototype only
A temporary constructor – new F()
Uber – access to the parent from a child object
Isolating the inheritance part into a function
Copying properties
Heads-up when copying by reference
Objects inherit from objects
Deep copy
object()
Using a mix of prototypal inheritance and copying properties
Multiple inheritance
Mixins
Parasitic inheritance
Borrowing a constructor
Borrow a constructor and copy its prototype
Summary
Case study – drawing shapes
AnalysisImplementationTesting
Exercises
7. The Browser Environment
Including JavaScript in an HTML page
BOM and DOM – an overview
BOM
The window object revisitedwindow.navigatorYour console is a cheat sheetwindow.locationwindow.historywindow.frameswindow.screenwindow.open()/close()window.moveTo() and window.resizeTo()window.alert(), window.prompt(), and window.confirm()window.setTimeout() and window.setInterval()window.document
DOM
Core DOM and HTML DOMAccessing DOM nodesThe document nodedocumentElementChild nodesAttributesAccessing the content inside a tagDOM access shortcutsSiblings, body, first, and last childWalk the DOMModifying DOM nodesModifying stylesFun with formsCreating new nodesDOM-only methodcloneNode()insertBefore()Removing nodesHTML-only DOM objectsPrimitive ways to access the documentdocument.write()Cookies, title, referrer, domain
Events
Inline HTML attributesElement PropertiesDOM event listenersCapturing and bubblingStop propagationPrevent default behaviorCross-browser event listenersTypes of events
XMLHttpRequest
Sending the requestProcessing the responseCreating XMLHttpRequest objects in IE prior to Version 7A is for AsynchronousX is for XMLAn example
Summary
Exercises
8. Coding and Design Patterns
Coding patternsSeparating behaviorContentPresentationBehaviorExample of separating behaviorAsynchronous JavaScript loadingNamespacesAn Object as a namespaceNamespaced constructorsA namespace() methodInit-time branchingLazy definitionConfiguration objectPrivate properties and methodsPrivileged methodsPrivate functions as public methodsImmediate functionsModulesChainingJSON
Design patterns
SingletonSingleton 2Global variableProperty of the ConstructorIn a private propertyFactoryDecoratorDecorating a Christmas treeObserver
Summary
9. Reserved Words
Keywords
Future reserved words
Previously reserved words
10. Built-in Functions
11. Built-in Objects
ObjectMembers of the Object constructorThe Object.prototype membersECMAScript 5 additions to Object
Array
The Array.prototype membersECMAScript 5 additions to Array
Function
The Function.prototype membersECMAScript 5 additions to a function
Boolean
Number
Members of the Number constructorThe Number.prototype members
String
Members of the String constructorThe String.prototype membersECMAScript 5 additions to String
Date
Members of the Date constructorThe Date.prototype membersECMAScript 5 additions to Date
Math
Members of the Math object
RegExp
The RegExp.prototype members
Error objects
The Error.prototype members
JSON
Members of the JSON object
12. Regular Expressions
A. Biblography
Index

Content preview from JavaScript : Object-Oriented Programming

Working with simple inheritance in C#

First, we will create a base class in C#. Then we will use simple inheritance to create subclasses and specialize behavior. We will override methods and overload comparison operators to be able to compare different instances of a specific class and its subclasses. We will take advantage of this polymorphism.

Creating classes that specialize behavior in C#

Now it is time to code all the classes in C#. The following lines show the code for the Animal abstract class in C#. The class declaration doesn't specify a base class; therefore, this class inherits from Object, specifically System.Object. System.Object is the base class for all the classes included in .NET Framework. The usage of the abstract keyword before ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

JavaScript: Functional Programming for JavaScript Developers

Publisher Resources

ISBN: 9781787123595

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

JavaScript : Object-Oriented Programming

by Kumar Chetan Sharma et al

Working with simple inheritance in C#

Creating classes that specialize behavior in C#

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

JavaScript: Functional Programming for JavaScript Developers

Functional Programming in JavaScript

Mastering JavaScript Object-Oriented Programming

Programming JavaScript Applications

Publisher Resources