100% found this document useful (3 votes)
18 views63 pages

Get JavaScript Recipes: A Problem-Solution Approach 1st Edition Russ Ferguson Free All Chapters

ebook

Uploaded by

lamwaidarwex
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
100% found this document useful (3 votes)
18 views63 pages

Get JavaScript Recipes: A Problem-Solution Approach 1st Edition Russ Ferguson Free All Chapters

ebook

Uploaded by

lamwaidarwex
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
Download as pdf or txt
You are on page 1/ 63

Full download textbook at textbookfull.

com

JavaScript Recipes: A Problem-Solution


Approach 1st Edition Russ Ferguson

https://textbookfull.com/product/javascript-
recipes-a-problem-solution-approach-1st-edition-
russ-ferguson/

Download more textbook from https://textbookfull.com


More products digital (pdf, epub, mobi) instant
download maybe you interests ...

Android Recipes A Problem-Solution Approach Dave Smith

https://textbookfull.com/product/android-recipes-a-problem-
solution-approach-dave-smith/

Raku Recipes: A Problem-Solution Approach J.J. Merelo

https://textbookfull.com/product/raku-recipes-a-problem-solution-
approach-j-j-merelo/

C Recipes - A Problem-Solution Approach 1st Edition


Shirish Chavan

https://textbookfull.com/product/c-recipes-a-problem-solution-
approach-1st-edition-shirish-chavan/

wxPython Recipes: A Problem - Solution Approach 1st


Edition Mike Driscoll

https://textbookfull.com/product/wxpython-recipes-a-problem-
solution-approach-1st-edition-mike-driscoll/
MATLAB Recipes: a problem-solution approach 2nd Edition
Michael Paluszek

https://textbookfull.com/product/matlab-recipes-a-problem-
solution-approach-2nd-edition-michael-paluszek/

PrestaShop Recipes : A Problem-Solution Approach 1st


Edition Arnaldo Pérez Castaño (Auth.)

https://textbookfull.com/product/prestashop-recipes-a-problem-
solution-approach-1st-edition-arnaldo-perez-castano-auth/

Java EE 7 Recipes A Problem Solution Approach 1st


Edition Juneau Josh

https://textbookfull.com/product/java-ee-7-recipes-a-problem-
solution-approach-1st-edition-juneau-josh/

Java 9 Recipes: A Problem-Solution Approach 3rd Edition


Josh Juneau

https://textbookfull.com/product/java-9-recipes-a-problem-
solution-approach-3rd-edition-josh-juneau/

Spring 5 Recipes: A Problem-Solution Approach 4th


Edition Marten Deinum

https://textbookfull.com/product/spring-5-recipes-a-problem-
solution-approach-4th-edition-marten-deinum/
JavaScript
Recipes
A Problem-Solution Approach

Russ Ferguson
Keith Cirkel
JavaScript Recipes
A Problem-Solution Approach

Russ Ferguson
Keith Cirkel
JavaScript Recipes: A Problem-Solution Approach
Russ Ferguson Keith Cirkel
Ocean, New Jersey, USA London, United Kingdom
ISBN-13 (pbk): 978-1-4302-6106-3 ISBN-13 (electronic): 978-1-4302-6107-0
DOI 10.1007/978-1-4302-6107-0
Library of Congress Control Number: 2016960744
Copyright © 2017 by Russ Ferguson and Keith Cirkel
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage
and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or
hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with
every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an
editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are
not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director: Welmoed Spahr
Acquisitions Editor: Louise Corrigan
Technical Reviewer: Luca Mezzalira
Editorial Board: Steve Anglin, Pramila Balan, Laura Berendson, Aaron Black, Louise Corrigan,
Jonathan Gennick, Todd Green, Robert Hutchinson, Celestin Suresh John, Nikhil Karkal,
James Markham, Susan McDermott, Matthew Moodie, Natalie Pao, Gwenan Spearing
Coordinating Editor: Nancy Chen
Copy Editor: Kezia Endsley
Compositor: SPi Global
Indexer: SPi Global
Artist: SPi Global
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail
orders-ny@springer-sbm.com, or visit www.springer.com. Apress Media, LLC is a California LLC and the sole
member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is
a Delaware corporation.
For information on translations, please e-mail rights@apress.com, or visit www.apress.com.
Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use.
eBook versions and licenses are also available for most titles. For more information, reference our Special
Bulk Sales–eBook Licensing web page at www.apress.com/bulk-sales.
Any source code or other supplementary materials referenced by the author in this text are available to
readers at www.apress.com. For detailed information about how to locate your book’s source code, go to
www.apress.com/source-code/. Readers can also access source code at SpringerLink in the Supplementary
Material section for each chapter.
Printed on acid-free paper
This space is always reserved for my brother Rodd and my Dad.
You guys are severely missed.
—Russ
Contents at a Glance

About the Authors���������������������������������������������������������������������������������������������������� lv


Acknowledgments������������������������������������������������������������������������������������������������� lvii
Introduction������������������������������������������������������������������������������������������������������������ lix


■Chapter 1: Working with JavaScript Datatypes����������������������������������������������������� 1

■Chapter 2: Working with Expressions����������������������������������������������������������������� 49

■Chapter 3: Working with Strings������������������������������������������������������������������������� 91

■Chapter 4: Working with Numbers and Math���������������������������������������������������� 137

■Chapter 5: Working with Bitwise Operations Against 32-Bit Integers�������������� 151

■Chapter 6: Dates and Times������������������������������������������������������������������������������� 173

■Chapter 7: Working with Arrays������������������������������������������������������������������������ 181

■Chapter 8: Working with Arrays in Loops���������������������������������������������������������� 195

■Chapter 9: Working with Objects����������������������������������������������������������������������� 207

■Chapter 10: Working with Sets�������������������������������������������������������������������������� 225

■Chapter 11: Working with Maps������������������������������������������������������������������������ 233

■Chapter 12: Working with Functions����������������������������������������������������������������� 239

■Chapter 13: Working with Generators��������������������������������������������������������������� 255

■Chapter 15: Working with Symbols������������������������������������������������������������������� 267

■Chapter 16: Working with Proxies��������������������������������������������������������������������� 277

v
■ Contents at a Glance


■Chapter 17: Working with Classes�������������������������������������������������������������������� 281

■Chapter 18: Working with Events���������������������������������������������������������������������� 289

■Chapter 19: Debugging and Handling Exceptions���������������������������������������������� 295

■Chapter 20: Working with Regular Expressions������������������������������������������������ 301

■Chapter 21: Working with Asynchronous Control Flow and Promises�������������� 309

Index��������������������������������������������������������������������������������������������������������������������� 341

vi
Contents

About the Authors���������������������������������������������������������������������������������������������������� lv


Acknowledgments������������������������������������������������������������������������������������������������� lvii
Introduction������������������������������������������������������������������������������������������������������������ lix


■Chapter 1: Working with JavaScript Datatypes����������������������������������������������������� 1
Assigning Variables with the var Statement��������������������������������������������������������������������� 1
Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 1
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 1
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 1
How It Works������������������������������������������������������������������������������������������������������������������������������������������� 1

Solving Errors with Variable Names��������������������������������������������������������������������������������� 2


Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 2
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 2
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 3
How It Works������������������������������������������������������������������������������������������������������������������������������������������� 3

Solving Reference Errors When Declaring Variables Inside a Function’s Scope������������� 3


Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 3
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 4
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 4
How It Works������������������������������������������������������������������������������������������������������������������������������������������� 4

Assigning Variables with the Let Statement��������������������������������������������������������������������� 6


Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 6
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 6
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 6
How It Works������������������������������������������������������������������������������������������������������������������������������������������� 7

vii
■ Contents

Assigning Constants with the Const Statement��������������������������������������������������������������� 7


Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 7
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 8
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 8
How It Works������������������������������������������������������������������������������������������������������������������������������������������� 8
Creating and Using Literals���������������������������������������������������������������������������������������������� 8
Problem�������������������������������������������������������������������������������������������������������������������������������������������������� 9
Solution�������������������������������������������������������������������������������������������������������������������������������������������������� 9
The Code������������������������������������������������������������������������������������������������������������������������������������������������� 9
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 10
Creating Types Using Their Constructors������������������������������������������������������������������������ 10
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 10
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 10
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 10
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 11
Determine If a Variable Has Been Defined Using an Equality Operator�������������������������� 11
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 11
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 11
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 11
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 12
Determining If a Variable Has Been Declared Using typeof( )����������������������������������������� 12
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 12
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 12
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 12
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 13
Determining If a Function Defines and Returns a Value������������������������������������������������� 13
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 13
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 13
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 13
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 15

viii
■ Contents

Determining If a Defined Variable Has a Value Using Equality Operators�������������������� 15


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 15
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 16
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 16
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 17

Performing Operations If a Defined Variable Has a Value����������������������������������������������� 17


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 17
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 17
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 17
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 18

What’s the Difference Between Null and Undefined?���������������������������������������������������� 18


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 18
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 18
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 19
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 19

Coercing a Boolean Variable Using the Boolean Constructor����������������������������������������� 19


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 19
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 19
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 20
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 20

Determining If a Boolean Variable Is Initialized�������������������������������������������������������������� 20


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 20
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 21
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 21
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 22

Valid Representations of the False and True Values������������������������������������������������������� 22


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 22
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 22
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 22
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 24

ix
■ Contents

Coercing a String Using the String Constructor������������������������������������������������������������� 24


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 24
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 24
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 24
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 25

Determining If a Variable Is a String������������������������������������������������������������������������������� 25


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 25
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 25
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 25
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 26

Coercing a Numeric Value Using the Number Constructor��������������������������������������������� 26


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 26
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 26
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 26
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 27

Creating a Numeric Value Using Number Literals���������������������������������������������������������� 27


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 27
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 27
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 28
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 29

Determining If a Defined Variable Is a Number�������������������������������������������������������������� 29


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 29
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 29
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 29
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 30

Dealing with NaN and Infinity����������������������������������������������������������������������������������������� 30


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 30
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 31
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 31
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 32

x
■ Contents

Generating a Date Using the Date Object����������������������������������������������������������������������� 32


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 32
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 32
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 32
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 33

Generating a Date with a Date String����������������������������������������������������������������������������� 33


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 33
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 33
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 33
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 34

Determining If a Defined Variable Is a Date�������������������������������������������������������������������� 34


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 34
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 35
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 35
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 35

Creating an Object and Assigning Properties����������������������������������������������������������������� 36


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 36
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 36
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 36
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 37

Determining If a Defined Variable Is an Object��������������������������������������������������������������� 37


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 37
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 37
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 38
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 38

Determining If an Object Is an Instance������������������������������������������������������������������������� 38


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 38
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 38
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 39
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 40

xi
■ Contents

Determining an Object’s Direct Instance with the Constructor Property������������������������ 40


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 40
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 40
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 40
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 41
Determining If Something Is a Plain Object�������������������������������������������������������������������� 42
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 42
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 42
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 42
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 43
Creating an Array and Assigning and Retrieving Values������������������������������������������������� 43
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 43
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 43
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 43
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 44
Choosing Between Objects and Arrays�������������������������������������������������������������������������� 44
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 44
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 44
Creating a Regular Expression Literal���������������������������������������������������������������������������� 45
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 45
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 45
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 45
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 46
Injecting Variables into a String with Template Literals������������������������������������������������� 46
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 46
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 46
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 47
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 47


■Chapter 2: Working with Expressions����������������������������������������������������������������� 49
Performing an Addition with the + Operator������������������������������������������������������������������ 49
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 49
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 49
xii
■ Contents

The Code����������������������������������������������������������������������������������������������������������������������������������������������� 49
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 50
Performing a Subtraction with the - Operator���������������������������������������������������������������� 50
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 50
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 50
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 50
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 51
Performing Multiplication with the * Operator��������������������������������������������������������������� 51
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 51
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 51
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 51
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 52
Performing Division with the / Operator������������������������������������������������������������������������� 52
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 52
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 52
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 52
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 52
Getting the Remainder of a Division Operation with the Modulo (%) Operator�������������� 53
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 53
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 53
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 53
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 53
Determining If a Value Is Less Than Another with the < Operator���������������������������������� 54
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 54
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 54
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 54
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 55
Determining If a Value Is Greater than Another with the > Operator������������������������������ 55
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 55
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 55
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 55
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 56
xiii
■ Contents

Determining If a Value Is Less than or Equal to Another with the <= Operator����������� 56
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 56
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 56
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 56
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 57

Determining If a Value Is Greater than or Equal to Another with the >= Operator��������� 57
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 57
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 57
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 58
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 58

Determining If a Value Is Equivalent to Another Using the == Operator������������������������ 59


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 59
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 59
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 59
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 60

Determining If a Value Is Strictly Equal to Another Using the === Operator��������������� 62


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 62
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 62
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 62
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 63

Determining If a Value Is Not Equivalent to Another Using the != Operator������������������� 64


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 64
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 64
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 65
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 66

Determining If a Value Is Strictly Not Equal to Another Using the !== Operator������������ 66
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 66
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 66
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 67
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 68

xiv
■ Contents

Using the Increment (++) Operator to Increase the Value of a Number Variable����������� 69
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 69
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 69
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 70
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 70

Using the Decrement (--) Operator to Decrease the Value of a Number Variable����������� 70
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 70
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 71
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 71
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 71

Using the Unary Addition (+) Operator to Coerce an Object to a Number���������������������� 71


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 71
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 72
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 72
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 72

Using the Unary Subtraction (-) Operator to Flip the Sign of a Number������������������������� 72
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 72
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 73
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 73
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 73

Using the Logical NOT (!) Operator to Toggle a Boolean Value��������������������������������������� 73


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 73
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 73
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 74
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 74

Deleting an Object, Property, or Array Element with the Delete Operator���������������������� 74


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 74
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 74
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 75
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 75

xv
■ Contents

Evaluating an Expression Without a Return Value with the Void Operator��������������������� 76


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 76
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 76
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 76
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 77

Determining the Type of a Variable with the typeof Operator����������������������������������������� 77


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 77
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 77
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 78
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 78

Using instanceof to Determine If a Variable Is an Instance of an Object������������������������ 79


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 79
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 79
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 79
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 81

Finding Properties in an Object with the in Operator����������������������������������������������������� 81


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 81
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 81
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 82
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 83

Using Logical AND (&&) for Combining Boolean Expressions in an if Statement,


with Short-Circuit Evaluation����������������������������������������������������������������������������������������� 83
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 83
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 83
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 83
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 84

Using Logical OR (||) Short-Circuit Evaluation in an if Statement����������������������������������� 84


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 84
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 84
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 85
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 86

xvi
■ Contents

Simplifying Variable Assignments Using the Conditional (?) Operator��������������������������� 86


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 86
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 86
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 86
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 87

Specifying Multiple Expressions Using the Comma Operator���������������������������������������� 88


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 88
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 88
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 88
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 89


■Chapter 3: Working with Strings������������������������������������������������������������������������� 91
Understanding Unicode Strings�������������������������������������������������������������������������������������� 91
Problem������������������������������������������������������������������������������������������������������������������������������������������������ 91
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 91
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 91
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 92

Using Special Characters (Escape Codes) in Strings����������������������������������������������������� 93


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 93
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 93
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 93
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 93

Comparing Two Strings for Equality������������������������������������������������������������������������������� 93


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 93
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 94
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 94
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 94

Determining a String’s Length���������������������������������������������������������������������������������������� 95


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 95
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 95
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 95
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 95

xvii
■ Contents

Concatenating Strings with the + Operator������������������������������������������������������������������� 96


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 96
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 96
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 96
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 96

Getting a Single Character from a String����������������������������������������������������������������������� 97


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 97
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 97
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 97
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 97

Creating a String of UTF Character Code Units with fromCharCode( )���������������������������� 98


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 98
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 98
The Code����������������������������������������������������������������������������������������������������������������������������������������������� 98
How It Works����������������������������������������������������������������������������������������������������������������������������������������� 99

Creating a String of UTF Code Points with fromCodePoint( )������������������������������������������ 99


Problem������������������������������������������������������������������������������������������������������������������������������������������������ 99
Solution������������������������������������������������������������������������������������������������������������������������������������������������ 99
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 100
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 100

Getting a Single Character’s UTF Code Unit from a String with charCodeAt( )������������� 100
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 100
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 101
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 101
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 101

Getting a Single Character’s UTF Code Point from a string with codePointAt( )����������� 102
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 102
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 102
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 102
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 103

xviii
■ Contents

Iterating Over a String’s code Units Using for...in��������������������������������������������������������� 103


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 103
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 103
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 103
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 103
Iterating Over a String’s Code Points Using for...of������������������������������������������������������ 104
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 104
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 104
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 104
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 105
Repeating a String with repeat( )���������������������������������������������������������������������������������� 105
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 105
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 105
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 105
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 106
Determining If a String Contains a Smaller String Using contains( )���������������������������� 106
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 106
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 106
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 106
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 107
Determining If a String Starts with a Smaller String using startsWith( )���������������������� 108
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 108
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 108
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 108
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 109
Determining If a String Ends with a Smaller String Using endsWith( )������������������������� 110
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 110
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 110
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 110
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 111

xix
■ Contents

Finding the Index of an Occurring Substring with indexOf( )���������������������������������������� 112


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 112
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 112
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 112
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 113

Finding the Index of the Last Occurrence of a Substring with lastIndexOf( )���������������� 113
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 113
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 113
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 113
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 114

Finding Many Matches of a Substring with match( )���������������������������������������������������� 114


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 114
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 114
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 115
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 115

Replacing Parts of a String with replace( )������������������������������������������������������������������� 115


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 115
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 115
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 116
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 116

Searching a String Using a Regular Expression with search( )��������������������������������������� 116


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 116
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 117
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 117
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 117

Getting a Substring Form a String with slice( )������������������������������������������������������������� 118


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 118
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 118
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 118
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 118

xx
■ Contents

Splitting Strings with .split( )���������������������������������������������������������������������������������������� 118


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 118
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 119
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 119
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 119
Changing String Case with toUpperCase( ) and toLowerCase( )����������������������������������� 120
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 120
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 120
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 120
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 120
Stripping Blank Spaces with trim( )������������������������������������������������������������������������������ 121
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 121
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 121
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 121
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 121
Determining If a String “Comes Before” Another with localeCompare( )���������������������� 122
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 122
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 122
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 122
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 123
Counting the Occurrences of a Substring�������������������������������������������������������������������� 123
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 123
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 123
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 124
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 125
Padding a String with a Custom Function�������������������������������������������������������������������� 125
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 125
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 125
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 125
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 126

xxi
■ Contents

Truncating a String with a Custom Function���������������������������������������������������������������� 127


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 127
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 128
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 128
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 128
Making a ROT13 Cypher with a Custom Function�������������������������������������������������������� 129
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 129
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 129
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 129
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 130

Calculating the Levenshtein Distance Between Two Strings with a


Custom Function���������������������������������������������������������������������������������������������������������� 131
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 131
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 131
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 132
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 132


■Chapter 4: Working with Numbers and Math���������������������������������������������������� 137
Converting Strings to Numbers������������������������������������������������������������������������������������ 137
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 137
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 137
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 137
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 138
Creating a Number Object�������������������������������������������������������������������������������������������� 138
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 138
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 138
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 138
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 138

Checking If a Value Is Not a Number���������������������������������������������������������������������������� 139


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 139
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 139
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 139
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 139
xxii
■ Contents

Formatting a Number to a Fixed Amount of Digits������������������������������������������������������� 139


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 139
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 139
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 140
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 140

Checking to See If a Number Is Finite�������������������������������������������������������������������������� 140


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 140
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 140
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 140
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 141

Checking If a Value Is an Integer���������������������������������������������������������������������������������� 141


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 141
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 141
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 141
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 142

Formatting Numbers for Date Time and Currency�������������������������������������������������������� 142


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 142
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 142
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 142
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 142

Creating a Random Number Generator������������������������������������������������������������������������ 143


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 143
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 143
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 143
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 143

Finding the Absolute Value of a Number���������������������������������������������������������������������� 143


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 143
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 143
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 144
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 144

xxiii
■ Contents

Using Math.max to Determine the Highest Number����������������������������������������������������� 144


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 144
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 144
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 144
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 145

Returning the Square Root of a Number���������������������������������������������������������������������� 145


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 145
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 145
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 145
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 145

Using Coercion and Performing Equations������������������������������������������������������������������� 145


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 145
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 145
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 146
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 146

What’s the Difference Between Math.floor() and Math.ceil()?�������������������������������������� 146


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 146
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 146
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 147
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 147

Returning a Number in Reverse����������������������������������������������������������������������������������� 147


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 147
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 147
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 147
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 148

Determining the Length of a Number��������������������������������������������������������������������������� 148


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 148
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 148
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 148
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 148

xxiv
■ Contents

Swapping Two Numbers Without a Temporary Variable����������������������������������������������� 149


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 149
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 149
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 149
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 149


■Chapter 5: Working with Bitwise Operations Against 32-Bit Integers�������������� 151
What Are 32-Bit Integers?�������������������������������������������������������������������������������������������� 151
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 151
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 151
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 151
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 151
Multiplying by Powers of 2 with the Left Shift (<<) Operator�������������������������������������� 152
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 152
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 152
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 152
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 152
Dividing by Powers of 2 with the Sign-Propagating Right Shift (>>) Operator������������ 154
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 154
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 154
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 154
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 155
Using the Zero-Fill Right Shift (>>>) Operator to Ensure a Variable
Is a 32-Bit Unsigned Integer����������������������������������������������������������������������������������������� 156
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 156
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 156
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 156
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 157
Using the Bitwise NOT (~) Operator to Swap All Binary Bits in a 32-Bit Integer���������� 158
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 158
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 158
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 158
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 158
xxv
■ Contents

Using Bitwise AND (&) Operator to Get a Value of All Equal Bits in a 32-Bit Integer����� 159
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 159
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 160
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 160
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 160

Using Bitwise OR (|) Operator to Get a Value Positive Bits on One or Both Operands�� 161
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 161
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 161
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 162
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 162
Using the Bitwise XOR (^) Operator to Get a Value of Differing Bits in Each Operand�������� 163
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 163
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 163
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 163
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 164
Converting RGB Color to Hexadecimal and Back Using
the Bitwise Signed Shift (>>, <<) Operators and the Bitwise AND (&) Operator��������� 165
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 165
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 165
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 165
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 166
Creating, Editing, and Testing a Bit Field Flag Set Using Bitwise Operators����������������� 169
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 169
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 169
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 169
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 170


■Chapter 6: Dates and Times������������������������������������������������������������������������������� 173
Using the Date Object��������������������������������������������������������������������������������������������������� 173
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 173
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 173
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 173
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 173
xxvi
■ Contents

Getting Date and Time Information������������������������������������������������������������������������������ 174


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 174
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 174
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 174
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 174

Calculating User Age���������������������������������������������������������������������������������������������������� 175


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 175
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 175
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 175
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 175

Using the HTML5 Date Input Field to Make a Date Object�������������������������������������������� 175
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 175
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 175
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 176
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 176

Checking If Two Dates Are the Same���������������������������������������������������������������������������� 177


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 177
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 177
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 177
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 177

Working with getTimezoneOffset��������������������������������������������������������������������������������� 177


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 177
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 177
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 178
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 178

Formatting Date and Time�������������������������������������������������������������������������������������������� 178


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 178
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 178
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 179
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 179

xxvii
■ Contents

Calculating Days from a Certain Date�������������������������������������������������������������������������� 179


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 179
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 179
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 179
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 180

Checking If Your Date Is in a Range of Dates��������������������������������������������������������������� 180


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 180
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 180
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 180
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 180


■Chapter 7: Working with Arrays������������������������������������������������������������������������ 181
What Is an Array?��������������������������������������������������������������������������������������������������������� 181
Problem���������������������������������������������������������������������������������������������������������������������������������������������� 181
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 181
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 181
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 181

How Do You Access Elements in an Array?������������������������������������������������������������������ 181


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 181
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 182
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 182
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 182

How Do You Create a Multi-Dimensional Array?����������������������������������������������������������� 182


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 182
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 182
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 182
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 182

How Do You Initialize an Array with Values?����������������������������������������������������������������� 183


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 183
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 183
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 183
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 183

xxviii
■ Contents

What Is the Size of the Array?�������������������������������������������������������������������������������������� 183


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 183
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 183
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 183
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 183

How Do You Convert an Array to a String?������������������������������������������������������������������� 184


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 184
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 184
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 184
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 184

How Do You Add an Element to the End of an Array?��������������������������������������������������� 184


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 184
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 184
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 184
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 185

How Do You Add Items to an Array Within a Range?���������������������������������������������������� 185


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 185
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 185
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 185
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 185

How Do You Append an Array to the End of Another Array?����������������������������������������� 185


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 185
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 185
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 185
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 186

How Do You Reverse the Order of the Items in an Array?�������������������������������������������� 186


Problem���������������������������������������������������������������������������������������������������������������������������������������������� 186
Solution���������������������������������������������������������������������������������������������������������������������������������������������� 186
The Code��������������������������������������������������������������������������������������������������������������������������������������������� 186
How It Works��������������������������������������������������������������������������������������������������������������������������������������� 186

xxix
Another random document with
no related content on Scribd:
Pietarin kirkossa ja sen tulee olla avoinna kaikille tulijoille.»

»Bene!»

»Teidän pyhyytenne lukee siunauksen messun loputtua joko sedia


gestatore'sta suuren alttarin edessä ja kansan keskellä, kuten
Gregorius paavilla oli tapana, tai loggiasta tuomiokirkon puolella.»

»Määrätään, että se tapahtuu edellisessä paikassa.»

»Lavanda toimitetaan kello neljä iltapäivällä Pietarin kirkossa, ja


kaikilla on vapaa pääsy sinne.»

»Bene!»

»Paavillinen hovi pitää vahtia 'haudan' ympärillä, ja kello yhdeksän


teidän pyhyytenne astuu huoneistostaan sinne ylimyskaartin ja
sveitsiläisen kaartin kantaessa tulisoihtuja.»

»Bene!»

»Sitten teidän pyhyytenne lepää tunnin verran sakaristossa,


kunnes tulee Tenebroe'n aika.»

»Pyhän Pietarinko sakaristossa?»

»Niin, teidän pyhyytenne.»

»Puoli kymmenen ja puoli yhdentoista välillä?»

»Aivan niin. Tenebroe alkaa kello kymmenen, kuten vanhoina


aikoina, ja jos teidän pyhyytenne tahtoo olla läsnä valtaistuimella, on
teidän pyhyytenne puettu punaiseen viittaan ja hiippaan, mutta jos
teidän pyhyytenne ei tahdo näyttäytyä julkisesti, vetäydytte
yksityislehterille.»

»Bene!»

Pienen majordomon kasvot loistivat ilosta hänen jatkaessaan


lukuaan ja ajatellessaan tuota tulevaa komeutta, mutta paavi näytti
väsyneeltä, ja »Bene» kaikui hitaasti ja hiljaa.

Kello oli nyt kymmenen, ja Cortis, paavin kamaripalvelija, toi


tavallisen keittolautasen paaville. Sitten saapui iso, ylpeännäköinen,
tumma-ihoinen mies puettuna punareunaiseen purppuraviittaan ja
punaiseen hattuun. Se oli kardinaali-valtiosihteeri.

»Mitä uutisia, teidän kunnianarvoisuutenne?» kysyi paavi.

»Hallitus», sanoi kardinaalisihteeri, »on juuri julaissut


tiedonannon, jossa ilmoitetaan riemujuhlan vietosta kuninkaan
valtaistuimellenousun muistoksi. Se on alkava ensi maanantaina
suurin juhlin ja huvituksin.»

»Riemujuhla tällaiseen aikaan! Mitä kamalaa kansan kärsimysten


pilkkaamista! Kuinka monta nais- ja lapsiparkaa saa kärsiä nälkää,
ennenkuin tuo kuninkaallinen irstas juhla on maksettu! Jumala
olkoon kanssamme! Tuollainen vääryys ja hirmuvalta lempeyden ja
armon saatanallisessa valepuvussa melkein riittää selittämään Rossin
kaltaisten miesten opit… Onko muita uutisia?»

»On. Rossi on nyt Pariisissa läheisessä yhteydessä kaikenlaisten


huonojen seurojen kanssa.»

»Oletteko koskaan nähnyt tuota miestä, Rossia?»


»Teidän pyhyytenne käskystä olen kerran tavannut hänet
jesuiittakollegiossa.»

»Oliko hän ulkomuodoltaan tyypillinen demagogi?»

»Ei. Minun täytyy se tunnustaa, teidän pyhyytenne. Ja hänen


puheessaan, vaikka se uhkuu nykyaikaista vapaamielisyyttä, ei ole
mitään Voltairen likaisuudesta.»

»Joku sanoi… kuka se nyt olikaan?… että hän on pyhän isän


näköinen.»

»Nyt, kun mainitsette sen, teidän pyhyytenne, myönnän, että hän


ehkä hiukan muistuttaa pyhää isää.»

»Ah! Kuka tietää mitä palveluksia sellainenkin mies olisi voinut


tehdä Jumalalle ja yhteiskunnalle, jos hänen aikaisin elämänsä olisi
saanut parempaa johtoa.»

»Sanotaan, että hän on orpo, teidän pyhyytenne.»

»Hän ei siis koskaan ole saanut kokea isän huolenpitoa ja johtoa!


Onneton poika! Onneton isä! Mutta oi laupias taivas, jos tuollaisen
pojan isä vielä olisi elossa ja saisi tietää, että hänen opetustensa
johdosta tai hänen huolimattomuutensa tähden hänen oma sikiönsä
on muuttunut kerettiläiseksi, kapinalliseksi ja turmeluksen johtajaksi
— mikä kurjuus, mikä katumus!»

»Monsignor Mario», ilmoitti kamariherran matala ääni, ja


seuraavassa silmänräpäyksessä pääministerin luona ollut paavin
lähettiläs polvistui keskelle lattiaa.
Hermostuneella äänellä ja katkonaisin lausein ja nostaen joskus
katseensa nähdäkseen, minkä vaikutuksen hänen sanansa
aikaansaivat, monsignor Mario kertoi tapahtumasta. Paavi kuunteli
tarkkaan, ja rypyt hänen otsallaan syvenivät ja synkistyivät, kunnes
hän vihdoin huudahti kärsimättömästi:

»Mutta, poikani, ethän sanone, että kerroitkin kaiken tuon?»

»Minut houkuteltiin sanomaan, minun täytyi puolustaa teidän


pyhyyttänne.»

»Sanoit siis pääministerille, että minä sain tietoni uskottuna


asiana?»

»Hän viittasi siihen, että teidän pyhyytenne ehkä rikkoi


rippisalaisuuden…»

»Ja sanoit, että kertoja ei ollut katolilainen?»

»Hän tarttui siihen kiinni, että teidän pyhyytenne aivan hyvin


saattoi pakottaa kertojan ilmaisemaan salahankkeet vallanpitäjiä
vastaan, ja siitä syystä…»

»Ja kerroit hänelle, että tuo ilmoittaja oli ollut täällä


lauantaiaamuna?»

»Hän viittasi siihen, että teidän pyhyytenne on liitossa


rikoksellisten kanssa, jos teidän pyhyytenne on tiennyt asiasta jo
kauan ilmoittamatta hallitukselle, ja…»

»Ja samalla hetkellä neiti astui sisään, niinkö?»


»Samalla hetkellä, teidän pyhyytenne, ja hän sanoi tavanneensa
minut lauantaiaamuna.»

»Mies, mitä sinä olet tehnyt?» huudahti paavi nousten ja astuen


kiivaasti huoneessa.

Monsignor polvistui yhä vielä nöyryytettynä, kunnes paavi


malttaen mielensä asetti molemmat kätensä hänen olkapäilleen
sanoen:

»Anteeksi, poikani! Minä olen syyllisempi kuin sinä. Oli väärin, että
lähetin suusanallisen viestin kettujen luolaan. Pyhän isän ei pitäisi
olla missään tekemisissä sellaisten ihmisten kanssa. Mutta kaikki on
Jumalan kädessä. Jättäkäämme kaikki Pyhän Hengen valtaan.»

Samassa paavin majordomo palasi tuoden kirjeen. Se oli paronin


kirje paaville. Kun paavi oli lukenut sen, astui hän viereiseen
huoneeseen, jossa ei ollut muuta kuin lepotuoli ja nojatuoli. Siellä
hän makasi kauan aikaa kasvot kääntyneinä seinään päin.
XII.

Kello neljä iltapäivänä paavi ja isä Pifferi taas kävelivät puutarhassa.


Juudas-puut olivat kylväneet punaisia kukkiaan pitkin tietä, ilma oli
täynnä orvokkien tuoksua, ja pääskyt lentelivät auringonpaisteessa
kimakasti kirkuen ja siivet välähdellen.

»Ja mitä teidän pyhyytenne aikoo tehdä?» kysyi kapusiinilainen.

»Taivas johtakoon meitä», vastasi paavi huoahtaen.

»Mutta kai teidän pyhyytenne vastaa kieltävästi hallituksen


pyyntöön?»

»Kuinka voin sen tehdä antamatta aihetta väärinkäsitykseen?


Ajatelkaas, että kuningas surmataan. Hallitus on vakuutteleva
maailmalle, että paavi tiesi edeltäkäsin kaikki, mutta ei tehnyt
mitään.»

»Vakuutelkoon. Semmoista on ennenkin sattunut kirkon


historiassa. Ja maailma on kunnioittava teidän pyhyyttänne sitä
enemmän siksi, että lujasti varjelitte ihmissielun pyhää salaisuutta.»
»Niin — jos nyt olisi kysymyksessä rippi. Maailma tietää, että rippi
on pyhä ja että sitä ei saa ilmaista. Mutta nyt ei ole kysymyksessä
rippisalaisuus.»

»Eikö teidän pyhyytenne sanonut, että piditte sitä sellaisena?»

»Niin pidinkin. Mutta entä yleisö? Sattumalta hallitus on saanut


selville, että tämä ei ole rippisalaisuus, ja sen se kertoo maailmalle.
Mikä on seurauksena? Jos kieltäydyn tekemästä mitään, selittävät
kirkon viholliset, että pyhä isä on osallisena kuninkaanmurhaan ja
valmis vehkeilemään kapinallisten kanssa voittaakseen takaisin
maallisen valtansa.»

»Teidän pyhyytenne ottaa siis vastaan pääministerin?»

»En! Tai jos sen teen, saa hän tulla ainoastaan herransa
seurassa.»

»Kuninkaanko?»

»Niin.»

Kapusiinilainen kosketti patalakkiaan levottomasti ja astui pari


askelta virkkamatta mitään.

»Luuletteko hänen tulevan?»

»Jos hän luulee, että minä tiedän salaisuuden, josta hänen


elämänsä riippuu, on hän tuleva.»

»Mutta te olette hallitsija yhtä hyvin kuin kuningas — voitteko


vastaanottaa hänet?»
»Minä voin vastaanottaa hänet Sardinian kuninkaana, tahi
vaikkapa
Italiankin kuninkaana, mutta en Rooman kuninkaana.»

Kapusiinilainen otti kirjavan nenäliinansa hihastaan ja puristi sitä


käsissään, jotka olivat kuumat ja hikiset.

»Mutta, pyhä isä», sanoi hän, »mitä hyötyä siitä on?


Otaksukaamme, että kaikki etiketti-esteet ovat poistetut, että
tapaatte toisenne aivan kuin ihminen tapaa ihmisen, Davido Leone ja
Alberto Carlo — miksi kuningas tulee? Ainoastaan pyytääkseen teitä
koettamaan saada lisätietoja kertojaltanne.»

Paavi ojentautui suoraksi ja löi rintaansa. »Ei ikinä! Se olisi


loukkaus kirkkoa kohtaan», huudahti hän. »Toinen asia on pyytää
pyhää isää tekemään velvollisuutensa kristittynä vihollistaankin
kohtaan ja toinen asia on pyytää häntä pettämään yksityisen
henkilön luottamusta.»

Kapusiinilainen ei vastannut, ja molemmat vanhat miehet astuivat


ääneti. Kun valo alkoi pehmitä, kiihtyi pääskyjen melu, ja
laululintuset läheisissä puissa alkoivat lennellä sinne päin. Äkkiä
kuului pelokas ääni pensaikosta, ja kääntyen nopeasti ympäri paavi
nosti ylös kissan, joka tavallisuuden mukaan hiipi hänen
kantapäillään.

»Voi sinua Mirri! Sainpa sinut kiinni nyt… Taas säikäytit pientä
lintuemoraukkaa. Missähän sen pesä lienee?»

He löysivät sen vanhan hautakiven luota, joka nyt oli melkein


kokonaan lehtien peitossa. Munat olivat nyt haudotut, ja silmättömät
poikaset kurottivat kaulaansa ja avasivat suunsa, kun paavi ojensi
kätensä koskettaakseen niitä.

»Monsignor», sanoi paavi, »muistuttakaa minua huomenna, jotta


tulen pyytäneeksi puutarhurilta hiukan matoja niille».

Kissa kurkisteli nälkäisin silmin paavin kainalosta linnunpesää.

»Paha Mirri! Paha!» sanoi paavi ja näppäsi sormellaan kissaa.


»Mutta Mirri seuraa vain luontoaan, ja minä tein ehkä hullusti, kun
annoin sen nähdä pesän.»

Paavi ja kapusiinilainen astuivat takaisin Vatikaaniin nauttien


suloisesta keväästä, kukkien tuoksusta ja lintujen laulusta.

»Te olette surullinen tänään, isä Pifferi», sanoi paavi.

»Ajattelen sitä tyttöraukkaa», sanoi kapusiinilainen.

Illan ensimmäisenä hetkenä paavi oli läsnä rukouksessa


yksityisessä kappelissa ja palattuaan sieltä työhuoneeseensa, jossa
oli pöytä ja pari tuolia, hän söi kevyen illallisen, jota Cortis puettuna
hännystakkiin tarjoili. Ainoana toverina hänellä oli kissa, joka istui
tuolilla toisella puolen pöytää. Illallisen jälkeen hän kirjoitti kirjeen:

»Sire! — Teidän ministerinne on ilmoittanut meille, että hän on


virallista tietä saanut vastaanottaa ilmoituksen salaliitosta
henkeänne vastaan ja hän luulee, että me voimme antaa hänelle
tietoja, jotka auttavat häntä vastustamaan tuota viheliäistä
hanketta, sekä pyytää siitä syystä audienssia luonamme. Ei ole
vallassamme antaa sen enempää apua kuin jo olemme antanut,
mutta jos Teidän Majesteettinne itse haluaa tavata meitä, olemme
valmiit vastaanottamaan Teidät joko ministerinne kanssa tai ilman
häntä, jos tahdotte tulla aivan yksityisesti ja ilman muuta seuruetta
ensi torstaina kello 1/2 10 Pyhän Pietarin kirkon kanoniikin ovelle,
josta tämän viestin tuoja on johtava Teidän Majesteettinne
sakaristoon.

Nil timendum nisi a Deo.

Pius P.P.X.»

Käskettyään ylimyskaartin upseeria viemään tuon kirjeen


Kvirinaaliin ja neuvottuaan häntä pitämään huolta salaisuudesta ja
tuomaan takaisin vastauksen, paavi istuutui katsomaan
sanomalehtiä, joita hänen lukijansa olivat merkinneet hänelle, sekä
odottamaan ja miettimään.

Tunti kului, eikä ylimyskaartin upseeria vielä kuulunut. Paavi nousi


ja katsoi ulos ikkunasta. Piazza hänen edessään oli hiljainen ja
rauhallinen kuin vuoriston järvi, eikä kuulunut muita ääniä kuin
suihkukaivojen lorina. Niiden välissä kohosi tumma patsas, jossa oli
tulinen kirjoitus: »Kristus voittaa, Kristus hallitsee, Kristus
riemuitsee.» Torin reunassa häämötti pääministerin palatsi, joka
kerran oli ollut paavin oman isän koti, tuon erehtyvän, mutta
rakastavan vanhan isän, joka nyt oli maannut kolmekymmentäviisi
vuotta haudassa. Ja sen takana oli humuava, kaunis Rooma!

Katsellen kaupunkia, joka päilyi tuolla iltavalaistuksessa, paavi


tunsi liikutusta. Ikuinen kaupunki! Pyhä kaupunki! Paavin kaupunki!
Kadonnut häneltä hetkeksi, mutta yhä vielä hänen lastensa
kaupunki!

Näky oli liikuttava. Tällä samalla paikalla entisten aikojen paavit


olivat uneksineet mahtavat unelmansa ihmiskunnan taivaallisesta
hallinnosta, pyhästä valtakunnasta maan päällä. Ja nyt, saattamatta
sanoa omakseen jalan leveyttäkään maata, paavi oli vankina oman
kansansa keskuudessa, ja hänen palatsinsa oli vankikoppi.

Mutta mitäpä siitä! »Kristus voittaa, Kristus hallitse, Kristus


riemuitsee!» Rooma oli kerran palaava kuin tuhlaajapoika isänsä luo,
joka odottaa sitä syli avoinna. Tämä aika huokaili jo uuden
syntymisen tuskissa ja se oli syntyvä uskonnon ja kirkon omaksi. Ja
paavi, jolla oli pieni kuningaskunta, mutta valta koko maailman yli
ilman armeijoja, ilman veroja, oli johtava, mutta ei hallitseva,
ohjaava, mutta ei käskevä, ja hän oli oleva maailman kansainvälinen
tuomari sekä henkisissä että aineellisissa asioissa!

Tyynnyttääkseen hermojaan, joita tuo suuri unelma oli kiihoittanut,


ja unohtaakseen kärsimättömyytensä odottaessaan lähettiläänsä
palaamista paavi veti uutimen pois kirjahyllynsä edestä, otti sieltä
kirjan ja alkoi lukea.

Se oli vanha, mustalehtinen kirja, kirjapainotaidon ensi ajoilta, ja


sillä lehdellä, jonka hän avasi, seisoi:

»Jumala, joka tietää, kuinka vaarallinen sellainen voimien yhdistys


on, ja joka tahtoo pelastaa palvelijansa, ei kruunun loistolla, vaan
ristin nöyryydellä, on jakanut nuo kaksi voimaa, säätäen, että
kuninkaitten tulee tarvita paavia iankaikkisen elämänsä tähden ja
paavin tulee olla riippuvainen kuninkaista ajallisissa asioissa. Pyhän
hallinnon ei koskaan tule tahtoa itselleen ajallisten asiain johtoa, ja
ne, joille tuo johto on annettu, eivät koskaan saata vahingotta
sekaantua taivaallisiin asioihin.»

Paavi nousi istuimeltaan jäykkänä. Kuka oli näin puhunut? Oliko se


luterilainen, mazzinilainen, vapaamielinen, kirkon vihollinen,
semmoinen kuin Rossi? Ei, vaan paavi, suuri paavi kristikunnan
alkuajoilta, jolloin kirkko oli nöyrä ja köyhä.

Paavi sulki kirjan ja koetti sanoa itselleen, että Gelasiuksen ajoista


saakka kirkon asema oli kokonaan muuttunut. Se oli turhaa. Totta
oli, mitä Gelasius oli sanonut — totta itsessään, totta historiallisessa
suhteessa, totta jumaluusopin kannalta, totta Kristuksen lain ja
Hänen pyhän esimerkkinsä mukaan.

»Jumala, joka tietää, kuinka vaarallinen sellainen voimain yhdistys


on…»

Oliko mahdollista, että sellaiset vaarat vieläkin väijyvät paavia?


Tänäkin aikana, tänä tuntina, tällä hetkellä hänen omassa
persoonassaan, tänä iltana, nyt?

Paavi tunsi hikipisaroita otsallaan ja hän avasi ikkunan antaakseen


yöilman tuulla sisään. Muistaessaan tämän kuluneen päivän töitä,
kuinka hän oli valmistanut juhlamenoja, puhunut isä Pifferin kanssa,
lähettänyt sanan ministerille, kirjoittanut kuninkaalle, hän kysyi
itseltään, olisiko hän menetellyt aivan samoin, ellei hän olisi ajatellut
mitä vaaroja ja mikä vastuunalaisuus hänellä oli ruhtinaana.

Hän ajatteli tuota nuorta naista, joka oli käynyt hänen luonaan,
hänen kertomustaan, hänen rukoustaan, hänen kaihoavaa
katsettaan, hänen surullista ääntään.

»Ehkä kuningas kieltäytyy», ajatteli hän ja hengittäen


helpotuksesta sulki ikkunan.

Samana hetkenä vaununpyöräin jyrinä katkaisi hiljaisuuden


piazzalla, ja pari minuuttia myöhemmin kreivi de Raymond
siviilipuvussa polvistui paavin eteen lausuen:

»Teidän pyhyytenne! Hänen majesteettinsa kuningas tulee!»


XIII.

Juhlamenot Pietarin-kirkossa piinatorstaina olivat komeammat ja


loistavammat kuin miesmuistiin oli nähty Roomassa. Aikaisesta
aamusta alkaen myöhään iltaan oli tuossa avarassa kirkossa kuin
jättiläismarkkinat, sillä lukemattomat tuhannet hyörivät edestakaisin.
Kello kymmenen aikaan siellä oli suuri ahdinko ovelta alttarille asti.

Väki siellä oli enimmäkseen köyhää kansaa. Sitä oli tullut kaikista
kaupunginosista ja Campagnalta. Siellä oli kalpeita miehiä
rukousnauha kädessä ja naisia kantaen pieniä lapsia, joihin he
tekivät ristinmerkin vihkivedellä. Tuolla kulki kädettömiä, jalattomia
kerjäläisiä, ryömien, mutisten, polvistuen. Näin murehtivan kansan
virta tulvaili kirkon läpi kertoen kurjuudesta ja puutteesta.

Tämä oli voittoisa juhla kirkolle. Euroopan epäuskoisimman


hallituksen silmäin edessä se oli todistanet, että kansan mahtavin
tunne oli uskonnon tunne. Kun synkkä aika kohtasi kansaa, kääntyi
se kirkon puoleen.

Paavin hovi oli syystä ylpeä. Muutamat sen jäsenet eivät ollenkaan
koettaneetkaan salata iloaan siitä, että olivat voineet iskeä noin
tuntuvan iskun hallitseviin luokkiin. Mutta Roomassa oli sittenkin yksi
mies, joka ei tuntenut mitään iloa voitostaan. Se oli paavi.

Hän oli mennyt messuun aamulla valkoisessa viitassaan ja


kultahiippa päässä, istunut sedia gestatoreen, kardinaalien,
patriarkkojen, arkkipiispojen, piispojen, pappien ja seurojen johtajien
ympäröimänä, ja sotilasrivit, joiden välitse hän kulki, tekivät ensin
kunniaa ja vaipuivat sitten polvilleen, Hiljaa liikkuen väkijoukon halki,
jonka tervehdyshuudot mahtavana aaltona kohosivat ilmoille, hän
saapui valtaistuimelleen, joka oli verhottu hopeakankaalla ja
koristettu kullalla. Hän oli vastaanottanut sinipunerviin pukuihin
puettujen pyhän kollegion jäsenten tervehdykset ja kuunnellut,
kuinka suuret kellot soittivat Gloriaa. Hän oli kantanut pyhää
sakramenttia verhokatoksen alla, jota piispat kohottivat ja jonka
edellä kulki kardinaaleja sytytetyt kynttilät kädessä ja molemmin
puolin bussolanteja soihdut kädessä. Hän oli astunut levon kappeliin,
alttoäänien laulaessa kuin satakielet korkeassa kirkossa. Vihdoin hän
oli lausunut kolminkertaisen siunauksen keskellä kirkkoa, missä
palfrenieerit olivat kohottaneet hänet ylemmäksi kaikkia noita
kasvoja, jotka äänettöminä ja kyyneleisinä liikutuksesta katsoivat
häneen uskoen kuulevansa Jumalan siunaavan äänen. Mutta kun
messu oli ohi ja hän oli palannut takaisin huoneistoonsa, muisti hän
kertomuksen siitä huoneesta, missä Jeesus asetti sakramenttinsa, ja
kysyi itseltään, oliko kaikki tämä loisto nyt tarpeellinen, jotta paavi ja
hänen väkensä voisivat rukoilla rukouksensa.

Hän oli pessyt kahdentoista köyhän miehen jalat. Nämä miehet oli
otettu Rooman kaduilta edustamaan kahtatoista apostolia ja asetettu
istumaan valkoisissa puvuissa punaisella ja kullalla päällystetylle
istuimelle. Kynttilöitä kantavien pappien jälessä ja kamariherrain
sekä kardinaalien ympäröimänä hän oli astunut valtaistuimelle pyhän
Pietarin patsaan eteen, joka tilaisuutta varten oli puettu paavilliseen
pukuun kantaen mustassa päässään hiippaa ja mustassa sormessaan
sormusta. Kun hän sitten oli pessyt miesten jalat ja kuivannut ne
sekä suudellut kutakin jalkaa kansan riemuitessa raivokkaasti, palasi
hän huoneistoonsa ajatellen Kristusta, joka eli köyhien seassa ja
rakasti heitä.

Kirkon sakaristo oli tähän aikaan tyhjänä lukuunottamatta mustaan


viittaan puettua palvelijaa, joka lämmitteli käsiään uunin edessä.
Mutta arkkipiispan huoneessa, jossa oli kullattu nojatuoli ja
punaisella päällystettyjä tuoleja, istui isä Pifferi tavallisessa ruskeassa
kaavussaan odottaen paavia. Kantajat saapuivat tuoden paavin,
asettivat alas kantotuolin, suutelivat paavin jalkoja huolimatta hänen
estelemisestään, poistuivat kumartaen ja jättivät nuo kaksi vanhaa
miestä kahden kesken.

»Ovatko he tulleet?» kysyi paavi.

»Ei vielä, teidän pyhyytenne», vastasi kapusiinilainen.

»Mitä tietä he tulevat?»

»Borgo Santo Spiriton kautta, Rotan ohi, pylväskäytävän takaa,


Santa Monicaa pitkin, pyhän inkvisitsionin ja Campo Santon ohi
sakariston ovelle. Ne ovat hiljaisia ja pimeitä teitä näin yöllä.»

»Odottaako kreivi de Raymond alhaalla?»

»Odottaa, teidän pyhyytenne.»

Paksujen seinien läpi kuului kansan riemuhuutoja kirkossa, mutta


vähitellen ne alkoivat häipyä.
»Isä, uskotteko aavistuksiin?»

»Joskus, teidän pyhyytenne. Jos niitä jatkuu kauemmin aikaa…»

»Minulla on ollut aavistus, joka on seurannut minua koko elämäni


— ainakin koko ajan, minkä olen ollut paavina. Hyvä Jumala, joka
alentaa ja ylentää, on nähnyt hyväksi korottaa minun vähäpätöisen
olentoni maailman korkeimpaan asemaan, mutta minä olen aina
pelännyt, että minut jonakin päivänä syöstään siitä alas ja kirkko
tulee kärsimään.»

»Taivas sen estäköön, teidän pyhyytenne.»

»Siitä syystä kieltäydyin kaikista viroista, kaikista


kunnianosoituksista. Tiedättehän, kuinka kieltäydyin, isä?»

»Tiedän, mutta Jumala ymmärsi sen asian paremmin, teidän


pyhyytenne, ja
Hän määräsi teidät kansansa siunaukseksi ja lohdutukseksi.»

»Hänen pyhä tahtonsa tapahtukoon! Mutta se varjo, joka on


vaappunut elämäni yllä, ei väisty. Pyytäkää rukoilemaan minun
puolestani! Ja rukoilkaa itse minun puolestani, isä.»

»Teidän pyhyytenne on alakuloinen. Ja vielä lisäksi tänä päivänä!


Mutta kirkko on onnellinen siitä, että Jumalan käsi on asettanut
pyhän
Pietarin istuimelle miehen, joka ymmärtää lastensa tarpeet ja jonka
sydän toivoo niiden tyydyttämistä.»

»En tiedä mitä tästä odotetusta keskustelusta mahtaa koitua, isä,


mutta minun täytyy jättää itseni Pyhän hengen huostaan.
»Sitä ei voi auttaa nyt enää, teidän pyhyytenne.»

»Ehkei minun olisi pitänyt mennä niin pitkälle — mutta kun tuo
anarkismin aalto uhkaa koko maailmaa… Uskotko, että Rossi
salaisesti on anarkisti?»

»Pelkään, että hän on, teidän pyhyytenne, ja paitsi sitä kirkon ja


pyhän isän pahimpia vihollisia.»

»Sanotaan, että hän on ollut orpo lapsuudestaan asti eikä ole


koskaan nähnyt isäänsä eikä äitiään.»

»Sääli, sääli!»

»Olen kuullut, että hänen julkisessa esiintymisessään on


jonkinmoinen ylevyys ja hänen yksityiselämänsä on puhdas ja
nuhteeton.»

»Hänen suhteensa tuohon neitiin näyttää todistavan sitä, teidän


pyhyytenne.»

»Pyhä isä voi sääliä harhaan joutunutta poikaa ja kuitenkin voi


hänen olla pakko tuomita häntä. Hänen täytyy pysyä erillään
sellaisista henkilöistä, jotteivät hänen vastustajansa pääse
sanomaan, että saarnatessaan rauhaa ja siveyttä hän itse salassa
yllyttää ateismin, anarkian ja kapinallisuuden perkeleellisiä ajajia.»

»Ehkä, teidän pyhyytenne.»

»Isä, luuletteko, että huolehtiminen ajallisista asioista on


vaarallista?»
»Joskus otaksun niin, teidän pyhyytenne, ja ajattelen, että pyhän
isän olisi parempi olla ilman maita ja ihmisarmeijoja.»

»Kuinka myöhään he tulevat», virkkoi paavi, mutta samassa ovi


avautui ja ylimyskaartin upseeri polvistui kynnykselle.

»Mitä nyt?»

»Henkilöt, joita odotatte, ovat saapuneet, teidän pyhyytenne!»

»Saattakaa heidät tänne», sanoi paavi.


XIV.

Nuorella kuninkaalla oli yllään ratsuväen upseerin univormu, miekka


vyöllä ja pitkä sininen viitta hartioilla. Hän polvistui paavin eteen,
mutta pääministeri, joka oli tavallisessa siviilipuvussa, kumarsi
syvään ja jäi seisomaan.

»Pyydän, istukaa», lausui paavi istuutuen itse kullattuun


nojatuoliin, kapusiinilainen vasemmalla sivullaan.

Kuningas istui puutuolille vastapäätä paavia, mutta paroni jäi


seisomaan hänen viereensä. Paavin ja kuninkaan välillä oli puinen
pöytä, jolla paloi kaksi suurta kynttilää. Nuori kuningas oli kalpea, ja
hänen värähtelevissä kasvoissaan oli kaino ilme.

»Oli ystävällistä, että teidän pyhyytenne tahtoi nähdä meidät»,


sanoi hän, »ja ehkä asiamme vakavuus voi puolustaa käyntimme
omituisuutta».

Paavi, joka nojautui eteenpäin tuolissaan, kumarsi vastaukseksi.

»Hänen ylhäisyytensä», sanoi kuningas osoittaen paronia, »kertoi


minulle, että hän on saanut selville salaliiton henkeäni vastaan ja
että teidän pyhyytenne tietää vehkeilijäin salaisuuden».
Vastaamatta mitään paavi katseli vakavasti nuorta kuningasta,
joka alkoi näyttää hermostuneelta ja hämmästyneeltä.

»Eipä siltä, että pelkäisin», sanoi hän, »en pelkää itse. Mutta
tietysti minun täytyy ajatella muita — perhettäni — kansaani —
Italiaakin — ja jos teidän pyhyytenne… jos… teidän pyhyytenne…»

Paroni, joka oli seisonut toinen käsi rinnan yli ja toinen poskella,
puuttui nyt puheeseen.

»Teidän majesteettinne», sanoi hän, »sallittehan — ja teidän


pyhyytenne», hän kumarsi molemmille, »että selitän käyntimme
tarkoituksen.»

Nuori kuningas hengähti helpotuksesta, ja paavi, joka yhä vielä oli


ääneti, kumarsi taas päätään.

»Muutamia päiviä sitten teidän pyhyytenne ystävällisesti ilmoitti


hänen majesteettinsa hallitukselle saaneensa yksityistä tietä
ilmoituksen, joka antoi aihetta pelkoon, että yleistä rauhaa vastaan
on tekeillä hankkeita.»

Paavi kumarsi taas myöntäen.

»Sen jälkeen hallitus on saanut varmoja tietoja samasta seikasta,


josta teidän pyhyytenne niin suosiollisesti ilmoitti, sekä myöskin
luotettavan selonteon tuon salaliiton luonteesta. Sanalla sanoen,
asiamiehemme ulkomailla on ilmoittanut, että Englannin, Ranskan ja
Saksan kapinalliset ainekset ovat liittyneet yhteen ja suuntaavat
liikkeensä Roomaa kohti, joka on tuleva vallankumouksen
keskipisteeksi, ja että aiotaan hyökätä perustuslaillista yhteiskuntaa
vastaan siten, että ensimmäinen isku tähdätään kuninkaaseemme.»
»Ja mitä sen johdosta tahdotte sanoa?»

»Teidän pyhyytenne on ehkä kuullut, että hallituksen ja kansan


tarkoitus on viettää hänen majesteettinsa valtaistuimellenousun
päivää juhlamenoin. Se päivä on ensi maanantaina, ja meillä on
syytä luulla, että juuri maanantai on aiottu tuon viheliäisen hankkeen
toimeenpanopäiväksi.»

»Ja mitä sitten?»

»Teidän pyhyytenne voi olla monessa asiassa eri mieltä hänen


majesteettinsa kanssa, mutta ette voi toivoa, että tuskan huutoja
sekaantuu kuninkaallisen marssin säveliin.»

»Jos hallitus tietää tuon kaiken, on sillä myöskin parannuskeino —


muuttakaa kuninkaan juhlahankkeet.»

»Neuvo, jolla teidän pyhyytenne kunnioittaa meitä, ei ole


käytännöllinen. Jos hallitus muuttaa juhlahankkeet, käy kansa
levottomaksi ja yleinen kiihtymys kasvaa. Tämän juhlan tarkoitus on
juuri sitä tyynnyttää.»

»Mutta miksi olette tullut minun luokseni?»

»Siitä syystä, teidän pyhyytenne, että vaikka olemmekin saaneet


tietomme varmalta taholta, olemme saaneet liian epämääräisiä
tietoja voidaksemme niiden nojalla toimia tehokkaasti, ja me
uskomme, että teidän pyhyytenne käytettävissä on keinoja, joiden
avulla voidaan ylläpitää yleistä järjestystä ja» — viitaten selittävin
liikkein kuninkaaseen — »pelastaa kuninkaan henki».

Paavi liikahti levottomasti tuolillaan. »Pyydän teitä puhumaan


suoraan», sanoi hän.
Paronin paksu viiksi kohosi hiukan hymyyn. »Teidän pyhyytenne»,
sanoi hän, »tietää jo, että sattuma ilmaisi meille, mistä te saitte
tietonne. Sen kertoja oli nainen.

»Tuo seikka ilmaisi meille, ketä tiedonanto koskee. Se koskee tuon


saman naisen rakastajaa. Virallista tietä olemme saaneet todistuksia,
että hän vehkeilee ulkomailla yhteiskunnallista järjestystä vastaan, ja
siis…»

»Jos tiedätte kaiken tuon, mitä siis minulta tahdotte?»

»Teidän pyhyytenne ei ehkä ole tullut ajatelleeksi, että


kysymyksessä oleva henkilö on parlamentin jäsen ja että häntä ei
voida vangita, ellei erityisiä laissa määrätyltä ehtoja ole olemassa.
Eräs näitä ehtoja on, että jonkun tulee voida syyttää häntä.»

Paavi nousi seisomaan. »Te pyydätte minua syyttämään häntä?»

Paroni kumarsi hyvin syvään. »Hallitus ei vaadi niin paljoa», sanoi


hän. »Se toivoo ainoastaan, että teidän pyhyytenne kehoittaa
kertojaansa tekemään niin.»

»Te pyydätte siis minua loukkaamaan uskotun salaisuuden


pyhyyttä?»

»Se ei ole rippisalaisuus, teidän pyhyytenne, ja vaikka se olisi


ollutkin, tietää teidän pyhyytenne paremmin kuin me, että ennenkin
on ilmoitettu seikkoja, joitten tunteminen on välttämätön rikoksen
estämiseksi.»

Kapusiinilaisen sandaalit raapivat lattiaa, mutta paavi kohotti


vasenta kättään, ja kapusiinilainen nojautui takaisin tuoliinsa.
»Te tiedätte», sanoi paavi, »että kysymyksessä oleva nuori nainen
on naimisissa saman parlamentinjäsenen kanssa?»

»Tiedämme, että hän luulee olevansa.»

»Luulee!» kajahti kapusiinilaisen suuttunut ääni, mutta paavin


vasen käsi kohosi taas.

»Lyhyesti, te pyydätte minua kehoittamaan vaimoa uhraamaan


miehensä.»

»Jos teidän pyhyytenne nimittää sitä siksi — tekemään teon, jota


rauhan säilyttäminen edellyttää…»

»Minä nimitän sitä siksi miksi sanoin.»

Paroni kumarsi, nuori kuningas näytti rauhattomalta, ja syntyi


hetken äänettömyys. Sitten sanoi paavi:

»Koska tuo nuori nainen tuskin tietänee ollenkaan enempää kuin


mitä hän jo on kertonut ja minkä olemme teille ilmoittaneet, en
käsitä mitä me voisimme tarjota hänelle, minkä tähden hän suostuisi
uhraamaan miehensä.»

»Voitte tarjota hänen miehensä hengen», sanoi paroni.

»Hänen henkensä?»

»Teidän pyhyytenne ei ehkä tiedä, että Euroopan hallitukset


saatuaan tiedon laajalle levinneestä liitosta yhteiskuntaa vastaan
ovat liittyneet yhteisiin toimiin sen kukistamiseksi. Yksi näistä
toimenpiteistä on n.s. Belgian sopimuksen ulottaminen kaikkiin
maihin, jonka sopimuksen nojalla kuninkaanmurhaan tai hallitsevien
henkilöiden henkeä uhkaaviin vehkeilyihin syypäät ovat luovutettavat
asianomaiselle valtiolle.»

»Entä sitten?»

»Parlamentinjäsen Rossi on nyt Berliinissä. Jos häntä syytetään


laillisessa järjestyksessä vehkeilystä kuninkaan henkeä vastaan,
voimme vielä tänä iltana saada hänet vangituksi ja palautetuksi
tänne tavallisena murhaajana.»

»Entä sitten?»

»Teidän pyhyytenne ei ehkä ole kuullut, että parlamentti


viimeisten levottomuuksien jälkeen, huolimatta hänen majesteettinsa
vastustuksesta, on säätänyt kuolemanrangaistuksen
kaikenlaatuisesta valtionkavalluksesta?»

»Siis», sanoi paavi, »jos vaimo syyttäisi miestään osanotosta


tähän salaliittoon, mies tuomittaisiin kuolemaan.»

»Tästä seikasta — niin», sanoi paroni. »Mutta nykyinen salaliitto ei


ole ainoa vehkeily, johon Rossi on ottanut osaa. Kahdeksantoista
vuotta sitten hänet tuomittiin poissaolevana vehkeilystä edellisen
kuninkaamme henkeä vastaan. Hän ei ole vielä kärsinyt mitään tuon
rikoksensa tähden, koska oli niin vaikea todistaa hänet samaksi
henkilöksi. Edellisessä tapauksessa, kuten tässäkin, on olemassa
ainoastaan yksi henkilö, joka voi täyttää lain vaatimat ehdot, mitä
todistamiseen tulee. Tuo henkilö on sama nainen, joka kertoi asiasta
teidän pyhyydellenne.»

»Ja sitten?»
»Jos teidän pyhyytenne voi saada tuon nuoren naisen
todistamaan, että hänen rakastajansa on sama, edellisestä
salaliitosta tuomittu mies, niin autatte häntä pelastamaan miehensä
hengen.»

»Kuinka niin?»

»Hänen majesteettinsa on taipuvainen lupaamaan teidän


pyhyydellenne, että hän suo tuomitulle täyden anteeksiannon,
olkoonpa tulos oikeustutkinnosta mikä tahansa.»

»Ja sitten?»

»Sitten Rossi ajetaan maanpakoon, uhkaava salaliitto kukistetaan,


yleinen rauha vahvistetaan, ja kuninkaan henki on pelastettu.»

Paavi nojautui tuolinsa käsipuihin, mutta ei puhunut ja täydellinen


hiljaisuus vallitsi hetkisen.

»Teidän pyhyytenne ymmärtää siis», sanoi paroni kohteliaasti,


»että pyytäessään teidän pyhyyttänne toimittamaan syyttäjän tuolle
miehelle, Rossille, hallitus ainoastaan anoo teiltä armotyötä, johon
teidän korkea asemanne on teidät määrännyt».

»Ja jos kieltäydyn tuosta armotyöstä?»

Paroni kumarsi juhlallisesti. »Teidän pyhyytenne ei kieltäydy»,


sanoi hän.

»Mutta jos kieltäydyn — mitä sitten?»

»Sitten… teidän pyhyytenne… minun on selitettävä jotakin.»

»Minä kuuntelen.»
»Kysymyksessä oleva mies on kirkon katkerin vihollinen. Olkoonpa
hän kuinka tekopyhä tahansa, tiedetään, että hän on ateisti ja
vapaamuurari, joka on vannonut, etteivät mitkään yksityiset asiat tai
tunteet, ei isänmaa eikä suku saa kääntää häntä pois päämäärästä,
joka on yhteiskunnan ja kirkon kukistaminen.»

»Ja sitten?»

»Hän on myöskin pyhän isän persoonallinen vihollinen, jonka


mieluisin tehtävä on teidän pyhyytenne syökseminen paavin
asemasta ja pyhän Pietarin istuimen järkähyttäminen.»

»Ja sitten?»

»Poliisi ja hallituksen armeija ovat ainoat voimat, jotka voivat


suojella pyhää isää, ja ilman niitä kaikki huonot ainekset, joita on
jokaisessa yhteiskunnassa, työntyisivät esiin, pyhä isä ajettaisiin pois
Roomasta ja hänen pappejaan solvattaisiin kaduilla.»

»Mutta mitä tapahtuu, jos huolimatta kaikesta tuosta vaarasta


kieltäydyn ilmaisemasta kuolemattoman sielun salaisuutta?»

»Teidän pyhyytenne kysyy, mitä tapahtuu, jos kieltäydytte


hankkimasta syyttäjän miehelle, joka, kuten teidän pyhyytenne
tietää, vehkeilee yleistä järjestystä vastaan?»

»Minä kysyn.»

»Mitä tapahtuu… teidän pyhyytenne, saanko sanoa…»

»Jatkakaa.»
»Jos rikos tapahtuu ja kuningas saa surmansa, minun, kuninkaan
ministerin, on pakko ilmaista — ja vaatia tämä munkki todistajaksi —
että paavi tiesi asiasta edeltäkäsin ja käsittämällä mitä jaloimmalla
tavalla kuolemattoman sielun salaisuuden pyhänä pitämisen kehoitti
kuninkaanmurhaan.»

»Ja sitten, hyvä herra?»

»Maailma ei välitä hyvin hienoista eroavaisuuksista, teidän


pyhyytenne, ja Vatikaani on tätä nykyä sotakannalla melkein kaikkia
Euroopan valtoja ja kansoja vastaan. Nähdessään viattominta ja
ylhäisintä vastaan tehdyn kamalan rikoksen maailma on sanova, että
mitä paavi ei estänyt, sitä paavi toivoi, ja mitä paavi toivoi, sen hän
päätti, ja että Rauhan Ruhtinaan edustaja koetti uudestaan rakentaa
maallisen valtansa kapinoitsijain vehkeiden ja salamurhaajien
miekkojen avulla.»

Kapusiinilaisen sandaalit raapivat taas lattiaa ja taas paavi kohotti


kätensä.

»Te tulitte luokseni, kun kaikki muut keinonne olivat lopussa?»

»Tietysti hallitus toivoo aina voivansa säästää teidän


Pyhyydeltänne kaikki turhat ja kiusalliset kokemukset.»

»Tuo nuori nainen on jaksanut vastustaa kaikkia muita vaikutuksia,


eikö niin?»

»Hän on vastustanut kaikkia vaikutuksia, joilla luonnolliset käskijät


ovat koettaneet häntä taivuttaa.»

»Olen kuullut siitä. Olen kuullut mitä teidän luonnolliset käskijänne


ovat tehneet nöyryyttääkseen turvatonta naista. Hän on joutunut
sydämettömän miehen uhriksi, ja tietäen tuon seikan teidän
neuvonantajanne ovat kiusanneet ja kiduttaneet häntä. He kiduttivat
häntä köyhyydellä, nöyryytyksillä, mustasukkaisuudella ja häpeän
varjolla. Mutta pyhä Jumala vahvisti hänen rakkauttaan, joka oli
herännyt hänen sielussaan, ja hän kesti kaikki kiusaukset.»

Ensi kerran paroni näytti joutuvan hämilleen.

»Olen myöskin kuullut, että tuon saman päämäärän


saavuttamiseksi teidän vankilassanne äskettäin tapahtui häpeällinen
juttu, joka on loukannut kaikkea sekä taivaallista että inhimillistä
oikeutta.»

»Teidän pyhyytenne ei tule pitää totena kaikkea, mikä on


painettuna nurkkalehdissä.»

»Onko totta, että sinne, missä kurja, avuton olento kärsi


rangaistusta rikoksestaan, teidän käskijänne toimittivat poliisin, joka
valepuvussa koetti saada häntä syyttämään toveriaan?»

»Nämä ovat valtioasioita, teidän pyhyytenne. En myönnä enkä


kiellä.»

»Ihmisyyden nimessä kysyn teiltä, ovatko sellaiset käskijät


saaneet rangaistuksensa vai vieläkö he istuvat
sisäasiainministeriössä?»

»Epäilemättä viranomaiset menivät liian pitkälle, teidän


pyhyytenne, mutta pitäisikö meidän tuollaisen viheliäisen hupsun
tähden, joka kertoo kaikille eri juttuja, vetää viranomaisemme
oikeuteen? Sellaisten henkilöiden sääliminen on vaarallista
sentimentaalisuutta, teidän pyhyytenne, mitä voimakas ja valistunut
hallitus ei voi kannattaa.»

»Jumala silloin hävittäköön kaikki sellaiset hallitukset sekä niitä


kannattavat jumalattomat systeemit! Jos otaksumme, että mies oli
viheliäinen hupsu, ei loukkaus koskenut häntä yksin, vaan hänen
persoonassaan koko oikeuden henkeä. Mitä teidän käskijänne
tekivät? He kiusasivat miestä käyttäen välikappaleenaan sitä
rakkautta, jota hän tunsi vaimoaan kohtaan, hänen surmatun
lapsensa muistoa, kaikkea sitä, mikä oli totta, jaloa ja taivaallista
hänessä. He ristiinnaulitsivat Kristuksen tuossa avuttomassa
miehessä, ja te seisotte tässä Kristuksen edustajan edessä
puolustamassa noita tekoja!»

Paavi oli noussut seisomaan ja kohottanut toisen kätensä päänsä


yli ruhtinaallisin liikkein. Tietämättään nuori kuningas, joka oli käynyt
kalman kalpeaksi, vaipui polvilleen, mutta paroni pani käsivartensa
ristiin ja seisoi entistä jäykempänä.

»Oletteko koskaan ajatellut tuollaisen väärän ministerin loppua?


Ajatelkaapa hänen kuolinhetkeään, jolloin muisto kaikista noista
nuorista olennoista, jotka hän on surmannut, kuolleista äideistä,
yksinäisistä leskistä ja kyynelisistä orvoista häntä uhkaa. Ajatelkaa
päivää jälkeen hänen kuolemansa, kun hän, joka vaelsi maailmassa
Jumalan ruoskana, makaa maailman jaloissa eikä ole ketään niin
kurjaa, ettei potkaisisi tuota häväistyä ruumista. Te tähtäätte
korkealle, hyvä herra, mutta olkaa varuillanne, olkaa varuillanne!»

Paavi istui taas ja kuningas nousi häveten heikkouttaan.

»Teidän majesteettinne», sanoi paavi, »päivä tulee, jolloin meidän


molempien täytyy astua Jumalan eteen tekemään tiliä töistämme, ja

You might also like