book

Speaking JavaScript

Name: Speaking JavaScript
Author: Axel Rauschmayer
ISBN: 9781449364991

by Axel Rauschmayer

February 2014

Beginner to intermediate

460 pages

8h 32m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Praise for Speaking JavaScript
Preface
What You Need to Know About This BookTips for Reading This BookThe Four Parts of This BookJavaScript Command LinesNotational ConventionsDescribing syntaxReferring to methodsCommand-line interactionTips, notes, and warningsQuickly Finding DocumentationSafari® Books OnlineHow to Contact UsAcknowledgmentsPreparing for JavaScriptHelp with JavaScriptReviewers
I. JavaScript Quick Start
1. Basic JavaScript
BackgroundJavaScript Versus ECMAScriptInfluences and Nature of the LanguageSyntaxAn Overview of the SyntaxStatements Versus ExpressionsSemicolonsCommentsVariables and AssignmentAssignmentCompound Assignment OperatorsIdentifiers and Variable NamesValuesPrimitive Values Versus ObjectsPrimitive ValuesObjectsundefined and nullChecking for undefined or nullCategorizing Values Using typeof and instanceofBooleansTruthy and FalsyBinary Logical OperatorsEquality OperatorsNumbersOperatorsStringsString OperatorsString MethodsStatementsConditionalsLoopsFunctionsFunction Declarations Are HoistedThe Special Variable argumentsToo Many or Too Few ArgumentsOptional ParametersEnforcing an ArityConverting arguments to an ArrayException HandlingStrict ModeVariable Scoping and ClosuresVariables Are Function-ScopedVariables Are HoistedClosuresThe IIFE Pattern: Introducing a New ScopeIIFE use case: inadvertent sharing via closuresObjects and ConstructorsSingle ObjectsArbitrary Property KeysExtracting MethodsFunctions Inside a MethodConstructors: Factories for ObjectsArraysArray LiteralsArray MethodsIterating over ArraysRegular ExpressionsMethod test(): Is There a Match?Method exec(): Match and Capture GroupsMethod replace(): Search and ReplaceMathOther Functionality of the Standard Library
II. Background
2. Why JavaScript?
Is JavaScript Freely Available?Is JavaScript Elegant?Is JavaScript Useful?Graphical User InterfacesOther Technologies Complementing JavaScriptDoes JavaScript Have Good Tools?Is JavaScript Fast Enough?Is JavaScript Widely Used?Does JavaScript Have a Future?Conclusion
3. The Nature of JavaScript
Quirks and Unorthodox FeaturesElegant PartsInfluences
4. How JavaScript Was Created
5. Standardization: ECMAScript
6. Historical JavaScript Milestones

III. JavaScript in Depth
7. JavaScript’s Syntax
An Overview of the SyntaxCommentsExpressions Versus StatementsExpressionsStatementsConditional statement versus conditional expressionsUsing ambiguous expressions as statementsEvaluating an object literal via eval()Immediately invoking a function expressionControl Flow Statements and BlocksRules for Using SemicolonsNo Semicolon After a Statement Ending with a BlockThe Empty StatementAutomatic Semicolon InsertionExample: ASI via illegal tokenExample: ASI via closing bracePitfall: ASI can unexpectedly break up statementsPitfall: ASI might unexpectedly not be triggeredLegal IdentifiersInvoking Methods on Number LiteralsStrict ModeSwitching on Strict ModeStrict Mode: Recommended, with CaveatsVariables Must Be Declared in Strict ModeFunctions in Strict ModeFunctions must be declared at the top level of a scopeStricter rules for function parametersThe arguments objects has fewer propertiesthis is undefined in nonmethod functionsSetting and Deleting Immutable Properties Fails with an Exception in Strict ModeUnqualified Identifiers Can’t Be Deleted in Strict Modeeval() Is Cleaner in Strict ModeFeatures That Are Forbidden in Strict Mode
8. Values
JavaScript’s Type SystemJavaScript’s TypesStatic Versus DynamicStatic Typing Versus Dynamic TypingStatic Type Checking Versus Dynamic Type CheckingCoercionPrimitive Values Versus ObjectsPrimitive ValuesObjectsundefined and nullOccurrences of undefined and nullOccurrences of undefinedOccurrences of nullChecking for undefined or nullChecking for nullChecking for undefinedChecking for either undefined or nullThe History of undefined and nullChanging undefinedWrapper Objects for PrimitivesWrapper Objects Are Different from PrimitivesWrapping and Unwrapping PrimitivesPrimitives Borrow Their Methods from WrappersType CoercionType Coercion Can Hide BugsFunctions for Converting to Boolean, Number, String, and ObjectAlgorithm: ToPrimitive()—Converting a Value to a PrimitiveExamples: ToPrimitive() in action
9. Operators
Operators and ObjectsAssignment OperatorsCompound Assignment OperatorsEquality Operators: === Versus ==Strict Equality (===, !==)Pitfall: NaNStrict inequality (!==)Normal (Lenient) Equality (==, !=)Lenient inequality (!=)Pitfall: lenient equality is different from conversion to booleanPitfall: lenient equality and stringsPitfall: lenient equality and objectsThere Are No Valid Use Cases for ==Use case: checking for undefined or nullUse case: working with numbers in stringsUse case: comparing wrapper instances with primitivesOrdering OperatorsThe AlgorithmThe Plus Operator (+)The AlgorithmOperators for Booleans and NumbersSpecial OperatorsThe Conditional Operator ( ? : )The Comma OperatorThe void OperatorWhat is void used for?Why does JavaScript have a void operator?Categorizing Values via typeof and instanceoftypeof: Categorizing PrimitivesPitfall: typeof nullThe history of typeof nullChecking whether a variable existsinstanceof: Checking Whether an Object Is an Instance of a Given ConstructorObject Operators
10. Booleans
Converting to BooleanManually Converting to BooleanTruthy and Falsy ValuesPitfall: all objects are truthyHistory: Why are objects always truthy?Logical OperatorsBinary Logical Operators: And (&&) and Or (||)Logical And (&&)Logical Or (||)Pattern: providing a default valueExample 1: a default for a parameterExample 2: a default for a propertyExample 3: a default for the result of a functionLogical Not (!)Equality Operators, Ordering OperatorsThe Function Boolean
11. Numbers
Number LiteralsExponentInvoking Methods on LiteralsConverting to NumberManually Converting to NumberparseFloat()Special Number ValuesNaNPitfall: checking whether a value is NaNInfinityError: a number’s magnitude is too largeError: division by zeroComputing with InfinityChecking for InfinityTwo ZerosBest practice: pretend there’s only one zeroDistinguishing the two zerosThe Internal Representation of NumbersSpecial ExponentsHandling Rounding ErrorsIntegers in JavaScriptRanges of IntegersRepresenting Integers as Floating-Point NumbersBest practiceSafe IntegersDefinitions in ECMAScript 6Safe results of arithmetic computationsConverting to IntegerIntegers via Math.floor(), Math.ceil(), and Math.round()Integers via the Custom Function ToInteger()32-bit Integers via Bitwise OperatorsBitwise Or (|)Shift operatorsShould I use bitwise operators to coerce to integer?Integers via parseInt()The radixExplanationSummaryArithmetic OperatorsBitwise OperatorsBackground KnowledgeBinary complementsSigned 32-bit integersInputting and outputting binary numbersBitwise Not OperatorBinary Bitwise OperatorsBitwise Shift OperatorsThe Function NumberNumber Constructor PropertiesNumber Prototype MethodsNumber.prototype.toFixed(fractionDigits?)Number.prototype.toPrecision(precision?)Number.prototype.toString(radix?)Decimal exponential notationNumber.prototype.toExponential(fractionDigits?)Functions for NumbersSources for This Chapter
12. Strings
String LiteralsEscaping in String LiteralsCharacter AccessConverting to StringManually Converting to StringPitfall: conversion is not invertibleComparing StringsConcatenating StringsConcatenation: The Plus (+) OperatorConcatenation: Joining an Array of String FragmentsThe Function StringString Constructor MethodString Instance Property lengthString Prototype MethodsExtract SubstringsTransformSearch and CompareTest, Match, and Replace with Regular Expressions
13. Statements
Declaring and Assigning VariablesThe Bodies of Loops and ConditionalsLoopsMechanisms to Be Used with Loopswhiledo-whileforfor-inBest practice: don’t use for-in for arraysBest practice: be careful with for-in for objectsfor each-inConditionalsif-then-elseChaining if statementsPitfall: dangling elseswitchThe with StatementSyntax and SemanticsThe with Statement Is DeprecatedTechniques for avoiding the with statementThe Rationale for the DeprecationThe debugger Statement
14. Exception Handling
What Is Exception Handling?Exception Handling in JavaScriptthrowtry-catch-finallyExamplesError ConstructorsStack TracesImplementing Your Own Error Constructor
15. Functions
The Three Roles of Functions in JavaScriptTerminology: “Parameter” Versus “Argument”Defining FunctionsFunction ExpressionsNamed function expressionsFunction DeclarationsThe Function ConstructorHoistingThe Name of a FunctionWhich Is Better: A Function Declaration or a Function Expression?More Control over Function Calls: call(), apply(), and bind()func.apply(thisValue, argArray)func.bind(thisValue, arg1, ..., argN)Handling Missing or Extra ParametersAll Parameters by Index: The Special Variable argumentsDeprecated features of argumentsMandatory Parameters, Enforcing a Minimum ArityOptional ParametersSimulating Pass-by-Reference ParametersPitfall: Unexpected Optional ParametersNamed ParametersNamed Parameters as DescriptionsOptional Named ParametersSimulating Named Parameters in JavaScript
16. Variables: Scopes, Environments, and Closures
Declaring a VariableBackground: Static Versus DynamicBackground: The Scope of a VariableVariables Are Function-ScopedVariable Declarations Are HoistedIntroducing a New Scope via an IIFEIIFE Variation: Prefix OperatorsIIFE Variation: Already Inside Expression ContextIIFE Variation: An IIFE with ParametersIIFE ApplicationsGlobal VariablesBest Practice: Avoid Creating Global VariablesModule Systems Lead to Fewer GlobalsThe Global ObjectCross-Platform ConsiderationsUse Cases for windowUse case: marking global variablesUse case: built-insUse case: style checkersUse case: checking whether a global variable existsUse case: creating things in global scopeEnvironments: Managing VariablesClosures: Functions Stay Connected to Their Birth ScopesHandling Closures via EnvironmentsPitfall: Inadvertently Sharing an Environment
17. Objects and Inheritance
Layer 1: Single ObjectsKinds of PropertiesObject LiteralsDot Operator (.): Accessing Properties via Fixed KeysGetting propertiesCalling methodsSetting propertiesDeleting propertiesThe return value of deleteUnusual Property KeysBracket Operator ([]): Accessing Properties via Computed KeysGetting properties via the bracket operatorCalling methods via the bracket operatorSetting properties via the bracket operatorDeleting properties via the bracket operatorConverting Any Value to an Objectthis as an Implicit Parameter of Functions and MethodsCalling Functions While Setting this: call(), apply(), and bind()Function.prototype.call(thisValue, arg1?, arg2?, ...)Function.prototype.apply(thisValue, argArray)Function.prototype.bind(thisValue, arg1?, ..., argN?)apply() for ConstructorsManually simulating an apply() for constructorsA library methodAn alternative approachPitfall: Losing this When Extracting a MethodHow to get a warningHow to properly extract a methodCallbacks and extracted methodsPitfall: Functions Inside Methods Shadow thisWorkaround 1: that = thisWorkaround 2: bind()Workaround 3: a thisValue for forEach()Layer 2: The Prototype Relationship Between ObjectsInheritanceOverridingSharing Data Between Objects via a PrototypeGetting and Setting the PrototypeCreating a new object with a given prototypeReading the prototype of an objectChecking whether one object a prototype of another oneFinding the object where a property is definedThe Special Property __proto__Setting and Deleting Affects Only Own PropertiesSetting a propertyDeleting an inherited propertyChanging properties anywhere in the prototype chainIteration and Detection of PropertiesListing Own Property KeysListing All Property KeysChecking Whether a Property ExistsExamplesThe effects of enumerabilityThe effects of inheritanceComputing the number of own properties of an objectBest Practices: Iterating over Own PropertiesAccessors (Getters and Setters)Defining Accessors via an Object LiteralDefining Accessors via Property DescriptorsAccessors and InheritanceProperty Attributes and Property DescriptorsProperty AttributesDefault valuesProperty DescriptorsGetting and Defining Properties via DescriptorsCopying an ObjectProperties: Definition Versus AssignmentInherited Read-Only Properties Can’t Be Assigned ToEnumerability: Best PracticesProtecting ObjectsPreventing ExtensionsSealingFreezingPitfall: Protection Is ShallowLayer 3: Constructors—Factories for InstancesThe new Operator Implemented in JavaScriptTerminology: The Two PrototypesThe constructor Property of InstancesUse cases for the constructor propertyBest practiceThe instanceof OperatorPitfall: objects that are not instances of ObjectPitfall: crossing realms (frames or windows)Tips for Implementing ConstructorsProtection against forgetting new: strict modeReturning arbitrary objects from a constructorData in Prototype PropertiesAvoid Prototype Properties with Initial Values for Instance PropertiesBest practice: don’t share default valuesCreating instance properties on demandAvoid Nonpolymorphic Prototype PropertiesPolymorphic Prototype PropertiesKeeping Data PrivatePrivate Data in the Environment of a Constructor (Crockford Privacy Pattern)Public propertiesPrivate valuesPrivileged methodsAn exampleThe pros and cons of the Crockford privacy patternPrivate Data in Properties with Marked KeysPrivate Data in Properties with Reified KeysKeeping Global Data Private via IIFEsAttaching private global data to a singleton objectKeeping global data private to all of a constructorAttaching global data to a methodLayer 4: Inheritance Between ConstructorsInheriting Instance PropertiesInheriting Prototype PropertiesEnsuring That instanceof WorksOverriding a MethodMaking a SupercallAvoiding Hardcoding the Name of the SuperconstructorExample: Constructor Inheritance in UseExample: The Inheritance Hierarchy of Built-in ConstructorsAntipattern: The Prototype Is an Instance of the SuperconstructorMethods of All ObjectsConversion to PrimitiveObject.prototype.toLocaleString()Prototypal Inheritance and PropertiesGeneric Methods: Borrowing Methods from PrototypesAccessing Object.prototype and Array.prototype via LiteralsExamples of Calling Methods GenericallyArray-Like Objects and Generic MethodsPatterns for working with array-like objectsA List of All Generic MethodsPitfalls: Using an Object as a MapPitfall 1: Inheritance Affects Reading PropertiesChecking whether a property existsCollecting property keysGetting a property valuePitfall 2: Overriding Affects Invoking MethodsPitfall 3: The Special Property __proto__The dict Pattern: Objects Without Prototypes Are Better MapsNormal objectsPrototype-less objectsRecommendationBest PracticesCheat Sheet: Working with Objects
18. Arrays
OverviewArrays Are Maps, Not TuplesArrays Can Also Have PropertiesCreating ArraysThe Array ConstructorCreating an empty array with a given lengthInitializing an array with elements (avoid!)Multidimensional ArraysArray IndicesThe in Operator and IndicesDeleting Array ElementsArray Indices in DetaillengthManually Increasing the Length of an ArrayDecreasing the Length of an ArrayClearing an arrayClearing shared arraysThe Maximum LengthHoles in ArraysCreating HolesSparse Arrays Versus Dense ArraysWhich Operations Ignore Holes, and Which Consider Them?Array iteration methodsOther array methodsThe for-in loopFunction.prototype.apply()Removing Holes from ArraysArray Constructor MethodArray Prototype MethodsAdding and Removing Elements (Destructive)Sorting and Reversing Elements (Destructive)Comparing NumbersComparing StringsComparing ObjectsConcatenating, Slicing, Joining (Nondestructive)Searching for Values (Nondestructive)Iteration (Nondestructive)Examination MethodsTransformation MethodsReduction MethodsPitfall: Array-Like ObjectsBest Practices: Iterating over Arrays
19. Regular Expressions
Regular Expression SyntaxAtoms: GeneralAtoms: Character ClassesAtoms: GroupsQuantifiersAssertionsDisjunctionUnicode and Regular ExpressionsCreating a Regular ExpressionLiteral Versus ConstructorFlagsInstance Properties of Regular ExpressionsExamples of Creating Regular ExpressionsRegExp.prototype.test: Is There a Match?String.prototype.search: At What Index Is There a Match?RegExp.prototype.exec: Capture GroupsFirst Match (Flag /g Not Set)All Matches (Flag /g Set)String.prototype.match: Capture Groups or Return All Matching SubstringsString.prototype.replace: Search and ReplaceReplacement Is a StringReplacement Is a FunctionProblems with the Flag /gTips and TricksQuoting TextPitfall: Without an Assertion (e.g., ^, $), a Regular Expression Is Found AnywhereMatching Everything or NothingMatching everythingMatching nothingManually Implementing LookbehindRegular Expression Cheat Sheet
20. Dates
The Date ConstructorDate Constructor MethodsDate Prototype MethodsTime Unit Getters and SettersVarious Getters and SettersConvert a Date to a StringDate Time FormatsDate Formats (No Time)Time Formats (No Date)Date Time FormatsTime Values: Dates as Milliseconds Since 1970-01-01Converting a Date to a Number
21. Math
Math PropertiesNumerical FunctionsTrigonometric FunctionsOther Functions
22. JSON
BackgroundData FormatHistoryGrammarJSON.stringify(value, replacer?, space?)Data Ignored by JSON.stringify()The toJSON() MethodJSON.parse(text, reviver?)Transforming Data via Node VisitorsJSON.stringify()JSON.parse()
23. Standard Global Variables
ConstructorsError ConstructorsNonconstructor FunctionsEncoding and Decoding TextCategorizing and Parsing NumbersDynamically Evaluating JavaScript Code via eval() and new Function()Evaluating Code Using eval()Use eval() in strict modeIndirect eval() evaluates in global scopeEvaluating Code Using new Function()eval() Versus new Function()Best PracticesLegitimate use casesConclusionThe Console APIHow Standardized Is the Console API Across Engines?Simple LoggingChecking and CountingFormatted LoggingProfiling and TimingNamespaces and Special Values
24. Unicode and JavaScript
Unicode HistoryImportant Unicode ConceptsCode PointsUnicode EncodingsJavaScript Source Code and UnicodeSource Code InternallySource Code ExternallyJavaScript Strings and UnicodeEscape SequencesRefering to Astral Plane Characters via EscapesCounting CharactersUnicode NormalizationJavaScript Regular Expressions and UnicodeMatching Any Code Unit and Any Code PointLibrariesRecommended Reading and Chapter Sources
25. New in ECMAScript 5
New FeaturesSyntactic ChangesNew Functionality in the Standard LibraryMetaprogrammingNew MethodsJSONTips for Working with Legacy Browsers
IV. Tips, Tools, and Libraries
26. A Meta Code Style Guide
Existing Style GuidesGeneral TipsCode Should Be ConsistentCode Should Be Easy to UnderstandCommonly Accepted Best PracticesBrace StylesAllman style1TBS (One True Brace Style)JavaScriptPrefer Literals to ConstructorsDon’t Be CleverConditional operatorAbbreviating if statementsIncrement operatorChecking for undefinedConverting a number to an integerAcceptable ClevernessDefault valuesGeneric methodsECMAScript 5: trailing commasECMAScript 5: reserved wordsControversial RulesSyntaxVariablesObject OrientationMiscellaneousConclusion
27. Language Mechanisms for Debugging
28. Subclassing Built-ins
TerminologyObstacle 1: Instances with Internal PropertiesWorkaround for Obstacle 1CaveatsObstacle 2: A Constructor That Can’t Be Called as a FunctionWorkaround for Obstacle 2Another Solution: Delegation
29. JSDoc: Generating API Documentation
The Basics of JSDocSyntaxNaming TypesBasic TagsDocumenting Functions and MethodsInline Type Information (“Inline Doc Comments”)Documenting Variables, Parameters, and Instance PropertiesDocumenting ClassesDefining a Class via a Constructor FunctionDefining a Class via an Object LiteralDefining a Class via an Object Literal with an @constructs MethodSubclassingOther Useful Tags
30. Libraries
Shims Versus PolyfillsFour Language LibrariesThe ECMAScript Internationalization APIThe ECMAScript Internationalization API, Edition 1What Kind of Standard Is It?When Can I Use It?Further ReadingDirectories for JavaScript Resources
31. Module Systems and Package Managers
Module SystemsPackage ManagersQuick and Dirty Modules
32. More Tools
33. What to Do Next
Index
About the Author
Colophon
Copyright

Content preview from Speaking JavaScript

Chapter 24. Unicode and JavaScript

This chapter is a brief introduction to Unicode and how it is handled in JavaScript.

Unicode History

Unicode was started in 1987, by Joe Becker (Xerox), Lee Collins (Apple), and Mark Davis (Apple). The idea was to create a universal character set, as there were many incompatible standards for encoding plain text at that time: numerous variations of 8-bit ASCII, Big Five (Traditional Chinese), GB 2312 (Simplified Chinese), and more. Before Unicode, no standard for multilingual plain text existed, but there were rich-text systems (such as Apple’s WorldScript) that allowed you to combine multiple encodings.

The first Unicode draft proposal was published in 1988. Work continued afterward and the working group expanded. The Unicode Consortium was incorporated on January 3, 1991:

The Unicode Consortium is a non-profit corporation devoted to developing, maintaining, and promoting software internationalization standards and data, particularly the Unicode Standard [...]

The first volume of the Unicode 1.0 standard was published in October 1991, and the second in June 1992.

Important Unicode Concepts

The idea of a character may seem a simple one, but there are many aspects to it. That’s why Unicode is such a complex standard. The following are important basic concepts:

Characters and graphemes: These two terms mean something quite similar. Characters are digital entities, while graphemes are atomic units of written languages (alphabetic letters, typographic ligatures, ...

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

Publisher Resources

ISBN: 9781449365028Errata

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design