Get ebook downloads in full at ebookname.

com

Data Structures and Algorithms with JavaScript 1st

Edition Michael Mcmillan

https://ebookname.com/product/data-structures-and-
algorithms-with-javascript-1st-edition-michael-mcmillan/

OR CLICK BUTTON

DOWNLOAD EBOOK

Explore and download more ebook at https://ebookname.com

Instant digital products (PDF, ePub, MOBI) available
Download now and explore formats that suit you...

Data Structures and Algorithms in C 2nd Edition Michael

T. Goodrich

https://ebookname.com/product/data-structures-and-algorithms-
in-c-2nd-edition-michael-t-goodrich/

Problem Solving with Algorithms and Data Structures

Using Python SECOND EDITION Bradley N. Miller

https://ebookname.com/product/problem-solving-with-algorithms-
and-data-structures-using-python-second-edition-bradley-n-miller/

Clojure Data Structures and Algorithms Cookbook 25

recipes to deeply understand and implement advanced
algorithms in Clojure 1st Edition Rafik Naccache

https://ebookname.com/product/clojure-data-structures-and-
algorithms-cookbook-25-recipes-to-deeply-understand-and-
implement-advanced-algorithms-in-clojure-1st-edition-rafik-
naccache/

Absolute Beginner s Guide to eBay 2nd Edition Michael

Miller

https://ebookname.com/product/absolute-beginner-s-guide-to-
ebay-2nd-edition-michael-miller/
Law of electronic commercial transactions contemporary
issues in the EU US and China 1st Edition Faye Fangfei
Wang

https://ebookname.com/product/law-of-electronic-commercial-
transactions-contemporary-issues-in-the-eu-us-and-china-1st-
edition-faye-fangfei-wang/

Introduction to Conservation Genetics 1st Edition

Richard Frankham

https://ebookname.com/product/introduction-to-conservation-
genetics-1st-edition-richard-frankham/

Schizophrenia Cognitive Theory Research and Therapy 1st

Edition Aaron T. Beck

https://ebookname.com/product/schizophrenia-cognitive-theory-
research-and-therapy-1st-edition-aaron-t-beck/

Type 1 diabetes in children adolescents and young

adults how to become an expert on your own diabetes 2nd
Edition Ragnar Hanas

https://ebookname.com/product/type-1-diabetes-in-children-
adolescents-and-young-adults-how-to-become-an-expert-on-your-own-
diabetes-2nd-edition-ragnar-hanas/

Porphyry Against the Christians Studies in Platonism

Neoplatonism and the Platonic Tradition Robert M.
Berchman

https://ebookname.com/product/porphyry-against-the-christians-
studies-in-platonism-neoplatonism-and-the-platonic-tradition-
robert-m-berchman/
Hiking Wisconsin Second Edition Kevin Revolinski

https://ebookname.com/product/hiking-wisconsin-second-edition-
kevin-revolinski/
www.it-ebooks.info
www.it-ebooks.info
Data Structures and Algorithms
with JavaScript

Michael McMillan

www.it-ebooks.info
Data Structures and Algorithms with JavaScript
by Michael McMillan
Copyright © 2014 Michael McMillan. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/
institutional sales department: 800-998-9938 or corporate@oreilly.com.
Editors: Brian MacDonald and Meghan Blanchette Cover Designer: Karen Montgomery
Production Editor: Melanie Yarbrough Interior Designer: David Futato
Copyeditor: Becca Freed Illustrators: Rebecca Demarest and Cynthia Clarke
Proofreader: Amanda Kersey Fehrenbach
Indexer: Ellen Troutman-Zaig

March 2014: First Edition

Revision History for the First Edition:

2014-03-06: First release

See http://oreilly.com/catalog/errata.csp?isbn=9781449364939 for release details.

Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly
Media, Inc. Data Structures and Algorithms with JavaScript, the image of an amur hedgehog, and related
trade dress are trademarks of O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O’Reilly Media, Inc. was aware of a trademark
claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and authors assume
no responsibility for errors or omissions, or for damages resulting from the use of the information contained
herein.

ISBN: 978-1-449-36493-9
[LSI]

www.it-ebooks.info
 Table of Contents

Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix

1. The JavaScript Programming Environment and Model. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

The JavaScript Environment 1
JavaScript Programming Practices 2
Declaring and Intializing Variables 3
Arithmetic and Math Library Functions in JavaScript 3
Decision Constructs 4
Repetition Constructs 6
Functions 7
Variable Scope 8
Recursion 10
Objects and Object-Oriented Programming 10
Summary 12

2. Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
JavaScript Arrays Defined 13
Using Arrays 13
Creating Arrays 14
Accessing and Writing Array Elements 15
Creating Arrays from Strings 15
Aggregate Array Operations 16
Accessor Functions 17
Searching for a Value 17
String Representations of Arrays 18
Creating New Arrays from Existing Arrays 18
Mutator Functions 19
Adding Elements to an Array 19
Removing Elements from an Array 20

iii

www.it-ebooks.info
 Adding and Removing Elements from the Middle of an Array 21
Putting Array Elements in Order 22
Iterator Functions 23
Non–Array-Generating Iterator Functions 23
Iterator Functions That Return a New Array 25
Two-Dimensional and Multidimensional Arrays 27
Creating Two-Dimensional Arrays 27
Processing Two-Dimensional Array Elements 28
Jagged Arrays 30
Arrays of Objects 30
Arrays in Objects 31
Exercises 33

3. Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
A List ADT 35
A List Class Implementation 36
Append: Adding an Element to a List 37
Remove: Removing an Element from a List 37
Find: Finding an Element in a List 38
Length: Determining the Number of Elements in a List 38
toString: Retrieving a List’s Elements 38
Insert: Inserting an Element into a List 39
Clear: Removing All Elements from a List 39
Contains: Determining if a Given Value Is in a List 40
Traversing a List 40
Iterating Through a List 41
A List-Based Application 42
Reading Text Files 42
Using Lists to Manage a Kiosk 43
Exercises 47

4. Stacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Stack Operations 49
A Stack Implementation 50
Using the Stack Class 53
Multiple Base Conversions 53
Palindromes 54
Demonstrating Recursion 56
Exercises 57

5. Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Queue Operations 59

iv | Table of Contents

www.it-ebooks.info
 An Array-Based Queue Class Implementation 60
Using the Queue Class: Assigning Partners at a Square Dance 63
Sorting Data with Queues 67
Priority Queues 70
Exercises 72

6. Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Shortcomings of Arrays 73
Linked Lists Defined 74
An Object-Based Linked List Design 75
The Node Class 75
The Linked List Class 76
Inserting New Nodes 76
Removing Nodes from a Linked List 78
Doubly Linked Lists 81
Circularly Linked Lists 85
Other Linked List Functions 86
Exercises 86

7. Dictionaries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
The Dictionary Class 89
Auxiliary Functions for the Dictionary Class 91
Adding Sorting to the Dictionary Class 93
Exercises 94

8. Hashing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
An Overview of Hashing 97
A Hash Table Class 98
Choosing a Hash Function 98
A Better Hash Function 101
Hashing Integer Keys 103
Storing and Retrieving Data in a Hash Table 106
Handling Collisions 107
Separate Chaining 107
Linear Probing 109
Exercises 111

9. Sets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Fundamental Set Definitions, Operations, and Properties 113
Set Definitions 113
Set Operations 114
The Set Class Implementation 114

Table of Contents | v

www.it-ebooks.info
 More Set Operations 116
Exercises 120

10. Binary Trees and Binary Search Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Trees Defined 121
Binary Trees and Binary Search Trees 123
Building a Binary Search Tree Implementation 124
Traversing a Binary Search Tree 126
BST Searches 129
Searching for the Minimum and Maximum Value 130
Searching for a Specific Value 131
Removing Nodes from a BST 132
Counting Occurrences 134
Exercises 137

11. Graphs and Graph Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

Graph Definitions 139
Real-World Systems Modeled by Graphs 141
The Graph Class 141
Representing Vertices 141
Representing Edges 142
Building a Graph 143
Searching a Graph 145
Depth-First Search 145
Breadth-First Search 148
Finding the Shortest Path 149
Breadth-First Search Leads to Shortest Paths 149
Determining Paths 150
Topological Sorting 151
An Algorithm for Topological Sorting 152
Implementing the Topological Sorting Algorithm 152
Exercises 157

12. Sorting Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

An Array Test Bed 159
Generating Random Data 161
Basic Sorting Algorithms 161
Bubble Sort 162
Selection Sort 165
Insertion Sort 167
Timing Comparisons of the Basic Sorting Algorithms 168
Advanced Sorting Algorithms 170

vi | Table of Contents

www.it-ebooks.info
 The Shellsort Algorithm 171
The Mergesort Algorithm 176
The Quicksort Algorithm 181
Exercises 186

13. Searching Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

Sequential Search 187
Searching for Minimum and Maximum Values 190
Using Self-Organizing Data 193
Binary Search 196
Counting Occurrences 200
Searching Textual Data 202
Exercises 205

14. Advanced Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

Dynamic Programming 207
A Dynamic Programming Example: Computing Fibonacci Numbers 208
Finding the Longest Common Substring 211
The Knapsack Problem: A Recursive Solution 214
The Knapsack Problem: A Dynamic Programming Solution 215
Greedy Algorithms 217
A First Greedy Algorithm Example: The Coin-Changing Problem 217
A Greedy Algorithm Solution to the Knapsack Problem 218
Exercises 220

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

Table of Contents | vii

www.it-ebooks.info
www.it-ebooks.info
 Preface

Over the past few years, JavaScript has been used more and more as a server-side com‐
puter programming language owing to platforms such as Node.js and SpiderMonkey.
Now that JavaScript programming is moving out of the browser, programmers will find
they need to use many of the tools provided by more conventional languages, such as
C++ and Java. Among these tools are classic data structures such as linked lists, stacks,
queues, and graphs, as well as classic algorithms for sorting and searching data. This
book discusses how to implement these data structures and algorithms for server-side
JavaScript programming.
JavaScript programmers will find this book useful because it discusses how to implement
data structures and algorithms within the constraints that JavaScript places them, such
as arrays that are really objects, overly global variables, and a prototype-based object
system. JavaScript has an unfair reputation as a “bad” programming language, but this
book demonstrates how you can use JavaScript to develop efficient and effective data
structures and algorithms using the language’s “good parts.”

Why Study Data Structures and Algorithms

I am assuming that many of you reading this book do not have a formal education in
computer science. If you do, then you already know why studying data structures and
algorithms is important. If you do not have a degree in computer science or haven’t
studied these topics formally, you should read this section.
The computer scientist Nicklaus Wirth wrote a computer programming textbook titled
Algorithms + Data Structures = Programs (Prentice-Hall). That title is the essence of
computer programming. Any computer program that goes beyond the trivial “Hello,
world!” will usually require some type of structure to manage the data the program is
written to manipulate, along with one or more algorithms for translating the data from
its input form to its output form.

ix

www.it-ebooks.info
For many programmers who didn’t study computer science in school, the only data
structure they are familiar with is the array. Arrays are great for some problems, but for
many complex problems, they are simply not sophisticated enough. Most experienced
programmers will admit that for many programming problems, once they come up with
the proper data structure, the algorithms needed to solve the problem are easier to design
and implement.
An example of a data structure that leads to efficient algorithms is the binary search tree
(BST). A binary search tree is designed so that it is easy to find the minimum and
maximum values of a set of data, yielding an algorithm that is more efficient than the
best search algorithms available. Programmers unfamiliar with BSTs will instead prob‐
ably use a simpler data structure that ends up being less efficient.
Studying algorithms is important because there is always more than one algorithm that
can be used to solve a problem, and knowing which ones are the most efficient is im‐
portant for the productive programmer. For example, there are at least six or seven ways
to sort a list of data, but knowing that the Quicksort algorithm is more efficient than
the selection sort algorithm will lead to a much more efficient sorting process. Or that
it’s fairly easy to implement a sequential or linear search algorithm for a list of data, but
knowing that the binary sort algorithm can sometimes be twice as efficient as the se‐
quential search will lead to a better program.
The comprehensive study of data structures and algorithms teaches you not only which
data structures and which algorithms are the most efficient, but you also learn how to
decide which data structures and which algorithms are the most appropriate for the
problem at hand. There will often be trade-offs involved when writing a program, es‐
pecially in the JavaScript environment, and knowing the ins and outs of the various data
structures and algorithms covered in this book will help you make the proper decision
for any particular programming problem you are trying to solve.

What You Need for This Book

The programming environment we use in this book is the JavaScript shell based on
the SpiderMonkey JavaScript engine. Chapter 1 provides instructions on downloading
the shell for your environment. Other shells will work as well, such as the Node.js Java‐
Script shell, though you will have to make some translations for the programs in the
book to work in Node. Other than the shell, the only thing you need is a text editor for
writing your JavaScript programs.

x | Preface

www.it-ebooks.info
Organization of the Book
• Chapter 1 presents an overview of the JavaScript language, or at least the features
of the JavaScript language used in this book. This chapter also demonstrates through
use the programming style used throughout the other chapters.
• Chapter 2 discusses the most common data structure in computer programming:
the array, which is native to JavaScript.
• Chapter 3 introduces the first implemented data structure: the list.
• Chapter 4 covers the stack data structure. Stacks are used throughout computer
science in both compiler and operating system implementations.
• Chapter 5 discusses queue data structures. Queues are an abstraction of the lines
you stand in at a bank or the grocery store. Queues are used extensively in simulation
software where data has to be lined up before it is processed.
• Chapter 6 covers Linked lists. A linked list is a modification of the list data structure,
where each element is a separate object linked to the objects on either side of it.
Linked lists are efficient when you need to perform multiple insertions and dele‐
tions in your program.
• Chapter 7 demonstrates how to build and use dictionaries, which are data structures
that store data as key-value pairs.
• One way to implement a dictionary is to use a hash table, and Chapter 8 discusses
how to build hash tables and the hash algorithms that are used to store data in the
table.
• Chapter 9 covers the set data structure. Sets are often not covered in data structure
books, but they can be useful for storing data that is not supposed to have duplicates
in the data set.
• Binary trees and binary search trees are the subject of Chapter 10. As mentioned
earlier, binary search trees are useful for storing data that needs to be stored orig‐
inally in sorted form.
• Chapter 11 covers graphs and graph algorithms. Graphs are used to represent data
such as the nodes of a computer network or the cities on a map.
• Chapter 12 moves from data structures to algorithms and discusses various algo‐
rithms for sorting data, including both simple sorting algorithms that are easy to
implement but are not efficient for large data sets, and more complex algorithms
that are appropriate for larger data sets.
• Chapter 13 also covers algorithms, this time searching algorithms such as sequential
search and binary search.
• The last chapter of the book, Chapter 14, discusses a couple more advanced algo‐
rithms for working with data—dynamic programming and greedy algorithms.

Preface | xi

www.it-ebooks.info
 These algorithms are useful for solving hard problems where a more traditional
algorithm is either too slow or too hard to implement. We examine some classic
problems for both dynamic programming and greedy algorithms in the chapter.

Conventions Used in This Book

The following typographical conventions are used in this book:
Italic
Indicates new terms, URLs, email addresses, filenames, and file extensions.
Constant width
Used for program listings, as well as within paragraphs to refer to program elements
such as variable or function names, databases, data types, environment variables,
statements, and keywords.
Constant width bold
Shows commands or other text that should be typed literally by the user.
Constant width italic
Shows text that should be replaced with user-supplied values or by values deter‐
mined by context.

Using Code Examples

Supplemental material (code examples, exercises, etc.) is available for download at
https://github.com/oreillymedia/data_structures_and_algorithms_using_javascript.
This book is here to help you get your job done. In general, if example code is offered
with this book, you may use it in your programs and documentation. You do not need
to contact us for permission unless you’re reproducing a significant portion of the code.
For example, writing a program that uses several chunks of code from this book does
not require permission. Selling or distributing a CD-ROM of examples from O’Reilly
books does require permission. Answering a question by citing this book and quoting
example code does not require permission. Incorporating a significant amount of ex‐
ample code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title,
author, publisher, and ISBN. For example: “Data Structures and Algorithms Using Java‐
Script by Michael McMillian (O’Reilly). Copyright 2014 Michael McMillan,
978-1-449-36493-9.”
If you feel your use of code examples falls outside fair use or the permission given above,
feel free to contact us at permissions@oreilly.com.

xii | Preface

www.it-ebooks.info
Safari® Books Online
Safari Books Online is an on-demand digital library that
delivers expert content in both book and video form from
the world’s leading authors in technology and business.
Technology professionals, software developers, web designers, and business and crea‐
tive professionals use Safari Books Online as their primary resource for research, prob‐
lem solving, learning, and certification training.
Safari Books Online offers a range of product mixes and pricing programs for organi‐
zations, government agencies, and individuals. Subscribers have access to thousands of
books, training videos, and prepublication manuscripts in one fully searchable database
from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Pro‐
fessional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John
Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT
Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technol‐
ogy, and dozens more. For more information about Safari Books Online, please visit us
online.

How to Contact Us
Please address comments and questions concerning this book to the publisher:

O’Reilly Media, Inc.

1005 Gravenstein Highway North
Sebastopol, CA 95472
800-998-9938 (in the United States or Canada)
707-829-0515 (international or local)
707-829-0104 (fax)

We have a web page for this book, where we list errata, examples, and any additional
information. You can access this page at http://oreil.ly/data_structures_algorithms_JS.
To comment or ask technical questions about this book, send email to bookques
tions@oreilly.com.
For more information about our books, courses, conferences, and news, see our website
at http://www.oreilly.com.
Find us on Facebook: http://facebook.com/oreilly
Follow us on Twitter: http://twitter.com/oreillymedia
Watch us on YouTube: http://www.youtube.com/oreillymedia

Preface | xiii

www.it-ebooks.info
Acknowledgments
There are always lots of people to thank when you’ve finished writing a book. I’d like to
thank my acquisition editor, Simon St. Laurent, for believing in this book and getting
me started writing it. Meghan Blanchette worked hard to keep me on schedule, and if
I went off schedule, it definitely wasn’t her fault. Brian MacDonald worked extremely
hard to make this book as understandable as possible, and he helped make several parts
of the text much clearer than I had written them originally. I also want to thank my
technical reviewers for reading all the text as well as the code, and for pointing out places
where both my prose and my code needed to be clearer. My colleague and illustrator,
Cynthia Fehrenbach, did an outstanding job translating my chicken scratchings into
crisp, clear illustrations, and she deserves extra praise for her willingness to redraw
several illustrations at the very last minute. Finally, I’d like to thank all the people at
Mozilla for designing an excellent JavaScript engine and shell and writing some excellent
documentation for using both the language and the shell.

xiv | Preface

www.it-ebooks.info
 CHAPTER 1
The JavaScript Programming Environment
and Model

This chapter describes the JavaScript programming environment and the programming
constructs we’ll use in this book to define the various data structures and algorithms
examined.

The JavaScript Environment

JavaScript has historically been a programming language that ran only inside a web
browser. However, in the past few years, there has been the development of JavaScript
programming environments that can be run from the desktop, or similarly, from a
server. In this book we use one such environment: the JavaScript shell that is part of
Mozilla’s comprehensive JavaScript environment known as SpiderMonkey.
To download the JavaScript shell, navigate to the Nightly Build web page. Scroll to the
bottom of the page and pick the download that matches your computer system.
Once you’ve downloaded the program, you have two choices for using the shell. You
can use it either in interactive mode or to interpret JavaScript programs stored in a
file. To use the shell in interactive mode, type the command js at a command prompt.
The shell prompt, js>, will appear and you are ready to start entering JavaScript ex‐
pressions and statements.
The following is a typical interaction with the shell:
js> 1
1
js> 1+2
3
js> var num = 1;
js> num*124
124

www.it-ebooks.info
 js> for (var i = 1; i < 6; ++i) {
print(i);
}
1
2
3
4
5
js>
You can enter arithmetic expressions and the shell will immediately evaluate them. You
can write any legal JavaScript statement and the shell will immediately evaluate it as
well. The interactive shell is great for exploring JavaScript statements to discover how
they work. To leave the shell when you are finished, type the command quit().
The other way to use the shell is to have it interpret complete JavaScript programs. This
is how we will use the shell throughout the rest of the book.
To use the shell to intepret programs, you first have to create a file that contains a
JavaScript program. You can use any text editor, making sure you save the file as plain
text. The only requirement is that the file must have a .js extension. The shell has to see
this extension to know the file is a JavaScript program.
Once you have your file saved, you interpret it by typing the js command followed by
the full filename of your program. For example, if you saved the for loop code fragment
that’s shown earlier in a file named loop.js, you would enter the following:
c:\js>js loop.js
which would produce the following output:
1
2
3
4
5
After the program is executed, control is returned to the command prompt.

JavaScript Programming Practices

In this section we discuss how we use JavaScript. We realize that programmers have
different styles and practices when it comes to writing programs, and we want to de‐
scribe ours here at the beginning of the book so that you’ll understand the more complex
code we present in the rest of the book. This isn’t a tutorial on using JavaScript but is
just a guide to how we use the fundamental constructs of the language.

2 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
Declaring and Intializing Variables
JavaScript variables are global by default and, strictly speaking, don’t have to be declared
before using. When a JavaScript variable is initialized without first being declared, it
becomes a global variable. In this book, however, we follow the convention used with
compiled languages such as C++ and Java by declaring all variables before their first
use. The added benefit to doing this is that declared variables are created as local vari‐
ables. We will talk more about variable scope later in this chapter.
To declare a variable in JavaScript, use the keyword var followed by a variable name,
and optionally, an assignment expression. Here are some examples:
var number;
var name;
var rate = 1.2;
var greeting = "Hello, world!";
var flag = false;

Arithmetic and Math Library Functions in JavaScript

JavaScript utilizes the standard arithmetic operators:

• + (addition)
• - (subtraction)
• * (multiplication)
• / (division)
• % (modulo)

JavaScript also has a math library you can use for advanced functions such as square
root, absolute value, and the trigonometric functions. The arithmetic operators follow
the standard order of operations, and parentheses can be used to modify that order.
Example 1-1 shows some examples of performing arithmetic in JavaScript, as well as
examples of using several of the mathematical functions.
Example 1-1. Arithmetic and math functions in JavaScript
var x = 3;
var y = 1.1;
print(x + y);
print(x * y);
print((x+y)*(x-y));
var z = 9;
print(Math.sqrt(z));
print(Math.abs(y/x));

The output from this program is:

JavaScript Programming Practices | 3

www.it-ebooks.info
 4.1
3.3000000000000003
7.789999999999999
3
0.3666666666666667
If you don’t want or need the precision shown above, you can format a number to a
fixed precision:
var x = 3;
var y = 1.1;
var z = x * y;
print(z.toFixed(2)); // displays 3.30

Decision Constructs
Decision constructs allow our programs to make decisions on what programming
statements to execute based on a Boolean expression. The two decision constructs we
use in this book are the if statement and the switch statement.
The if statement comes in three forms:

• The simple if statement

• The if-else statement
• The if-else if statement

Example 1-2 shows how to write a simple if statement.

Example 1-2. The simple if statement

var mid = 25;
var high = 50;
var low = 1;
var current = 13;
var found = -1;
if (current < mid) {
mid = (current-low) / 2;
}

Example 1-3 demonstrates the if-else statement.

Example 1-3. The if-else statement

var mid = 25;
var high = 50;
var low = 1;
var current = 13;
var found = -1;
if (current < mid) {
mid = (current-low) / 2;
}

4 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
else {
mid = (current+high) / 2;
}

Example 1-4 illustrates the if-else if statement.

Example 1-4. The if-else if statement

var mid = 25;
var high = 50;
var low = 1;
var current = 13;
var found = -1;
if (current < mid) {
mid = (current-low) / 2;
}
else if (current > mid) {
mid = (current+high) / 2;
}
else {
found = current;
}

The other decision structure we use in this book is the switch statement. This statement
provides a cleaner, more structured construction when you have several simple deci‐
sions to make. Example 1-5 demonstrates how the switch statement works.

Example 1-5. The switch statement

putstr("Enter a month number: ");
var monthNum = readline();
var monthName;
switch (monthNum) {
case "1":
monthName = "January";
break;
case "2":
monthName = "February";
break;
case "3":
monthName = "March";
break;
case "4":
monthName = "April";
break;
case "5":
monthName = "May";
break;
case "6":
monthName = "June";
break;
case "7":

JavaScript Programming Practices | 5

www.it-ebooks.info
 monthName = "July";
break;
case "8":
monthName = "August";
break;
case "9":
monthName = "September";
break;
case "10":
monthName = "October";
break;
case "11":
monthName = "November";
break;
case "12":
monthName = "December";
break;
default:
print("Bad input");
}

Is this the most efficient way to solve this problem? No, but it does a great job of dem‐
onstrating how the switch statement works.
One major difference between the JavaScript switch statement and switch statements
in other programming languages is that the expression that is being tested in the state‐
ment can be of any data type, as opposed to an integral data type, as required by languages
such as C++ and Java. In fact, you’ll notice in the previous example that we use the
month numbers as strings, rather than converting them to numbers, since we can com‐
pare strings using the switch statement in JavaScript.

Repetition Constructs
Many of the algorithms we study in this book are repetitive in nature. We use two
repetition constructs in this book—the while loop and the for loop.
When we want to execute a set of statements while a condition is true, we use a while
loop. Example 1-6 demonstrates how the while loop works.

Example 1-6. The while loop

var number = 1;
var sum = 0;
while (number < 11) {
sum += number;
++number;
}
print(sum); // displays 55

6 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
When we want to execute a set of statements a specified number of times, we use a for
loop. Example 1-7 uses a for loop to sum the integers 1 through 10.

Example 1-7. Summing integers using a for loop

var number = 1;
var sum = 0;
for (var number = 1; number < 11; number++) {
sum += number;
}
print(sum); // displays 55

for loops are also used frequently to access the elements of an array, as shown in
Example 1-8.

Example 1-8. Using a for loop with an array

var numbers = [3, 7, 12, 22, 100];
var sum = 0;
for (var i = 0; i < numbers.length; ++i) {
sum += numbers[i];
}
print(sum); // displays 144

Functions
JavaScript provides the means to define both value-returning functions and functions
that don’t return values (sometimes called subprocedures or void functions).
Example 1-9 demonstrates how value-returning functions are defined and called in
JavaScript.
Example 1-9. A value-returning function
function factorial(number) {
var product = 1;
for (var i = number; i >= 1; --i) {
product *= i;
}
return product;
}

print(factorial(4)); // displays 24
print(factorial(5)); // displays 120
print(factorial(10)); // displays 3628800

Example 1-10 illustrates how to write a function that is used not for its return value, but
for the operations it performs.

JavaScript Programming Practices | 7

www.it-ebooks.info
Example 1-10. A subprocedure or void function in JavaScript
function curve(arr, amount) {
for (var i = 0; i < arr.length; ++i) {
arr[i] += amount;
}
}

var grades = [77, 73, 74, 81, 90];

curve(grades, 5);
print(grades); // displays 82,78,79,86,95

All function parameters in JavaScript are passed by value, and there are no reference
parameters. However, there are reference objects, such as arrays, which are passed to
functions by reference, as was demonstrated in Example 1-10.

Variable Scope
The scope of a variable refers to where in a program a variable’s value can be accessed.
The scope of a variable in JavaScript is defined as function scope. This means that a
variable’s value is visible within the function definition where the variable is declared
and defined and within any functions that are nested within that function.
When a variable is defined outside of a function, in the main program, the variable is
said to have global scope, which means its value can be accessed by any part of a program,
including functions. The following short program demonstrates how global scope
works:
function showScope() {
return scope;
}

var scope = "global";

print(scope); // displays "global"
print(showScope()); // displays "global"

The function showScope() can access the variable scope because scope is a global vari‐
able. Global variables can be declared at any place in a program, either before or after
function definitions.
Now watch what happens when we define a second scope variable within the show
Scope() function:
function showScope() {
var scope = "local";
return scope;
}

var scope = "global";

print(scope); // displays "global"
print(showScope()); // displays "local"

8 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
The scope variable defined in the showScope() function has local scope, while the scope
variable defined in the main program is a global variable. Even though the two variables
have the same name, their scopes are different, and their values are different when
accessed within the area of the program where they are defined.
All of this behavior is normal and expected. However, it can all change if you leave off
the keyword var in the variable definitions. JavaScript allows you to define variables
without using the var keyword, but when you do, that variable automatically has global
scope, even if defined within a function.
Example 1-11 demonstrates the ramifications of leaving off the var keyword when
defining variables.
Example 1-11. The ramification of overusing global variables
function showScope() {
scope = "local";
return scope;
}

scope = "global";
print(scope); // displays "global"
print(showScope()); // displays "local"
print(scope); // displays "local"

In Example 1-11, because the scope variable inside the function is not declared with the
var keyword, when the string "local" is assigned to the variable, we are actually chang‐
ing the value of the scope variable in the main program. You should always begin every
definition of a variable with the var keyword to keep things like this from happening.
Earlier, we mentioned that JavaScript has function scope. This means that JavaScript
does not have block scope, unlike many other modern programming languages. With
block scope, you can declare a variable within a block of code and the variable is not
accessible outside of that block, as you typically see with a C++ or Java for loop:
for (int i = 1; i <=10; ++i) {
cout << "Hello, world!" << endl;
}
Even though JavaScript does not have block scope, we pretend like it does when we write
for loops in this book:
for (var i = 1; i <= 10; ++i ) {
print("Hello, world!");
}
We don’t want to be the cause of you picking up bad programming habits.

JavaScript Programming Practices | 9

www.it-ebooks.info
Recursion
Function calls can be made recursively in JavaScript. The factorial() function defined
earlier can also be written recursively, like this:
function factorial(number) {
if (number == 1) {
return number;
}
else {
return number * factorial(number-1);
}
}

print(factorial(5));
When a function is called recursively, the results of the function’s computation are tem‐
porarily suspended while the recursion is in progress. To demonstrate how this works,
here is a diagram for the factorial() function when the argument passed to the func‐
tion is 5:
5 * factorial(4)
5 * 4 * factorial(3)
5 * 4 * 3 * factorial(2)
5 * 4 * 3 * 2 * factorial(1)
5 * 4 * 3 * 2 * 1
5 * 4 * 3 * 2
5 * 4 * 6
5 * 24
120
Several of the algorithms discussed in this book use recursion. For the most part, Java‐
Script is capable of handling fairly deep recursive calls (this is an example of a relatively
shallow recursive call); but in one or two situations, an algorithm requires a deeper
recursive call than JavaScript can handle and we instead pursue an iterative solution to
the algorithm. You should keep in mind that any function that uses recursion can be
rewritten in an iterative manner.

Objects and Object-Oriented Programming

The data structures discussed in this book are implemented as objects. JavaScript pro‐
vides many different ways for creating and using objects. In this section we demonstrate
the techniques used in this book for creating objects and for creating and using an
object’s functions and properties.
Objects are created by defining a constructor function that includes declarations for an
object’s properties and functions, followed by definitions for the functions. Here is the
constructor function for a checking account object:

10 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
 function Checking(amount) {
this.balance = amount; // property
this.deposit = deposit; // function
this.withdraw = withdraw; // function
this.toString = toString; // function
}

The this keyword is used to tie each function and property to an object instance. Now
let’s look at the function definitions for the preceding declarations:
function deposit(amount) {
this.balance += amount;
}

function withdraw(amount) {
if (amount <= this.balance) {
this.balance -= amount;
}
if (amount > this.balance) {
print("Insufficient funds");
}
}

function toString() {
return "Balance: " + this.balance;
}

Again, we have to use the this keyword with the balance property in order for the
interpreter to know which object’s balance property we are referencing.
Example 1-12 provides the complete definition for the checking object along with a test
program.

Example 1-12. Defining and using the Checking object

function Checking(amount) {
this.balance = amount;
this.deposit = deposit;
this.withdraw = withdraw;
this.toString = toString;
}

function deposit(amount) {
this.balance += amount;
}

function withdraw(amount) {
if (amount <= this.balance) {
this.balance -= amount;
}
if (amount > this.balance) {
print("Insufficient funds");
}

Objects and Object-Oriented Programming | 11

www.it-ebooks.info
}

function toString() {
return "Balance: " + this.balance;
}

var account = new Checking(500);

account.deposit(1000);
print(account.toString()); // Balance: 1500
account.withdraw(750);
print(account.toString()); // Balance: 750
account.withdraw(800); // displays "Insufficient funds"
print(account.toString()); // Balance: 750

Summary
This chapter provided an overview of the way we use JavaScript throughout the rest of
the book. We try to follow a programming style that is common to many programmers
who are accustomed to using C-style languages such as C++ and Java. Of course, Java‐
Script has many conventions that do not follow the rules of those languages, and we
certainly point those out (such as the declaration and use of variables) and show you
the correct way to use the language. We also follow as many of the good JavaScript
programming practices outlined by authors such as John Resig, Douglas Crockford,
and others as we can. As responsible programmers, we need to keep in mind that it is
just as important that our programs be readable by humans as it is that they be correctly
executed by computers.

12 | Chapter 1: The JavaScript Programming Environment and Model

www.it-ebooks.info
 CHAPTER 2
Arrays

The array is the most common data structure in computer programming. Every pro‐
gramming language includes some form of array. Because arrays are built-in, they are
usually very efficient and are considered good choices for many data storage purposes.
In this chapter we explore how arrays work in JavaScript and when to use them.

JavaScript Arrays Defined

The standard definition for an array is a linear collection of elements, where the elements
can be accessed via indices, which are usually integers used to compute offsets. Most
computer programming languages have these types of arrays. JavaScript, on the other
hand, has a different type of array altogether.
A JavaScript array is actually a specialized type of JavaScript object, with the indices
being property names that can be integers used to represent offsets. However, when
integers are used for indices, they are converted to strings internally in order to conform
to the requirements for JavaScript objects. Because JavaScript arrays are just objects,
they are not quite as efficient as the arrays of other programming languages.
While JavaScript arrays are, strictly speaking, JavaScript objects, they are specialized
objects categorized internally as arrays. The Array is one of the recognized JavaScript
object types, and as such, there is a set of properties and functions you can use with
arrays.

Using Arrays
Arrays in JavaScript are very flexible. There are several different ways to create arrays,
access array elements, and perform tasks such as searching and sorting the elements
stored in an array. JavaScript 1.5 also includes array functions that allow programmers

13

www.it-ebooks.info
to work with arrays using functional programming techniques. We demonstrate all of
these techniques in the following sections.

Creating Arrays
The simplest way to create an array is by declaring an array variable using the [] oper‐
ator:
var numbers = [];
When you create an array in this manner, you have an array with length of 0. You can
verify this by calling the built-in length property:
print(numbers.length); // displays 0
Another way to create an array is to declare an array variable with a set of elements
inside the [] operator:
var numbers = [1,2,3,4,5];
print(numbers.length); // displays 5

You can also create an array by calling the Array constructor:

var numbers = new Array();
print(numbers.length); // displays 0

You can call the Array constructor with a set of elements as arguments to the constructor:
var numbers = new Array(1,2,3,4,5);
print(numbers.length); // displays 5

Finally, you can create an array by calling the Array constructor with a single argument
specifying the length of the array:
var numbers = new Array(10);
print(numbers.length); // displays 10
Unlike many other programming languages, but common for most scripting languages,
JavaScript array elements do not all have to be of the same type:
var objects = [1, "Joe", true, null];

We can verify that an object is an array by calling the Array.isArray() function, like
this:
var numbers = 3;
var arr = [7,4,1776];
print(Array.isArray(number)); // displays false
print(Array.isArray(arr)); // displays true
We’ve covered several techniques for creating arrays. As for which function is best, most
JavaScript experts recommend using the [] operator, saying it is more efficient than

14 | Chapter 2: Arrays

www.it-ebooks.info
calling the Array constructor (see JavaScript: The Definitive Guide [O’Reilly] and Java‐
Script: The Good Parts [O’Reilly]).

Accessing and Writing Array Elements

Data is assigned to array elements using the [] operator in an assignment statement.
For example, the following loop assigns the values 1 through 100 to an array:
var nums = [];
for (var i = 0; i < 100; ++i) {
nums[i] = i+1;
}

Array elements are also accessed using the [] operator. For example:
var numbers = [1,2,3,4,5];
var sum = numbers[0] + numbers[1] + numbers[2] + numbers[3] +
numbers[4];
print(sum); // displays 15

Of course, accessing all the elements of an array sequentially is much easier using a for
loop:
var numbers = [1,2,3,5,8,13,21];
var sum = 0;
for (var i = 0; i < numbers.length; ++i) {
sum += numbers[i];
}
print(sum); // displays 53

Notice that the for loop is controlled using the length property rather than an integer
literal. Because JavaScript arrays are objects, they can grow beyond the size specified
when they were created. By using the length property, which returns the number of
elements currently in the array, you can guarantee that your loop processes all array
elements.

Creating Arrays from Strings

Arrays can be created as the result of calling the split() function on a string. This
function breaks up a string at a common delimiter, such as a space for each word, and
creates an array consisting of the individual parts of the string.
The following short program demonstrates how the split() function works on a simple
string:
var sentence = "the quick brown fox jumped over the lazy dog";
var words = sentence.split(" ");
for (var i = 0; i < words.length; ++i) {
print("word " + i + ": " + words[i]);
}

Using Arrays | 15

www.it-ebooks.info
The output from this program is:
word 0: the
word 1: quick
word 2: brown
word 3: fox
word 4: jumped
word 5: over
word 6: the
word 7: lazy
word 8: dog

Aggregate Array Operations

There are several aggregate operations you can perform on arrays. First, you can assign
one array to another array:
var nums = [];
for (var i = 0; i < 10; ++i) {
nums[i] = i+1;
}
var samenums = nums;
However, when you assign one array to another array, you are assigning a reference to
the assigned array. When you make a change to the original array, that change is reflected
in the other array as well. The following code fragment demonstrates how this works:
var nums = [];
for (var i = 0; i < 100; ++i) {
nums[i] = i+1;
}
var samenums = nums;
nums[0] = 400;
print(samenums[0]); // displays 400
This is called a shallow copy. The new array simply points to the original array’s elements.
A better alternative is to make a deep copy, so that each of the original array’s elements
is actually copied to the new array’s elements. An effective way to do this is to create a
function to perform the task:
function copy(arr1, arr2) {
for (var i = 0; i < arr1.length; ++i) {
arr2[i] = arr1[i];
}
}
Now the following code fragment produces the expected result:
var nums = [];
for (var i = 0; i < 100; ++i) {
nums[i] = i+1;
}
var samenums = [];

16 | Chapter 2: Arrays

www.it-ebooks.info
 copy(nums, samenums);
nums[0] = 400;
print(samenums[0]); // displays 1
Another aggregate operation you can perform with arrays is displaying the contents of
an array using a function such as print(). For example:
var nums = [1,2,3,4,5];
print(nums);
will produce the following output:
1,2,3,4,5
This output may not be particularly useful, but you can use it to display the contents of
an array when all you need is a simple list.

Accessor Functions
JavaScript provides a set of functions you can use to access the elements of an array.
These functions, called accessor functions, return some representation of the target array
as their return values.

Searching for a Value

One of the most commonly used accessor functions is indexOf(), which looks to see if
the argument passed to the function is found in the array. If the argument is contained
in the array, the function returns the index position of the argument. If the argument is
not found in the array, the function returns -1. Here is an example:
var names = ["David", "Cynthia", "Raymond", "Clayton", "Jennifer"];
putstr("Enter a name to search for: ");
var name = readline();
var position = names.indexOf(name);
if (position >= 0) {
print("Found " + name + " at position " + position);
}
else {
print(name + " not found in array.");
}

If you run this program and enter Cynthia, the program will output:
Found Cynthia at position 1

If you enter Joe, the output is:

Joe not found in array.

Accessor Functions | 17

www.it-ebooks.info
If you have multiple occurrences of the same data in an array, the indexOf() function
will always return the position of the first occurrence. A similar function, lastIndex
Of(), will return the position of the last occurrence of the argument in the array, or -1
if the argument isn’t found. Here is an example:
var names = ["David", "Mike", "Cynthia", "Raymond", "Clayton", "Mike",
"Jennifer"];
var name = "Mike";
var firstPos = names.indexOf(name);
print("First found " + name + " at position " + firstPos);
var lastPos = names.lastIndexOf(name);
print("Last found " + name + " at position " + lastPos);
The output from this program is:
First found Mike at position 1
Last found Mike at position 5

String Representations of Arrays

There are two functions that return string representations of an array: join() and
toString(). Both functions return a string containing the elements of the array de‐
limited by commas. Here are some examples:
var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];
var namestr = names.join();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
namestr = names.toString();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

When you call the print() function with an array name, it automatically calls the
toString() function for that array:
print(names); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

Creating New Arrays from Existing Arrays

There are two accessor functions that allow you create new arrays from existing arrays:
concat() and splice(). The concat() function allows you to put together two or more
arrays to create a new array, and the splice() function allows you to create a new array
from a subset of an existing array.
Let’s look first at how concat() works. The function is called from an existing array,
and its argument is another existing array. The argument is concatenated to the end of
the array calling concat(). The following program demonstrates how concat() works:
var cisDept = ["Mike", "Clayton", "Terrill", "Danny", "Jennifer"];
var dmpDept = ["Raymond", "Cynthia", "Bryan"];
var itDiv = cis.concat(dmp);
print(itDiv);

18 | Chapter 2: Arrays

www.it-ebooks.info
 itDiv = dmp.concat(cisDept);
print(itDiv);
The program outputs:
Mike,Clayton,Terrill,Danny,Jennifer,Raymond,Cynthia,Bryan
Raymond,Cynthia,Bryan,Mike,Clayton,Terrill,Danny,Jennifer

The first output line shows the data from the cis array first, and the second output line
shows the data from the dmp array first.
The splice() function creates a new array from the contents of an existing array. The
arguments to the function are the starting position for taking the splice and the number
of elements to take from the existing array. Here is how the method works:
var itDiv = ["Mike","Clayton","Terrill","Raymond","Cynthia","Danny","Jennifer"];
var dmpDept = itDiv.splice(3,3);
var cisDept = itDiv;
print(dmpDept); // Raymond,Cynthia,Danny
print(cisDept); // Mike,Clayton,Terrill,Jennifer

There are other uses for splice() as well, such as modifying an array by adding
and/or removing elements. See the Mozilla Developer Network website for more in‐
formation.

Mutator Functions
JavaScript has a set of mutator functions that allow you to modify the contents of an
array without referencing the individual elements. These functions often make hard
techniques easy, as you’ll see below.

Adding Elements to an Array

There are two mutator functions for adding elements to an array: push() and un
shift(). The push() function adds an element to the end of an array:
var nums = [1,2,3,4,5];
print(nums); // 1,2,3,4,5
nums.push(6);
print(nums); // 1,2,3,4,5,6

Using push() is more intuitive than using the length property to extend an array:
var nums = [1,2,3,4,5];
print(nums); // 1,2,3,4,5
nums[nums.length] = 6;
print(nums); // 1,2,3,4,5,6
Adding data to the beginning of an array is much harder than adding data to the end
of an array. To do so without the benefit of a mutator function, each existing element

Mutator Functions | 19

www.it-ebooks.info
 Another Random Document on
Scribd Without Any Related Topics
– De nem tehette azt; mert amint a kunyhóajtóból előlép, a kunyhó
tetején ácsingózó ordas egyszerre le fog rá ugrani s hátulról rántja
le.
Guthay Lőrincz karra vetett puskával nézte ezt az ádáz
küzdelmet.
Bizony ordália ez! Istenitélet. Ime előjöttek azok a vadak, a kik
Eliézer megcsúfolóit összetépték; a sors azok által tesz igazságot. Itt
most össze fogják tépni, széthurczolni azt a halálos ellenséget, a
kinek kiengesztelhetetlen haragja, akinek gonosz luxuriese az ő
életét követelte áldozatul. A saját életét veszti el.
Neki nem kell egyebet tenni, mint nézni. Elnézni a halálos tusáját,
kétségbeesését annak a másiknak.
De hát el fogja-e ezt viselni az ő lelke?
A kétségbeesésnek e paroxismusában elordítá magát Kadarkuthy:
«ember! segíts!»
A borzasztó, emberéhez nem hasonlitó üvöltést viszhangozá a
mogyoróliget fala.
Arra két lövés dördült el, pillanatnyi közökben.
Az egyik lövésre a gunyhó tetején leskelődő farkas bukfenczezett
le Kadarkuthy lába elé, a másikra a havat szóró ordas vágta magát
hanyatt, négy lábával kalimpázva. Guthay Lőrincz «holó–holó–holó!»
kiáltozással rohant elő a bükkfa mellől szuronyos fegyverével, mire
az ugrásra készülő ordas egyszerre felriadt, oldalt szökött, s aztán
odarohanva a bezuzott orru párjához, annak megkapta a fülét, s ugy
vonszolta el magával a fülénél fogva: lompos farkával ütögetve hátul
gyorsabb szaladásra. Eltüntek a bozótban.
– Nem törött el a puskaagy? – Ez volt az első szava Guthay
Lőrincznek Kadarkuthy Viktorhoz.
A kérdezett szótlanúl mutatta a fegyverét: ép volt.
 – Akkor hát újra megtölthetjük a puskáinkat s kezdhetjük a
párbajt.
Kadarkuthy erre a szóra eldobta a puskát a kezéből.
– Jaj, ne beszélj róla, – rebegé fogvaczogva. – Hiszen úgy
reszketek. A hideg ráz. Fogd meg a kezemet.
Odanyújtá a kezét Guthay Lőrincznek. Olyan hideg volt az, mint
egy halottnak a keze.
– Csinálj tüzet inkább.
A lévita erre odament a lesgunyhóhoz, fölnyitotta annak az
ajtaját. A puskavesszővel kellett benyúlni az ajtó likán s úgy emelni
föl a reteszt. Odabenn aztán volt tűzszerszám. A gunyhó közelében
volt fölmáglyázva a targaly, azt csak meg kellett gyújtani az égő
csóvával: a tűz vigan ropogva égett.
Kadarkuthy Viktor térdre ereszkedett a tűz mellé, s kezeit
összetette a mellén: fázott, reszketett. Szemei merően bámultak a
lobogó tűzbe; még most is a pokoli rémképeket látta maga előtt.
Ajkai valamit motyogtak csendesen: «van Isten! van Isten!»
Azután odainté Lőrinczet.
– Ülj mellém. Ölelj meg. Úgy reszketek. Nincsen egy csöpp
szivem sem. Megették a farkasok! Ne hagyj nekik széttépni!
Guthay Lőrincz odaült a térdeplő férfi mellé s átölelte annak a
vállát.
– Ne félj! Elvertük a czudár bestiákat. Ott hevernek a havon.
Kettőt te öltél meg, kettőt én.
Erre a szóra elkezdett Kadarkuthynak az arcza nyavalyatörős
vigyorgásra torzulni.
– Azokban laktak az ördögök, – suttogá. – A mi lelkünket
megszálló ördögök. Most megszabadultunk tőlük. Úgy-e nem fogunk
egymásra haragudni többé soha?
Guthay Lőrincz mély megilletődést érzett. Valami nagy változást
vett észre Kadarkuthyn, mely külső jelben tanusítá a nagy lelki
fordulatot; de nem szólt neki felőle.
Kadarkuthy odahúzta magához Guthay fejét, hogy a fülébe
súghassa:
– Én teneked a lelkemmel tartozom. Te a lelkemet adtad vissza.
Eddig nem volt.
A lévita vette észre, hogy vadásztársa félrebeszél.
Hirtelen fölvett egy marék havat s azzal erősen bedörzsölte
annak az arczát, orrát, füleit. Ettől magához tért.
– Köszönöm, pajtás! – szólt aztán régi szokott hangján. – Nagyon
elcsigázott ez a hajczihő. Most már eszemen vagyok. Nem fogok
bolondokat beszélni. Te kiegyenlítetted a tartozásodat ellenemben;
de én még nem, a mivel neked tartozom. Eredj haza a feleségedhez,
s mondd el neki, hogy az ő férjét nem üldözi senki a világon többé.
Te visszatérhetsz az emberi társaságba. Asszonyoddal
megesküdhetel igaz hit szerint, hogy viselje a te nevedet. Szülőid
meghaltak. Az öreg Malárdyból alázatos ember lett. Fia elvette a te
szülőid fogadott leányát. A két család közti átok megszünt. A
feleséged szép vagyont örökölt; Durday őrnagy ráhagyta egész
birtokát, ha tíz év alatt elő fog kerülni. Ellenkező esetben a városi
kórház alapítványáúl fog az szolgálni. Ezentúl gond nélkül élhettek
szülővárosodban; te a tudományoknak élhetsz, tisztességes állást
szerezhetsz; egy makula nem lesz a neveden. Én úgy elhagyom ezt
az országot, hogy soha vissza nem térek többet. Én megbocsátottam
neked s másnak nincs megbocsátani valója.
Guthay Lőrincz megszorítá Kadarkuthy Viktor feléje nyujtott
kezét; most már forró volt az.
– A bocsánatot köszönöm, ezt örömmel fogadom. De azon túl
semmit. Én a feleségemnek el nem mondhatom ennek a mostani
órának a történetét; mert azzal egész életére szerencsétlenné
tenném. Ő pedig most boldog, meg van elégedve. S az ő boldogsága
az én sorsom is. A birtokra, a mit neki hagyományoztak, a város
gyámoltalan lázárainak szüksége van, nekünk nincs. A mi kenyerünk
hiveink szivében van s az jó termő föld. A fiamat arra fogom nevelni,
hogy esze és szorgalma után megéljen. A pénz elgurúl, a földbirtok
elszalad a kényeztetett úrfiak kezéből és lába alól; hanem a szegény
ember fiának a munkakedve dominium és capitalis, a mi nem vész el
soha. Mi itt maradunk a barátfalvi völgyben. Külömbség csak az lesz
ránk nézve, hogy most már ki is járhatunk belőle.
– Így is jó, – mondá Kadarkuthy fölállva a tűz mellől. – Most hát
töltsük meg újra a fegyvereinket s aztán te majd vezess el a
kocsiutig, a melyen Szent Péterre eljutok, a hol egy emberem vár
reám, a kivel tudatnom kell, hogy élek.
– Hanem előbb ezeket az elejtett farkasokat czipeljük be a
lesgunyhóba, mert ez most rám nézve egy capitalis, a mivel ki lesz
elégítve az orgonácskám ára.
– Félsz, hogy ellopja valaki őket?
– Nem valaki, de valami. A farkasok visszajönnek s a megölt
pajtásaikat fölfalják.
– Ah! A kannibálok? A saját testvéreiket.
– Te soha sem láttál farkast?
– Soha! Hiszen Párisból jövök, s ott «louve»-nak a fortificatio
nimfáit hívják.
– Akkor elég jól viselted magadat a farkasok első rendez-vous-
jában.
Azzal aztán segített Kadarkuthy Guthaynak a vadászzsákmányt a
lesgunyhóba behordani. Majd holnap eljönnek a munkások a
bundáikért.
 – De biz ezt a kis ártatlan malaczot sem hagyom itt prédára, –
mondá a lévita s odament a hangafa bokorhoz. A kis malacznak már
volt annyi esze, hogy a nagy farkasvonítás közben meg ne
nyikkanjon, hanem elbújjon a páfrán közé. – Majd mikor a falú
végéhez érünk, kieresztem a zsákból; hazatalál ez magától.
Azután sáscsutakból fáklyákat készítettek a vadászok, s azokat
meggyújtva, hatoltak ki a veszedelmes völgyből, föl a vízválasztóig.
A szekérútnál, a keresztfa előtt, megölelték egymást, úgy váltak el.
Hermina soha sem tudta meg, hogy mi történt ezen a
réméjszakán, a farkasok völgyében.
 MI VOLT AZ A NAGY VÁLTOZÁS?

Kadarkuthy jó délelőtt érkezett be gyalogsorban a szentpéteri

vendéglőhöz, a hol útitársát, hajdani princzipálisát, a komédiást,
hátrahagyta. Az ott ült az ivószobában egy üveg alamázia mellett.
A báró ki volt melegedve a gyalogolásban, a süveget levette az
izzadt fejéről s a farkasbőr-kosokat panyókára veté a vállára, úgy
lépett be a korcsmaszobába.
Hát a mint a Herkules megpillantá a belépőt, fölugrott a padról;
mint a ki kisértetet lát, keresztül ugrott az asztalon s kiszaladt a
söntés ajtaján, folyvást hátrafelé nézve, ijedtségtől kidülledt
szemekkel.
A báró utána kiáltott, a korcsmáros meg is fogta; de az föltaszítá
a korcsmárost s úgy elszaladt, hogy kergetve sem lehetett volna
útolérni.
– Hát ezt mi lelte? – kérdé elbámulva a báró.

– De bár a czechjét13) kifizette volna! – lamentált a korcsmáros.

E felől megvigasztalta a báró; letéve az asztalra a két napi
ellátást fedező máriásokat.
– De már most nekem rögtön teremtsen ide egy szekeret, a mivel
Miskolczra mehessek! – parancsolá a báró.
Ott szalonnázott épen az állás alatt egy matyó fuvaros, a ki üres
szekérrel jött vissza a dédesi vásárból; annak volt négy bozontos
szőrü turcsija. Hamar meg volt az alkú közte és a báró között.
 – Jól van, öreg uracskám, – mondá a kocsisember. – Elszállítom
én kegyelmedet repülve arra a Miskaóczra, csak jól megfogózzék a
lőcsbe, hogy ki ne górjón a saroglyából, öreg uracskám.
– Aztán majd a Tósó borbély előtt álljunk meg a városban. Tudja
kend, hol van a Tósó borbély műhelye?
– Hisz engem is az szokott nyúzni! Hogy ne tudnám én a Tósó
borbélyt, öreg uracskám?
– De ne szólítgasson kend engem öreg uracskámnak; az én
czimem méltóságos báró úr.
– Jól van, jól, méltóságos öreg bárócskám.
A négy bozontos táltos csakugyan repülve szállította be a bárót
Miskolczra, letéve őt, kivánsága szerint, a Tósó borbély műhelye
előtt.
A báró belépett az officzinába s azt mondá a princzipálisnak,
hogy futtasson el valakit a birónál hagyott öltözetéért, s a közben
hozza rendbe a frizuráját.
Tósó mester összecsapta a tenyereit.
– De báró úr! Mit csinált a hajával?
– Hát mit csináltam?
– Nézzen ide a tükörbe! – S azzal eléje tartá a kézi tükröt.
Kadarkuthy nem ismert magára. Az egész haja galambfehér volt.
Azokban a rémséges perczekben egyszerre megőszült.
Egyet rántott a vállán.
– Legalább nem kell a hajamat többet bepudereztetni.
Azon idők divatja szerint jól illett a fehér hajzat a fiatal arczhoz:
férfiaknál, nőknél egyaránt. A tulajdon hajszinével czivilizált ember
nem jelent meg világ a előtt. Ha ezt a pentateuch szerzője tudta
Á É
volna, Ádám és Éva mindjárt, ab origine, fehér hajjal jött volna elő a
föld méhéből, – és egymás oldalából.
Kadarkuthy Viktor, európai costumejébe átöltözve, sietett a
másodalispánné látogatására.
A tekintetes asszony nagy örömmel fogadta a bárót.
Kadarkuthy azon kezdé, hogy szépen kezet csókolva, elejétől
végig elmondta a derék matronának mind azt, a mi vele történt e
nehány nap alatt. Egész a kölcsönös kiengesztelődésig.
A viczispánné nagy érdeklődéssel hallgatta a figyelemkötő
eladást.
A báró beszédéből mély érzés és tiszta igazság tündökölt elő. A
széplelkű úrhölgy gyakran törülgeté a szemeit.
Utóvégre, mintegy anyai áldásképen, rátette a kezét a báró
fejére.
Azután rögtön, elálmélkodva mondá:
– Nézze csak! A báró feje nincsen púderezve, mégis fehér.
– Az ám! Azon az egy fatális éjszakán megőszült.
– Akkor valóban vigye ön magával anyai áldásomat.
Először életében érte ez Kadarkuthy Viktor fejét. Talán volt is
foganatja.
Az egész homályos történetből nem tudott meg a köznapi világ
semmit. A kik tudták, elhallgatták. Sok ilyen titkos történetet
rejtegetnek a mi családi krónikáink.
A legközelebbi tavaszszal azonban érkezett a postán extra-kurirral
egy zacskó Francziaországból, a barátfalvi lévitának czímezve. Az a
zacskó töltve volt a még akkor e földön ismeretlen «robinia
pseudacacia» magjaival. Ez az, a mit most «akácfa» név alatt ismer

Á
egész Magyarország. Áldása az áldatlan földnek! Ez az a fa, a mely
minden mostoha talajban meghonosúl, olyanokban, a mikben már a
vad cziher sem marad meg, s aztán tavaszszal elárasztja tündér
illatával az egész vidéket s gazdagítja édes mézzel a méhköpüket.
Ezzel az akáczfa-maggal Guthay Lőrincz visszavivta a hivei
számára a záporásta szántóföldek területét, hogy ismét boldog
szántóvetők lehettek, örülhettek a kalászérésnek és aratásnak.
S vannak emberek, a kiknek ez is öröm.
UJABB ELBESZÉLÉSEK.
 NAZLI-HÁNEM.

Mahmud szultán kiadta már a kegyetlen parancsot, hogy a

muzulmán hölgyek, mikor az utczán megjelennek, termetüket
buggyos bő köpönyegbe burkolják, az arczukat pedig átlátszótlan
fátyol alá rejtsék; de biz ezt a zsarnoki rendeletet a kairói
mohamedán hölgyek nem tartották tiszteletben.
Hiszen Sztambulban is csak oly módon sikerült a padisahnak a
legfelsőbb rendelettel behozott divatot a hölgyvilággal elfogadtatni,
hogy elébb egy sereg hölgyet, a ki fátyol és feredzse nélkül sétált a
Boszporusz-parton, beledobáltatott a tengerbe.
Mehemed Ali, Egyiptom kormányzója, azonban nem követte a
szultánja példáját; egyéb parancsolatjait sem fogadta meg: elég
háborúja volt kemény férfiakkal, mit háborúskodott volna lágy, szelid
asszonynéppel. Azokat tartá gyönyörűségre. Ha ő akkor ott lett volna
Sztambulban, mikor azt a sok szép leányt a vizbe dobálták:
bizonyosan kihalászta volna őket.
Azért a kairói hölgyek azontúl is hagyták gyönyörködni termetük
és arczuk bájaiban az utczán nyüzsgő férfi népet. S azok között igen
sok volt az idegen.
A mogorva imámok ugyan meg-megszólítának egy-egy ifjú
bajadért, a ki a szokottnál is vékonyabb szövetű öltönyt viselt, s a
haját szétszórva bocsátá a vállaira, riasztva őket a szultán
parancsával, de azok csak fittyet vetének nekik. Mind azt lesték,
hogy mit fog csinálni Nazli-Hánem.
 Igy hítták a kormányzó húgát, kedvenczét, a kinek
gyönyörködtetésére építteté a «Subra» tündérkastélyt Kairo mellett,
melyet három oldalról magas kőfallal elzárt kert vesz körül, csak a
pálmák koronái s a cziprusok sudarai nyúlnak túl a párkányon; a
kastély homlokfalának fehér márvány lépcsőit pedig a Nilus kék vize
mossa, mely áradáskor egész a rézajtókig emelkedik. A széles,
magas falat, mely a Nilusra néz, elborítják a festett és faragott
arabeszkek, az aranyozott czikornyák; de ablaka, melylyel a Nilusra
nézzen, csak egyetlen egy van: gömbölyű, az is aranyozott rácscsal
elzárva. Ha ez a szem beszélni is tudna s elmondaná egyszer, hogy
mit látott?
Ebből a mesemondásba illő kastélyból szokott minden délután
bevonulni a városba a bűbájos Nazli-Hánem, fényes kiséretével.
Mindenkit a saját szeme győzhetett meg róla, hogy megérdemli a
«varázsló» melléknevet. Két izmos nubiai csonkított szolga czepeli
aranyos palankinját; előtte szaladnak a kengyelfutók, kürtszóval adva
jelt a leghatalmasabb úrnő közeledtéről, a ki még a kormányzó fölött
is uralkodik.
És mindenkinek, a ki szembe jő, szabad a hasonlíthatlan tündér
bájaitól megittasulni, akár frank, akár mozlem; még a fellah is
fölemelheti hozzá szemeit. Nazli-Hánem büszke arra a hírére, hogy
őrültekkel töltötte meg Kairót. Ezrekre megy a száma, a kik
odavesztették az eszüket az ő villogó, nagy éjfekete szemeibe. Mire
a Birkes-eszkebieh piaczig eljut, egész svadronyt képez a lovas
kisérete, a kik mind utána bolondult imádói. A délczeg mamelukok!
Egy nap azonban elmaradt a fényes kisérő csapat.
Nazli-Hánem palankinja, trombita-fuvóival együtt üdvözletlen
haladt végig a hosszú, kettős pálmasor alatt. Más nem bókolt előtte,
csak a pálmák.
Hol maradtak a délczeg mamelukok?
A város utczáin sem volt a szokott néptolongás. A herczegnő (ez
volt a czíme) ellátogatott a Khan-Khalilba, a hol az ékszereket
árulják; onnan elvitette magát a Tarbiehbe; mindenütt bevásárolt,
keleti ékszereket, aranyhímzett fátyolokat vett; a Szukarieh-bazárban
rózsavizes sorbetet ivott; de férfival nem találkozott sehol, kivéve a
rabszolgákat meg a kalmárokat.
Talán a Szug-e-Szallahban lesznek, a hol a drága fegyverzeteket
árulják? Itt szoktak a mamelukok találkozni.
Ott sem talált senkit a lovagok közül; és a kalmárok, a kikhez
kérdést intézett, mind a válluk közé húzták a fejüket, a tenyerüket a
szájuk elé tették: nem mondhattak semmit.
Végre egy vén, fehér szakállú fellaht szólított meg, a ki fejét a
térdére fektetve guggolt a Hasszarin-mecset előtt.
– Mit tudsz, öreg? Hová lettek a délczeg mamelukok?
A fellah meg sem emelte a fejét, így válaszolt:
– A délczeg mamelukok nagy vendégségen voltak az éjjel a
kormányzónál és most alusznak.
– De hiszen már alkonyodik a nap.
– Annál inkább alusznak.
– De reggel csak fölébrednek?
– Még reggel is aludni fognak. És azután, a mig az Izrafil angyal
trombitája meg nem harsan, addig folyvást aludni fognak a délczeg
mamelukok.
Nazli-Hánem a helytartó palotájához vitette magát palankinjában.
Nőknek a hárem felőli oldalon volt bejárásuk, melyet nagy, tágas
kert takart el szem elől; ez is magas kőfallal volt körülvéve, a
párkányzat hegyes vasrácscsal szegélyezve; a kapujához hosszú
töltés vezetett, melynek oszlopívei alatt lomhán folyt a csatornán
bevezetett Nilus vize; a kapuboltot pedig egy gömbölyű kupolás
tornyacs koronázza, melynek két gömbölyű ablakából éjjel-nappal
két eunuch kukucskált elő, régi divatú, mozsáröblű puskákkal, a
melyekkel végig lehetett seperni az egész keskeny útat. A kapunyílás
előtt volt egy felvonó híd, mely azt egyúttal elzárta. Azt az ismerős
sípjeladásra lebocsátották.
A herczegnő bámulva látta, hogy a csapóhíd le van eresztve, a
kapunyilás tátong; őrök nincsenek sehol. A két gömbölyű
ablaknyilásban két páva ül: azok kiabálnak egymásra kihivóan,
mintha ők volnának itt az urak.
Kiszállt a palankinból, rabszolgáit hátrahagyva, s két rabnője
kiséretében bement a kapuboltozaton át a kertbe.
Ott sem talált egy élő lélekre sem. Máskor ott kapargatták az
útakat a bosztandzsik; most üres minden itt.
De valamit mégis talált, a mi meglepte. Egy sárgaréz gombot az
útfélen. Azt fölvette.
Gombot az ozmanli nem visel. A sárgarezet nem is ismeri. Ez egy
«frank» kabátjáról szakadt le. Hogy kerül a gyönyörűségek kertjébe
egy frank férfi?
A háremhez vezető ajtók is mind tárva, nyitva voltak.
Nazli-Hánem ismerte a bátyja háremének minden szobáit,
folyosóit; végig járt rajtuk. A kincseket érő drágaságok ott voltak
érintetlenül; a felnyitott szobák során végig lehetett látni.
Végre eljutott a nagy fürdő-terem ajtajához. Annak a zárában
benne volt a kulcs. Az ajtó kivülről volt bezárva. Felnyitá a zárt és
feltárta az ajtót. Abban a teremben találta Mehemet Ali valamennyi
asszonyait és odaliszkjait együtt. Kisírt szemű, zilált hajú valamennyi,
a ki fehér bőrű; a feketéknek a szeme pedig úgy forgott
rémületében.
Mikor az ajtót nyilni hallották, mind elbújtak a fülkékbe, de mikor
a herczegnőt meglátták, hangos sivalkodással rohantak eléje,
odaomlottak a lábaihoz. Anisz-Jel, a helytartó kedvencz kadinája,
nyakába borult a herczegnőnek, s hevesen zokogott.
– Mi történt itt? – kérdezé Nazli-Hánem.
– Nem merek beszélni, rebegé halkan Anisz-Jel.
A többi hölgyek is, kezeiket ajkaik elé téve, mutatták, hogy
tilalmas a beszéd.
– Mi történt itt az éjjel? Ki mondja meg? – kérdé a herczegnő.
– A beszéd halál! – sugá a kadina.
Ekkor odaérkezett a vén kadun-khiet-kuda, az eunuchok agája,
Badrul.
– No, hát beszélek én. Vén vagyok már, s azok után, a miket az
éjjel láttam, nem bánom, ha nem látok többet semmit a világon.
De erre a szóra a hölgyek mind szétfutottak s maga Anisz-Jel is a
füleire tapasztá a tenyereit; ezt a beszédet meghallani is halál.
– No, hát én nem félek tőle, mondjad! – szólt Nazli-Hánem az
öregnek s leült a dagadó kerevetre, lábait maga alá szedve.
– Gyásznap lett ez a mai egész Egyiptomra, – kezdé el az öreg
Badrul. A kormányzó összehivatta az egész országból a mamelukok
főnökeit. Számra voltak négyszázhetvenöten. Tanácsot ült velük
reggeltől estelig, melyben a mamelukok előadták kivánságaikat.
Mehemed Ali mindent helybenhagyott.
– Így szokott azokkal tenni, a kiket el akar veszteni.
– Megosztá velük a hatalmát; úrrá tette őket a hadsereg fölött;
nekik adta a földmives nép terményeinek negyedét; elengedte sok
évi tartozásaikat; közbocsánatot hirdetett minden eddigi
lázadásaikért; – s a legnagyobb pártosokat megölelgeté,
megcsókolgatá.
 – S azok nem rémültek meg?
– Utoljára mindegyiknek ajándékozott egy nagy pecsétes gyűrűt.
– S azok nem tudták, hogy ez a halál jegygyűrűje?
– Este felé aztán, mikor a mamelukok kiváltságait, az alkoránra
tett kézzel eskűszóval megerősité, meghívta valamennyit lakomára a
nagy zöld-terembe. Ismeritek azt a termet. Tojásdad köralakú. Egy
karzat veszi körül, melyhez csak a háremből van bejárás. Ennek a
sűrű rácsozata mögül volt megengedve a háremhölgyeknek a férfiak
mulatságait nézni; ők maguk látatlanok maradtak. A lakoma a csillag
feljöttével kezdődött, s tartott az éjféli szúra énekléseig. – Ezúttal
azonban a háremhölgyek helyett a basa frenk lövészei foglalták el a
karzatot. Azok a híres vadászok, a kik egyes golyóval futtában lelövik
a zergét, röptiben a keselyűt. Azok is négyszázhetvenöten voltak:
minden vendégre egy. A kerti kapun, a háremen keresztül bocsáták
be őket, elébb a hölgyeket mind bezárva ide a fürdőterembe. Mikor
aztán a fekete kávét hozták, a csibukokkal együtt, Mehemed Ali volt
az első, a ki rágyújtott. A mint az első füstkarikát felbocsátá a
magasba: ez volt a jeladás. Egyszerre eldördültek a frenk vadászok
puskái s négyszázhetvennégy mamelukfőnök holtan esett le a
lakoma asztal mellé. Csak egy maradt közülök élve: Omár bég.
– Omár bég! Az én hősöm.
– Azt eltakarta a gyilkos golyó elől a kávétöltő rabszolga: azt érte
a halál. Ő maga karddal a kezében tört utat a testőrökön keresztül, a
kik mind frenkek voltak, s aztán kirohant az udvarra, felkapott egy
paripa nyergébe: a ki útjába állt, azt megölte. Ámde hirtelen
felhúzták előtte a csapóhidat, a várkapun nem menekülhetett ki
többé. Ekkor Omár bég a bástya meredek lépcsőin felkapatott a
párkányra s egy vakmerő ugrással leszökött onnan a magasból. Se
magának, se lovának nem lett baja: kijutott az árok-partra.14)
– Az én hős Omárom! – tapsolt a herczegnő.
 – A te hős Omárodat azonban a bástyatoronyban álló strázsa
meglőtte, ő aztán nehéz sebével tovanyargalt; de mire a Hasszán
moszkéig eljutott, halálát érezé: ott lesegítteté magát a nyergéből a
küszöbön ülő koldussal: annak elmondá a mamelukok gyászesetét s
annak a karjai között meghalt.
– Jaj! Jaj! – sikoltá, haját tépdesve Nazli-Hánem. Jaj neki! Jaj
nekem! Jaj azoknak, a kik őt megölték.
A herczegnő a hárem jól ismert folyosóján keresztül átment a
bátyja palotájába. Rátalált Mehemed Alira abban a szobában, a hol
irni szokott. Saját életének krónikáját irta.
– Hová tetted az én lovagjaimat? Mit tettél Mizraim virágos
kertjével? Hol van az én hősöm, Omár?
Mehemed Ali szép nagyszakállú férfi volt. Nyugodt mosolygással
simítá végig a tenyerét a mellén végig hullámzó szakálla fölött;
azután a hugának az omlatag hajfürteit czirógatá meg. Akkor
megfogta a kezét s odavezette egy keskeny, csúcsíves ablakhoz,
melyet finom arany rács takart.
Az ablakból a palota udvarába lehetett látni: Nazli-Hánem ott
látta a szökőkút medenczéjében piramiddá felhalmozva a mameluk
vezérek levágott fejeit, legfelül volt Omár bég feje. A szökőkút felső
víz-sugára, szivárványt vetve az alkonyi napban, hullott arany
cseppekben a néma arczokra. Az oszlopos arkádok alatt frenk
katonák álltak, a kik fecsegve, kaczagva csináltak vadásztréfát abból,
hogy a halott fejekre lecsapó keselyüket lelövöldözték. Szélpuskát
használtak hozzá, a mi nem ád hangot a lövésnél.
– Mit tettél, Mehmed Ali? – sikolta fel kétségbeesetten Nazli-
Hánem.
– Úrrá tettem magamat Egyiptomban, – szólt a helytartó, oda
mutatva a pergamen lapra a kitárt könyvben, a hol ugyanez a
mondás volt felírva arany betűkkel.
 S ugyan úrrá tette magát! A mameluk vezérek leöletése után a
többi tízezer mamelukot egy tollvonással megfosztá kiváltságaitól és
birtokától.
Azontúl nem volt senkinek földbirtoka Egyiptomban. Minden
vagyon az államé lett.
Ime a szocziális állam-ideál megvalósulva! Semmi külömbség
nemes és paraszt között; minden ember egyenlő; mindenki dolgozik.
Vagyona senkinek sincs, minden jövedelem az államé. Az állam
gondoskodik mindenkiről, ád ennivalót kicsinynek, nagynak
egyformán, ruhát, hajlékot, dohányt. A munkát is az állam osztja ki.
A kinek izmos karja van, abból lesz katona; a kinek nincs kedve a
hadakozáshoz, az szánt-vet, a kinek görbe a háta, a karja vézna, az
lesz szabó. A ki ravasz, az lesz kereskedő; a kit valami kórság
háborgat, az lehet költő. Feleségről is gondoskodik az állam az
alattvalói számára. Ha nem telik az itthon szülöttekből, hozat
Georgiából, Circassiából, Görögországból: így nemesíti a fajt.
Iskolákat is tart az állam: minden embernek kell a betűket ismerni.
Adót senki sem fizet; pénze senkinek sincs; minden az állam
kincstárába folyik s onnan szivárog szét.
S ennek a minta-államnak, mely valóságos respublica volt
parlament nélkül, volt is olyan hatalma, mely daczolt a török
szultánéval, az európai nagy államokkal, mely rendet csinált
Afrikában s uralkodott a szárazon és tengeren.
S ennek az államnak a lelke volt Mehmed Ali.
Meg lehet érteni, hogy miért irtatta ki egy óra alatt az összes
mameluk főnököket? Utjában álltak a nagy állameszmének.
Francziákat használt az államcsínyhez. Azok már értettek hozzá.
A «septembriseurök» utódai.
 Nazli-Hánem háromszor elfordítá a talizmán-gyűrűt balkeze
hüvelykujján s rettentő fogadást tett szivében.
Legelső dolga volt, hogy egy rézfürdőmedenczét belülről
bezománczoztatott üvegmázzal. Azután a szolgálatába fogadott egy
tanult khemikust.
Tehát frenkek követték el azt a tömeges gyilkolást.
Frenk alatt értenek francziát, olaszt. Ezek képezték Mehmed Ali
udvarát, tanácsát, testőrségét.
Nazli-Hánem minden nap megtette a szokott sétáját hordozó-
hintajában végig a pálmák útján, az utczákon, téreken, egész a
helytartó palotájáig; meglátogatta a bazárokat s szemébe nézett
fátyolán keresztül a czifra egyenruhás frenk ifjaknak. Most fátyolt
viselt az arczán.
Egy fiatal hadnagyocska olyan merész volt, hogy a kezével csókot
intett a herczegnő felé.
Nazli-Hánem oda sugott a palankinja mellett ballagó feketének:
– Ezt jegyezd meg!
A megbizott eunuch aztán addig kisérgette a kiválasztott fiatalt, a
mig megtudta a nevét és lakását.
Ennél aztán másnap bekoczogtatott a keleti városok ismeretes
alakja: a közvetítő vén asszony, besugva neki, hogy egy előkelő
hölgy, egy csodaszép tündérnő, őt választotta ki kegyosztása
tárgyául. Bizonyítékul átadott neki egy drágaköves arany gyűrűt.
Ennek a gyűrűnek az előmutatóját fogja várni az alkonyi
muezzim-éneklés után a Haszszán-mecset mögött egy gyalog-hintó,
két hordozóval; a kik őt egyenesen elszállítják a húrik édenébe: a
költők által megénekelt paradicsomba.
A fiatal vitéz képzelete bizonyosan bekóborolta már ezt a
tündérvilágot s most örömmel fogadta a meghívást, mely azt a
valóságban is feltárja előtte.
A Hasszán-mecset mögött várt az ifjú vitézre a hordozó hintó, a
két emelőlegénynyel, s az eunuchhal a kit a herczegnő megbizott.
Beültették, s csak akkor vette észre, hogy a gyaloghintó ablakai nem
üvegből, hanem macskaezüstből vannak, a min a világosság áthat
ugyan, de keresztül nem lehet rajta látni; ki sem lehet törni, mert
hajlik.
Nem láthatta, hogy hová viszik. De őt sem láthatta meg senki az
útfélen, a ki a zsöllye ablakán be akart tekinteni.
A palankin a herczegnő palotájában ért czéljához: itt kibocsáták
az ifjút.
A vigyorgó duéna ott várt reá a tornáczban s kézen fogva, maga
után vezette, egyik fényes teremből a másikba.
Az ifjú vitéz az ezeregyéjszakai mesék világát látta elevenné
válni. Kápráztató pompa, mámorító illatár, virágos bokrok, gyümölcs-
pazar fák, s azokon ugrándozó majmok, repkedő madarak; szökőkút
rózsavízből, süppedő selyem pokrócz a padlaton, selyem függönyzet
a falakon, aztán andalító énekhangok, a mik egyre közelebb jőnek;
mig kétfelé nyilik a nehéz selyemkárpit s a pompák pompája, a bájos
hölgycsoport előre tánczol, csábító mozdulatokkal, ingerlő
szökeléssel, körüllebegve az elbűvölt idegent, mig aztán a mindent
elhomályosító fény kitündöklik: maga a paradicsom királynéja, a
kinek az arab költő ezt a nevet adta: «napsötétség» és igen jól
találta; mert a hol ő leveti a fátylát fejéről, ott a halandó nem lát
többé se napot, se holdat, csak az ő arczát.
Ez Nazli-Hánem.
A szerencsés ifjú aztán a gyönyörök minden poharát sorba ízleli:
fenékig üríti. A bort csókkal édesítik. Az álmot csókkal ébresztik.
Egy ilyen tündéréjszakáért nem is drága fizetés a halál.
De milyen halál!
 Hajnalhasadtával azt mondja a tündér-menyasszony az elbűvölt
vőlegénynek:
– Eddig csak úgy szerettünk, a hogy férfi és nő szeretnek. Most
jön még, hogy úgy szeressünk, a hogy az istenek szerettek
hajdanában! Azok a pogány istenek: a kik nektárt ittak, ambróziát
lélegzettek, a kiknek szárnyas gyermekük volt, s a kiknek még a
bűne is dicsőség volt. Nézd: ebben az arany fiólában van a nektár és
ambrózia. Ha ebből iszunk, mi is istenekké leszünk.
Ő maga ivott előbb a szűk nyakú arany kulacskából, aztán az
átölelt ifjúnak nyújtá.
Annak a kulacsnak pedig az a bösztörsége volt, hogy két rekeszre
osztva, kétféle ital volt benne. A kulacs kupakjának egy
félrecsavarásával változott az ital. A mit a herczegnő ivott belőle, az
tiszta bor volt; a mit az ifjúnak nyujtott, az erős álomital volt. Rögtön
elaludt tőle.
Akkor aztán a herczegnő egy nagy rézgombra ütött az öklével, s
annak a harangkondulására előjött a padló csapóajtaján négy izmos
eunuch. Kettő czepelte magával az üveggel bélelt fürdőkádat, másik
kettő pedig két hordó nagyságú korsót hozott a vállán.
Abból a két korsóból valami zöld szint játszó folyadékot töltöttek
a medenczébe.
Az egyik eunuch kihúzott a göndör hajából egy fehér kakastollat s
azt belemártotta a zöld folyadékba. Mikor kihúzta onnan, a toll veres
volt s összezsugorodott.
Azután azon a gömbölyű ablakon, mely a Nilus felé néz, felhúzták
az ércz redőnyöket, hogy a napvilág teljes fényében oda süthessen
arra a medenczére.
Akkor odamentek az alvó ifjúhoz, a kinek a feje még oda volt
hajtva a tündérnő keblére, ajkai még nedvesek voltak az utolsó
csóktól. Azt felemelték s odavitték a fürdőkádhoz; de előbb a két
kezét selyemzsinórral hátrakötötték.
 Ez alatt szép csendesen aláereszkedék a padmalyból egy vastag
üveg lap, mely a földig érve, az egész szobát kétfelé rekeszté. Nazli-
Hánem kerevetén fekve, keresztül láthatott az üvegfalon.
Láthatta, hogyan merítik bele a rabszolgák azt az ifjút, a kit
szerelmével boldogított, abba a fürdőkádba.
A mivel az meg volt töltve, az hígított vitriol volt.
Nehány percz mulva aztán életre tért a maró érczsavanyban
fürösztött ifjú.
De minő életre.
Egész testét égette már a gyilkoló folyadék. Ordított a pokoli kín
miatt.
Ekkor aztán Nazli-Hánem elkezdett beszélni hozzá az üvegfalon
keresztül.
– Úgy-e te voltál, a ki az én hősömet megölted? Úgy-e te vagy a
mamelukok gyilkosa? Hát jó-e a pokolba kerülni? Hogy esik a
gyehenna fürdője? Ordíts! üvölts! Káromold az eget! Azt akarom én
hallani.
S mentől kínosabb torzpofákat fintorított a halálra gyötrött, annál
jobban kaczagott rajta a herczegnő, s ott nézte nagy gyönyörűséggel
a kétségbeesett szerető vergődését, a míg az meg nem halt.
Akkor aztán kiemelték az eunuchok a megölt ifjút a halálos
fürdőből s a hulláját kidobták a gömbölyű ablakon át a Nilusba.
A palota lépcsőin ott sütkéreztek a kajmánok; azok rögtön
rohantak a préda után.
Az üvegfal ismét fölemelkedett; akkor aztán Nazli-Hánem kiült az
ablakba s legeltette szemeit azon a tréfás látványon: hogyan
osztoznak a sok fogú alligátorok a kapott prédán. (A krokodilnak
nincs se szaglása, se izlése.)
 Később aztán abban gyönyörködhetett a herczegnő, hogy a
vitriolos lakomától felpuffadt kajmánok hogy jönnek oda a lépcsőkre,
kínjukban meggebedni.
– No, majd holnap jobbat kaptok!
Így folytatta ezt a démoni gyönyörűséget Nazli-Hánem hosszú
időn át.
Egyenkint elemésztette a bátyja testőr-csapatjának szinevirágát,
a nélkül, hogy valaki sejthette volna, hogy azok hová lettek.
Háromszáznál többet elvezetett már közülök a gyönyörök
paradicsomán keresztül az égő pokolba. Elébb megízleltette velük az
üdvösséget, azután meg a kárhozatot. Örömét találta mind a
kettőben. Rettenetes boszút állt a mamelukok gyilkosain.
Egy napon maga a testőrség ezredese ellen veté ki a hálóját.
Randolfi korzikai eredetű olasz volt. Sámsoni erejű férfi. Azt
azonban már Delila asszonyság is kitalálta, hogy Sámsont hogyan
kelle erejétől megfosztani.
Randolfi már régóta gyanakodva kémlelőzött a herczegnő
palotája körül. Testőreinek titokteljes eltünését egyenesen ő neki
tulajdonította.
Midőn a susogó banya ő neki is elhozta a gyönyörűségek zálogát,
a gyémántos jegygyűrűt, az ezredes megjelent a légyotton, s
engedte magát a zárt palankinban a herczegnő palotájába
szállíttatni. Ő vele is azt tették, a mit a többivel. Előbb fürdőbe
vitték, ott a rabnők illatos olajokkal bedörzsölték; aztán keleties
selyem ruhákba felöltöztették; semmi fegyvert, ártó szerszámot nem
hagytak nála. Randolfi bízott oroszláni erejében. A tündértánczok és
csábító énekek által félbeszakított hosszú lakoma után, a gyönyörök
mámora közepett őt is megkinálta a paradicsom királynője a
túlvilágra magasztaló bájitallal.
De Randolfi minden mozdulatára vigyázott a csábító tündérnek s
észrevette, hogy az, miután maga ivott az ezüst kulacsból, annak a
Ő
nyakán egyet fordít. Ő, hatalmas öklébe fogva a kulacsot, a
hüvelykujjával visszafordította a kulacs nyakát: úgy ivott belőle. Az
pedig nem volt más, mint czukros rózsavíz.
Ekkor aztán elálmosodást szinlelt; a szemét lehunyta; nagyot
lélekzett, mint a ki mély álomba merült.
A gong harang kondulására előjött a szomszéd szobában leskődő
négy eunuch, s leemelte a fekhelyről a mozdulatlan alakot.
Az ezredes álomütöttnek tetteté magát.
A rabszolgák felhúzták a padlat alól a fürdőmedenczét, aztán
kettő közülök megtölté azt a gyilkos érczsavanynyal.
Randolfi a fojtó szagáról ráismert a vitriolra.
A másik két rabszolga e közben lebocsátá az üvegfalat, mely a
szobát kétfelé választá.
Az áldozatnak szánt férfi lecsukott szempillái alól látta, hogy a
kéjek istennője hogy alakul át a boszúállás Erynnisévé. Ez arcz nem
Circe képe volt már; hanem Megæráé! Parancsoló kézzel inte a
rabszolgáknak, hogy hajtsák végre halálos munkájukat. Azok hozzá
fogtak, hogy Randolfi kezeit hátra kötözzék.
Ebben a pillanatban talpra ugrott az olasz, s megragadta két
karjánál az egyik rabszolgát, oly erővel hajítá azt az üvegfal felé,
hogy az keresztül tört rajta, halálos sebektől elborítva, úrnője
lábaihoz.
És aztán a másik hármat nagy hirtelen utána.
Nem kellett neki szablya, hogy összeaprítsa őket; elég fegyver
volt az a széthasadt üvegfal. Annak az éles szilánkjai, mint a
kaszabörtön, úgy hasogatták össze a rajtuk keresztül hajigált
testeket, a kiknek mély, tátongó sebeiből fecskendett a vér a
rettenetes tűndér alakjára.
 Nazli-Hánem meg volt bénulva a rémülettől. Se egy kiáltást tenni,
se helyéből megmozdulni nem tudott. Csak elmeredve bámult erre a
csodaerejű férfira, a kihez hasonló hőst soha nem látott. Várta, hogy
mikor fog ő rá is kerülni a sor? Mikor ragadja meg rettenetes
ökleivel? Vagy mit fog tenni?
Az athleta, a négy rabszolgával elbánva, azt az erőmutatványt
tette, hogy azt a vitriollal félig töltött rézkádat a két fülénél fogva
felemelte magasra s arra fordítá, a herczegnő felé.
Nazli-Hánem eliszonyodva veté magát fekhelyére, arczát hosszú
hajával eltakarva, hogy azt ne érje a pokoli tűzeső. A viador azonban
mást gondolt. Odavitte a rézmedenczét a felnyitott gömbölyű
ablakhoz s azon kihajította.
A krokodilok ott ácsingoztak már, százfogú torkukat a vízből
kitátva, várták a mai nap lakomáját.
Mikor aztán az a nagy tömeg vitriol a Nilusba zuhant: az ott
egyszerre lobbot vetett; a víz forrni kezdett, a kajmán-banda
iramodott gyors úszással a Nilus szigete felé, megrettenve a sistergő
haboktól. Akkor aztán Randolfi is kiugrott az ablakon át a Nilusba.
A vizet felforraló vitriol, sűrű fehér ködöt támasztva hömpölygött
a habok felszinén odább, s e romboló elem védelme alatt úszott
tovább a menekült férfi is, láthatatlanná téve a feje fölött lebegő
érczsavany füstjétől.
Mikor Nazli-Hánem ismét fel merte emelni a fejét s hátra nézett,
elbámult, hogy áldozatát nem látta sehol, csak az elvérzett, vonagló
rabszolgákat az ágy fülkéje előtt.
Hová tünhetett el? A fürdő-kád sem volt ott.
Öklével háromszor ütött a gongra; erre befutottak a rabnői.
Ájuldozott valamennyi, mikor azt a sok vért meglátta. Azt parancsolá
nekik, hogy nézzenek ki az ablakon, mit látnak. Azok mondák, hogy
semmit sem látnak, mint egy, a víz szinén úszó felhőt. A kajmánok
szilaj czikkázást mivelnek a vízben. Ez megnyugtatá. A megmenekült
áldozatot bizonyosan széjjeltépték a víz szörnyei.
Azt a négy rabszolgát is kidobáltatá az ablakon. Legyen a
kajmánoknak is egy Bajrám-ünnepük egyszer.
Aztán fürdőbe vitette magát; lemosatta tagjairól a vért, attól még
fehérebbé lett a bőre; a vérszagot elüzette ambrával, pézsmával, s
aztán felöltözött legpompásabb ruháiba s palankinjába szállva,
elvitette magát a városba, sorba járta a bazárokat, bevásárolt,
sorbetet ivott, s végül látogatást tett az alkirály palotájában.
A hárem bejáratánál két eunuch lépett eléje, a kik bő palástot
vetettek a fejére, s abba egy percz alatt úgy beburkolták, hogy se
mozdulni, se kiáltani nem tudott.
Aztán ismét palankinba tették; órákig jártak vele, lépcsőkön fel és
lefelé, míg utóljára ismét kiemelték a hordozó zsöllyéből, akkor egy
székbe ültették; az himbálózott, mintha a levegőben lógna; a tekerő
csigát hallotta csikorogni, a kötelet zsurlódni: egyszer aztán földet
ért a szék s akkor aztán csöndesség lett körülötte.
Ott elkezdte magáról lebontani a palástot, melybe be volt
burkolva, míg egészen kiszabadítá belőle a fejét.
Egy gömbölyű teremben találta magát, melynek nem volt se
ajtaja, se ablaka. A világosság egy gömbölyű nyiláson hatolt le e
börtönbe sok ölnyi magasból. Ugyan ezen a résen bocsáták alá a
kosarat, melybe naponkinti étele és itala volt téve, vékony
érczsodronyon.
Itt maradt holtig Nazli-Hánem, az örök feledékenység vermében,
a hova őt Mehemed Ali, a testvére, elzáratta.
Kilenczvenkét esztendős volt, a mikor meghalt.
 HÁNYAN VAGYUNK MÉG?

(Elbeszélés.)
Hárman ültek együtt a hosszú terített asztalnak a végén az
«Angol királynő» vendégfogadó földszinti étkezőszobáinak
egyikében, ott, a hol a képviselőház elnöke szokta tartani a
képviselői lakomát.
Az asztalon tizenkét tányér volt, megfelelő étkező szerekkel,
poharakkal, nyomtatott fogásrenddel és vékony pohárkákba dugott
thearozsákkal. Az asztalkendők dinnye alakú gerezdekbe hajlítva a
tányérokon.
Tizenkét teríték az asztalon és csak hárman ülnek az asztal
végén? Ennek a magyarázata az, hogy már elmúlt két óra, a mi
rendes viszonyaink szerint túlhaladott álláspontja az ebédkezdés
idejének. Még várnak valakit, vagy valakiket, de addig is
«domitorium»-nak hozzálátnak a jó szerémi szilvapálinkához, a mit
miskolczi gyürkés czipóval nyomtatnak le. Ez csak sarkantyút ád az
étvágynak.
A ki az asztalfön ül, az egy előkelő fővárosi ügyvéd; a feje
egészen kopasz, alig billeng fülei mögött egy-egy kondor bibolácska,
a minek az a szokása, hogy soha sem őszül meg, makacsul
megmarad gesztenyeszinűnek, a mi némi ellenmondást képez a
felkunkorított bajuszszal, mely koromszínű. Ez szabad: a bajuszt
koromszinűre festeni. Szakáll, haj, szemöldök mind követheti a maga
változatosság iránti szabad akaratát; de a bajusz a miénk, annak mi
parancsolunk. Különben a szakáll sem a maga ura, annak is van
törvénye, a borotva: az learattatik. Az arcz piros és sima. Látszik,
hogy jól van táplálva. Csak a szemek árulják el az előhaladott kort. A
szemhéjak duzzadtak, s a látószereknek két szemüvegre van
szükségük, az egyik az orrcsiptető, mely az olvasáshoz szükséges, a
másik a fülbekapaszkodó pápaszem, melylyel távolba lehet látni;
szobában azt a homlokra feltolva viselik.
A matrózhurokra kötött fehér nyakravalóba egyszerű
gyémántgombos melltű van nyársalva; a mellény sárga pikét,
oldalzsebéből lecsüggő nehéz aranylánczczal, melynek végét kárniól
pecsétnyomó, ezüst Szent György-tallér korallkéz, arany plajbásztok,
aczél szivarvégcsikkentő és kisded aneroid húzzák lefelé. A hátra
nyesett szárnyú dohányzó kabát oldalzsebéből sárgavörös keztyű
újjai kandikálnak elő.
Ez a házigazda, a ki a kupiczákba töltöget.
A másik kettő a meghivott vendég.
A jobbkéz felől ültetett vendég alacsony, köpczös termetű férfi,
szürke, kurta zekében, melynek a gallérja hiúzprém. A zeke
ezüstgombos és zsinórra jár: de most ki van gombolva, mert ebéd
előtt ez így tanácsos; az előre domborodó testrész ezt megkívánja,
melyet nem egész akkurátusan fedez a kalotaszegi varrottas mellény,
úgy hogy az alatt a következő csattos szíj lyukait meg lehet
számlálni. (Majd később szaporodni fognak.) Természetesen zsinóros
magyar nadrágot s gombfejü sarkantyús csizmát visel. Inggallérja és
ingeleje koczkás rózsaszínű vászon, virágos himzésekkel. Arcza,
homloka széles, naptól égett kordovánszínű, a mitől erősen elüt a
gunár ősz haj gubanczos volta, s a sárgára őszült szakáll, meg a
fakóvá pipázott bajusz. Az arcz kifejezése mérgesen jókedvű.
A második vendég, a ki balfelől ül, háttal van felénk fordulva; de
az elejéből sem ismerjük meg jobban, mert iparkodik az arczát
mindig lefelé hajtani, mintha keresne a földön valamit; homlokát a
tenyerébe támasztja, s a száját csak akkor nyítja föl, a mikor a
kupiczát kihörpinti. Arczvonásai kemények, bőrré váltak, rajta a
szőrféle, úgynevezett koldússzakáll, rövid borostásra nyirva; ilyen a
haja is, rövid, sűrű, elől homlokig, hátúl nyakig benőve. Fekete
selyem nyakkendője az ádámcsutkáig föltekerve; viseléstől fényes
fekete kabátja végig begombolva.
– Ugyan szép volt tőletek, hogy eljöttetek a meghivásomra, fiúk!
(fiúk!) szólt a házi gazda, összekoczintva kupiczáját a két szál
vendégével.
– Hát hogyne jöttünk volna? monda a zöldszakállú. A kiben egy
csepp magyar vér buzog, csak feljön a millennáris kiállításra; ámbár
az ilyen gazdaféle embernek, mint magam, ilyenkor van a
legsürgősebb dolga odahaza. Most gépelik a repczét. No, de otthon
van a fiam, utána lát a dolognak, nem kell miatta aggódnom.
– A fiadból is mezei gazdát csináltál? Nagyon helyes.
– Höher Péter! A fiam diplomás ember.
– Miféle diplomája van?
– Hát gépész diplomája. Gépésznek taníttattam ki. Igy aztán
rábizhatom az egész gazdaságot.
Erre aztán a koldús-szakállú is megszólalt.
– Hát bizony engem is a fiam segített ki, hogy erre a szent napra
feljöhessek Bergengócziából a szép fővárosba.
– A fiad is néptanító?
– Egygyel feljebb. Az már lelkész. Káplán a legjobb dotáczióval
biró helységében a Bakonynak. Nagyon szeretik a hivek. Ha az öreg
testál, pedig közel van már hozzá, megmarasztják papnak. Most
távollétemben ő szolgál helyettem. A scytháknak ugyan most már
vakácziójuk van; de a hivek megkivánják a mindennapi beéneklést.
– No, csakhogy eljöttetek, szólt két kezét egyszerre nyújtva a
vendégeinek az ügyvéd.