How Javascript Works Master The Basics Of

Javascript And Modern Web App Development 1st

Edition Jonathon Simpson download

https://ebookbell.com/product/how-javascript-works-master-the-
basics-of-javascript-and-modern-web-app-development-1st-edition-
jonathon-simpson-54604020

Explore and download more ebooks at ebookbell.com

Here are some recommended products that we believe you will be
interested in. You can click the link to download.

How Javascript Works Master The Basics Of Javascript And Modern Web
App Development 1st Edition Jonathon Simpson

https://ebookbell.com/product/how-javascript-works-master-the-basics-
of-javascript-and-modern-web-app-development-1st-edition-jonathon-
simpson-54544624

How Javascript Works Master The Basics Of Javascript And Modern Web
App Development Jonathon Simpson

https://ebookbell.com/product/how-javascript-works-master-the-basics-
of-javascript-and-modern-web-app-development-jonathon-simpson-55667652

How Javascript Works Douglas Crockford

https://ebookbell.com/product/how-javascript-works-douglas-
crockford-21976016

Learn D3js Simple Way Learn How To Work With D3 Javascript Libraries
In Stepbystep And Most Simple Manner With Lots Of Handson Examples
Nuno Correia Ajay Nayak

https://ebookbell.com/product/learn-d3js-simple-way-learn-how-to-work-
with-d3-javascript-libraries-in-stepbystep-and-most-simple-manner-
with-lots-of-handson-examples-nuno-correia-ajay-nayak-55922952
Reliable Javascript How To Code Safely In The Worlds Most Dangerous
Language 1st Edition Lawrence Spencer

https://ebookbell.com/product/reliable-javascript-how-to-code-safely-
in-the-worlds-most-dangerous-language-1st-edition-lawrence-
spencer-5131426

Functional Programming In Javascript How To Improve Your Javascript

Programs Using Functional Techniques First Edition Luis Atencio

https://ebookbell.com/product/functional-programming-in-javascript-
how-to-improve-your-javascript-programs-using-functional-techniques-
first-edition-luis-atencio-55892992

Asynchronous Programming Patterns In Javascript How To Use Asyncawait

And Promises To Solve Programming Problems Tams Sallai

https://ebookbell.com/product/asynchronous-programming-patterns-in-
javascript-how-to-use-asyncawait-and-promises-to-solve-programming-
problems-tams-sallai-33377304

Learn How Professionals Write Javascript In The Industry Mendoza

https://ebookbell.com/product/learn-how-professionals-write-
javascript-in-the-industry-mendoza-232147582

Instant Interactive Map Designs With Leaflet Javascript Library Howto

Jonathan Derrough

https://ebookbell.com/product/instant-interactive-map-designs-with-
leaflet-javascript-library-howto-jonathan-derrough-43741254
Jonathon Simpson

How JavaScript Works

Master the Basics of JavaScript and Modern
Web App Development
Jonathon Simpson
Belfast, Antrim, UK

ISBN 978-1-4842-9737-7 e-ISBN 978-1-4842-9738-4

https://doi.org/10.1007/978-1-4842-9738-4

© Jonathon Simpson 2023

This work is subject to copyright. All rights are solely and exclusively
licensed by the Publisher, whether the whole or part of the material is
concerned, specifically the rights of translation, reprinting, reuse of
illustrations, recitation, broadcasting, reproduction on microfilms or in
any other physical way, and transmission or information storage and
retrieval, electronic adaptation, computer software, or by similar or
dissimilar methodology now known or hereafter developed.

The use of general descriptive names, registered names, trademarks,

service marks, etc. in this publication does not imply, even in the
absence of a specific statement, that such names are exempt from the
relevant protective laws and regulations and therefore free for general
use.

The publisher, the authors, and the editors are safe to assume that the
advice and information in this book are believed to be true and accurate
at the date of publication. Neither the publisher nor the authors or the
editors give a warranty, expressed or implied, with respect to the
material contained herein or for any errors or omissions that may have
been made. The publisher remains neutral with regard to jurisdictional
claims in published maps and institutional affiliations.

This Apress imprint is published by the registered company APress

Media, LLC, part of Springer Nature.
The registered company address is: 1 New York Plaza, New York, NY
10004, U.S.A.
Introduction
JavaScript is one of the most used programming languages in the world.
When JavaScript was first created, it was a useful tool for adding
interactivity to web pages. Since then, it has evolved to power back-end
servers, massive front-end web applications, and even iPhone and
Android applications via tools like Electron and Tauri.
While JavaScript has matured as a language its complexity seems to
have increased. What started as simple scripts inside HTML tags now
seems to involve compile steps via TypeScript and frameworks like
React, Vue.js, or Svelte. For those getting started in JavaScript, it can be
overwhelming, even though these tools are just an additional level of
abstraction which ultimately compiles down into vanilla JavaScript.
In this book, we’ll learn how JavaScript works from the bottom up,
which will prepare you for everything web development and JavaScript-
led app development can throw at you. We’ll also explain some of the
quirks you’ll find in JavaScript and how many of them have come to be
due to JavaScript’s long and varied history.
After that, we’ll cover JavaScript’s unique approach to inheritance
before moving into more complicated topics like memory management,
classes, APIs, and web workers. We’ll explore how the weakly typed
system JavaScript employs has both benefits and downsides.
As a fundamental part of the web stack, and with more people using
it every day, there has never been a better time to learn JavaScript. This
book will guide you through everything you need to know, so that you
can master modern web app development.
Table of Contents
Chapter 1:​Introduction to JavaScript
JavaScript Fundamentals
JavaScript’s Type Classification
What Is JavaScript Used For?​
Writing JavaScript
Summary
Chapter 2:​Code Structure and Logical Statements
Getting Started
Common Code Conventions
Semicolons
Spacing
Variable and Function Naming
JavaScript Variables
Setting Variables with let
Setting Variables with var
Setting Variables with const
Defining Variables Without Values
Assignment Operators
Variable Concatenation
JavaScript Comments
Logical Statements
If…else Statements
Switch Statements
Block Scoping with Logical Statements
Conditional Operator in Variables
 Logical Statement Comparison Operators
Logical Statement Logical Operators
Summary
Chapter 3:​Introduction to Objects, Arrays
Arrays
Getting the Length of an Array
Getting the Last Element of an Array
Array Manipulation Methods
Push and Unshift
Pop and Shift
Splice
Objects
Accessing Object Data
Object Mutability
Spread Syntax or the “Three Dots”
Prototype-Based Programming
Prototypical Inheritance
[[Prototype]] vs.​prototype (and _​_​proto_​_​)
Object Shallow and Deep Copies
Summary
Chapter 4:​Loops and Iterables
Loops
Break and Continue in Loops
Loop Labels
Iteration
Iterables and For Loops
 Array forEach methods
String Iteration
Iteration Protocol
Objects Are Not Iterable by Default
Summary
Chapter 5:​References, Values, and Memory Management
Introduction
Stacks
The Event Loop
The Heap
Object and Reference Equality
Summary
Chapter 6:​Functions and Classes
Introduction to Functions
Running Arguments with the “Three Dots”
Alternative Ways to Call Functions
Unnamed Function Expressions
Anonymous Functions
Functions with Arrow Notation
Functions and the “this” Keyword
Sloppy Mode
Arrow Notation Functionality with this
Calling Functions with Context
Constructor Functions in JavaScript
Additional Function Methods
Getters and Setters
 Generator Functions
Classes
Classes and Constructor Functions
Class Methods
Class Method Types
Class Inheritance via Extends
Summary
Chapter 7:​Types
Primitive Types
Primitive Wrappers
Using Wrappers to Create Types
The Number Type and NaN
Number Type Mathematics
Mathematical Methods
The Date Type
The Symbol Type
Truthy and Falsy Types
Truthy and Falsy Operators
Logical AND Operator
Logical OR Operator
Nullish Coalescing
Optionality
Summary
Chapter 8:​Manipulating and Interacting with HTML
Window and Document Objects
The Window Object
 The Document Object Model
Selecting HTML Elements
The Order of HTML
NodeLists and HTMLCollections
Manipulating HTML After Selection
Adding Events to HTML Elements
Creating a Modal Window
Creating a Counter
Event Types
Drag and Drop
The e variable
Creating New Elements with JavaScript
Manipulating CSS with JavaScript
HTMLElements and Changing Styles in JavaScript
Adding New Style Sheets to HTML Pages
Setting CSS Variables
Getting CSS Properties and HTML Dimensions
Summary
Chapter 9:​Maps and Sets
Sets
Modifying Sets
Checking Set Membership
Checking Set Size
Merging Sets
Set Iteration and Values
Maps
 Retrieving Map Properties
Checking for Key Existence on a Map
Telling How Big a Javascript Map Is
Iterating, Merging, and Accessing Maps
Keys and Values in Maps
Serialization of Maps in JavaScript
Summary
Chapter 10:​Fetching Data, APIs, and Promises
What Are APIs?​
Understanding HTTP
RESTful Design
Understanding APIs Through a Node.​JS Web Server
Testing Endpoints with Postman
The Benefits of APIs
Sending Data to APIs with JSON
The fetch Function
A Deep Dive into Fetch Options
Asynchronicity and Promises
Promise Methods:​then, finally, and catch
The await Keyword
Useful Promise Methods
Summary
Chapter 11:​Introduction to Web APIs
Web APIs
Frequently Used Web APIs
URL API
 Web Storage API
Web Notifications API
History API
Summary
Chapter 12:​Errors and the Console
The Console Object
Console Errors, Debugs, Warnings, and Info
Console Timing
Console Counting
Other Useful Console Methods
Console Grouping
Console Tables
Errors and Exceptions
try…catch
Generating Errors
Handling Specific Errors
Summary
Chapter 13:​The Canvas
Introduction
Drawing and Images
Drawing Rectangles
Drawing Circles
Drawing Triangles
Drawing Images
Drawing Text
Interactivity and Creating a Drawing Application
 Animations
Summary
Chapter 14:​Web Workers and Multithreading
Introduction
Using Web Workers
Sending Messages to and from Web Workers
Restrictions on Web Workers
Conclusion
Index
About the Author
Jonathon Simpson
studied at UCL and currently works in product development at Revolut,
a global neobank and financial technology company that offers banking
services. He has over 15 years of web development experience working
on a wide range of products and services. Jonathon also owns and
operates a popular software engineering blog focusing on JavaScript
and web development.
About the Technical Reviewer
Russ Ferguson
is a web application developer living in Brooklyn, New York. He has
worked on projects for organizations such as Ann Taylor, MTV, DC
Comics, and LG. Currently, he is the Vice President at Bank of America
managing a team of Angular developers, building internal applications.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer Nature 2023
J. Simpson, How JavaScript Works
https://doi.org/10.1007/978-1-4842-9738-4_1

1. Introduction to JavaScript
Jonathon Simpson1
(1) Belfast, Antrim, UK

JavaScript is a programming language that first appeared in 1995 as the

scripting language for the Netscape browser. Since then, it has evolved
into one of the most used programming languages in the world. While
its initial goal was to add interactivity to websites, it has since come to
do just about everything, including creating desktop apps and back-end
APIs.
JavaScript is everywhere, and over the years, many frameworks
have been built on top of it, such as jQuery, React, Vue.js, and Svelte. All
of this can make learning JavaScript intimidating, as there are often
many different ways to achieve the same thing.
In this book, we’ll be covering how JavaScript works at a
fundamental level. That will then make it is easier to understand how
frameworks like React and Vue.js work. We’ll discuss why things work
the way they do in JavaScript and the various quirks that come with
years of ongoing development on the language.
JavaScript today broadly falls into two major categories:
Client-side code, which we’ll refer to as “the front end,” which is
included via HTML files and adds interactivity to websites. Client-
side code is loaded and processed directly on someone’s web
browser or device. In practice, this means writing a .js file or HTML
file containing JavaScript and loading it directly into your
web browser.
Server-side code, which we’ll refer to as “the back end,” which is
used for writing web servers. This kind of code is written on web
 servers and can be used to create things like APIs which the end user
never directly sees. It uses a runtime to execute the code on web
servers. The most common runtime used for this is called Node.js.
Server side code is loaded and processed on a server that is separate
from the user’s device.
Everything we discuss in this book will be applicable to both front
end and back end, but our focus will be on front-end JavaScript since
that’s where JavaScript started. We’ll sometimes touch on back-end
JavaScript where necessary so that certain concepts can be more easily
understood.

JavaScript Fundamentals
JavaScript is based on a language standard called ECMAScript. How
JavaScript should exactly work is documented in a specific standard
called ECMA-262. Since ECMAScript does not provide any tools to
compile JavaScript, every implementation of JavaScript creates its own
version of JavaScript. That includes your browser and back-end
compilers like Node.js.
For the most part, these implementations follow ECMA-262, but
since each implementation is done by different teams, there can be
some minor discrepancies or different feature sets depending on the
browser or implementation.
In this chapter, we will be covering how you can set yourself up to
start using JavaScript, including how to set up JavaScript projects when
using Node.js. In future chapters, we will explore how to write
JavaScript code.

JavaScript’s Type Classification

How a language is typed usually gives us a broad idea of how it works.
Like most other languages, JavaScript lets you define “variables” to
store data, and these variables have types. “Type” refers to the kind of
data being used. For example, a number is of type Number, and a
mixture of characters and/or numbers is referred to as having a type
called String.
 If you have used other languages, JavaScript may seem different
since it is weakly typed. That means that while other languages
require you to explicitly mention in the code what type of data different
variables are, JavaScript does not. JavaScript is also often referred to as
dynamically typed, meaning it will dynamically interpret what type of
data is based on the context it finds it in.
To understand this better, let’s look at how variables are defined in
JavaScript. Usually, we define them like this:

let x = "Some String"

let y = 5
let z = false

You’ll see that no types are defined here. For example, we did not
have to mention that "Some String" was a String. JavaScript
determines types based on context – so it will take x to be a String
simply because we put its value in quotation marks. Similarly, it will
dynamically interpret y as being of type Number since it lacks
quotation marks and z as being of type Boolean since it has no
quotation marks and uses the keyword false.
This makes JavaScript quite easy to pick up, but quite hard to
master. The lack of strong typing can mean that you unknowingly create
bugs in your software since JavaScript will not always throw errors if
unexpected types show up, and even worse, JavaScript may dynamically
interpret types incorrectly in some cases.
For more complex applications with lots of test cases, developers
often reach for TypeScript instead of JavaScript for this reason.
TypeScript is JavaScript, but extended. It’s strongly typed, meaning
types must be mentioned in your code.

What Is JavaScript Used For?

As we mentioned in the introduction, JavaScript can be compiled and
used in two major ways. The first is to create front-end interactive
experiences, right in your browser. The second is as back-end server
code. Front-end JavaScript is rendered by the browser inside of web
pages, while back-end server code requires a runtime like Node.js,
which compiles the code you write to run it directly on the server.
 When inside the browser, some of the major things JavaScript can
do are
Adding, changing, or deleting CSS/HTML when a user interacts with
something.
Creating new HTML tags programmatically.
Tracking user action and producing feedback to the user (such as
showing a pop-up when a user clicks on something).
Storing data for the user locally via local storage or cookies.
Creating single-page user experiences where no page refreshing is
needed.
On the back end, the main use cases are
Creating routes/URL endpoints on a server and dictate what happens
if a user navigates there.
Creating routes/URL endpoints for APIs (application programming
interfaces), so we can send and receive data to and from the server.
Building WebSocket servers, which users can interact with from their
front-end experience. These can be used for making things like chat
rooms.
Compressing pre-rendered web pages for a faster web experience.
Manipulating data sent to the server (sometimes via WebSocket or
API) and store it in a back-end database.

Writing JavaScript
JavaScript on the front end is found inside HTML on web pages. As such,
familiarity with HTML is quite important when we work with
JavaScript. To create your first file containing JavaScript, you can start
by making a .html file. We usually call the home page of a website
index.html when building websites, so for this example, I created a
new HTML file called index.html.
.html files can be opened by any web browser, such as Google
Chrome. You can edit your HTML file by opening it up in a text or code
editor (Notepad included), and puting in this standard “boilerplate”
HTML:

<!DOCTYPE html>
<html>
<head>
<title>My First JavaScript</title>
</head>
<body>
<p>Hello World</p>
<script type=”text/javascript”>
// This is JavaScript!
</script>
</body>
</html>

Note You can use any text editor (like Notepad) to create HTML
and even JavaScript. While that works fine, it’s better to use a
professional code editor instead. One of the most popular code
editors used in the software development community is VS Code.
You can download it via https://code.visualstudio.com/.
This will color code your JavaScript and give you a lot of other useful
features.

In the preceding example, we inserted a <script> tag within our

HTML body. The <script> tag is where our JavaScript goes:

<script type="text/javascript">
// This is JavaScript!
</script>

Since JavaScript applications can get quite long, you may see this
<script> tag substituted out for a file instead. This can be useful
since it lets us separate our HTML and JavaScript into different files.
For example, if we had a separate JavaScript file called
myScript.js stored in the same folder as index.html file, we
could load that into our HTML document by using the src attribute on
the script tag:

<script src="myScript.js"></script>
 You may also see JavaScript embedded into HTML via the attributes
of HTML tags. For example, JavaScript can be put inside a button to
cause something to happen when a user clicks that button:

<button onclick="//JavaScript here"></button>

Setting Up a Code Editor

Throughout this book, I will be writing code using Visual Studio Code or
VS Code. If you do not have a preferred code editor, I would strongly
recommend using VS Code, which you can download via the official
website (https://code.visualstudio.com).
Although it is possible to build a software career through Notepad,
it’s not recommended. Modern code editors like VS Code give you a ton
of useful features, including code highlighting which makes it easier to
read what you’re writing. They also come with more advanced features
like built-in terminals, for when you need those things.
If you download VS Code, you’ll be greeted with a screen that looks
like the one shown in Figure 1-1. From there, you’ll be able to make
new files and folders for storing your projects in.
Figure 1-1 After you install VS Code, open the application. By going to File ➤ Open Folder… or
clicking “Open Folder” in VS Code and finding your “My JavaScript” folder

Starting Up Our Code

The fun thing about writing front-end JavaScript is that once you save
your .html file, you can load it directly in any web browser to test it
out.
Try it out by opening index.html in your web browser, either by
dragging it into the window or by opening it via File ➤ Open File….
To see your code in the browser itself, you can right-click on the
web page anywhere and choose “Inspect” in Google Chrome. If Chrome
is not your browser of choice, similar functions exist in other browsers
too. Using “Inspect” will also let you see supplementary information
about what you’ve created, as Figure 1-2 shows.
Figure 1-2 “Inspect” or “Inspect Element” lets you view more information about your code in
the web browser

“Inspect” or “Inspect Element” is a vital tool in web development.

Throughout this book, we’ll use the console tab within developer tools
to test out code and see the results of code we run. As such, it’s very
useful to familiarize yourself with this display now.

How to Get Started with Writing Back-End JavaScript

We’ve now discussed how JavaScript can be run inside a web
browser like Google Chrome. Before we go any further, let’s briefly look
at how we run back-end JavaScript too, which we’ll occasionally touch
on in this book. Back end JavaScript runs directly on your computer or a
web server instead of inside a web browser. To run JavaScript like this,
you need to use a runtime like Node.js.
Node.js can be downloaded and installed on your computer via the
official Node.js website (https://nodejs.org/en/download).
After it has been installed, you’ll be able to run JavaScript code directly
from a terminal window by executing your .js file.
You can do that by opening the terminal or command line on your
computer, which is accessible on MacOS via the terminal app or on
Windows via the “cmd” application.
Running the node command lets you compile and execute
JavaScript files. Let’s try it out – create a file called index.js in a
code editor or Notepad, and add the following JavaScript code before
saving:
console.log("Hello World!")

Then you can execute this file by using the node command in
terminal:

node index.js

This will produce an output which looks something like what is

shown in Figure 1-3.

Figure 1-3 Running a JavaScript script from the command line is as simple as using the “node”
command followed by the directory link to the file you want to run

Note If you saved your index.js file in another directory, you will
need to provide the full directory link. To navigate directories, use
the cd command. For example, if your index.js file was in
“/Users/JohnDoe/Documents/”, you would run cd
/Users/JohnDoe/Documents/ and only after that, run node
index.js.
Node.js applications like this are frequently used to create APIs,
which we will cover in much more detail later in the book.
Creating Node.js JavaScript Projects
In the above example, we executed a single file using Node.js It is more
common, though, to create a Node.js project when you start something
new in Node.js. This is also done via terminal or the cmd. The first step
is to make a new folder and navigate to it using the cd command.
In this example, I made a folder called “node-project” on my desktop
and navigated to it using the following command in Terminal:

cd ~/Desktop/node-project

After that’s done, you can use the npm init command, which is
installed along with Node.js, to initiate your project. You can see how
that looks in Figure 1-4.

Figure 1-4 When using the npm init command, you will be asked to enter some information
about your new project as shown earlier
 All you have to do now is type in answers to each question and
press enter. For example, the first question asks what you want to call
your project – so type in the name of your project, and press enter.
Your folder will now contain a package.json file summarizing
the information you provided. Since you’ve initialized your Node.js
project, you’ll now be able to run other commands like npm install
now, which lets you install third party dependencies.

JavaScript Support
Traditional software is usually written by a developer and downloaded
onto a user’s computer or device. This is the case with things like video
games, apps on your phone, or big applications like Adobe Photoshop.
When writing code in JavaScript, things are very different. The
software the user installs is the browser, not your website! The browser
then loads your web page within it. Since everyone has their own
browser preference, and not everyone keeps their browsers up to date,
JavaScript that works in one browser can oftentimes not work in
another. For example, Firefox may support a new JavaScript feature, but
Chrome may not. The worst thing about this is you can’t really use a
new JavaScript feature on the front end until a majority of browsers
have implemented it.
If you are coming from other languages, then worrying about
browser support will be a foreign concept to you. In JavaScript, it is a
real thing. In recent times, since most browsers are “evergreen”
(meaning they auto-update), this has become less of a problem than it
used to be, but sometimes different browsers just disagree on what
should and shouldn’t be implemented. Promising new features may end
up implemented in just Chrome, just Safari, or just Firefox.
Throughout this book, we’ll only be looking at JavaScript with broad
browser support, meaning you don’t need to worry about if you can or
can’t use it. However, when you start exploring JavaScript in your own
time, and especially when looking at more advanced functionality, it’s
important to check if browsers support it. You can find good browser
support tables on websites like https://caniuse.com/ or
https://developer.mozilla.org/.
An example of a browser support table can be found in Figure 1-5,
for the GPU feature.
Figure 1-5 Not all browsers support every new JavaScript feature. In the preceding example,
only Chrome and Edge have support. Other browsers only have partial support or none at all.
That means if you tried to implement this on a website, only some users could use it!

Summary
In this chapter, we’ve looked at how to set up your workspace to begin
writing code with JavaScript. We’ve discussed what JavaScript is
typically used for and some of the pitfalls or differences between it and
other languages. Now that we’ve covered the basics let’s look at how to
write JavaScript code.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer Nature 2023
J. Simpson, How JavaScript Works
https://doi.org/10.1007/978-1-4842-9738-4_2

2. Code Structure and Logical

Statements
Jonathon Simpson1
(1) Belfast, Antrim, UK

In the previous chapter, we covered the fundamental definitions of

JavaScript and where we write it. Now that we’ve discussed the basics,
let’s start learning about how we write JavaScript code. In this
chapter, we’ll cover the fundamentals, which includes code structure,
logical statements, and variables. Mastering these concepts is a
requirement to writing useful JavaScript code. Where relevant, we’ll
also be diving deeper into how these basic concepts actually work, so
that you have a deeper understanding of the code you are writing.

Getting Started
As we go through this chapter, it will be good to have a work space
where you can write and test your JavaScript. For these purposes, I’ve
created a folder called “javascript-project” in my documents
folder. Within that, I have created two files – index.html and
index.js.
Since our focus will be writing JavaScript, your HTML file can be
relatively simple:

<!DOCTYPE html>
<html>
<head>
<title>My First JavaScript</title>
 </head>
<body>
<p>Hello World</p>
<script src="index.js"></script>
</body>
</html>

Any JavaScript code you want to try out can be put in index.js.
For now, I’ve only put a simple console.log method:

console.log("Hello World!")

The console.log method is really useful. It’s used extensively for

debugging, and we’ll be using it throughout this book. When it’s run, it
logs a message to your browser’s console, so that you can see the
output of your code easily. You can find the console by right-clicking
anywhere on your web page and selecting “Inspect.” Console logs can
then be viewed under the “Console” tab, as shown in Figure 2-1.

Figure 2-1 Right-clicking in the web browser and selecting “Inspect” in Google Chrome (or
other browsers) allows you to access the console log. If you do this with the index.html file we
defined before, you’ll see “Hello World!” written here. The console is a powerful tool used for
debugging. When we use the console.log method, it shows up here!

Common Code Conventions

Before we start writing real code, let’s first consider some basic code
conventions. As is the case in most programming, developers of
JavaScript try to follow some common conventions when writing code.
This section is largely opinionated, but it does provide you with
guidelines on how you should go about writing JavaScript. It will also
let you know how we will go about writing code throughout the book.

Semicolons
For readability, JavaScript is sometimes written with a semicolon at the
end of each line. For example:

console.log("Hello World!");
console.log("Goodbye World!");

However, this is not necessary, and it’s also just as common to see
the same code written without semicolons:

console.log("Hello World!")
console.log("Goodbye World!")

We can do this because JavaScript will intuitively “figure out” where

semicolons should go. It even works if you do an accidental line break
where an expression seems incomplete. For example, if a line ends with
a + symbol, JavaScript will assume that the expression must continue
onto the next line, meaning the code will still work as expected:

console.log(5 +
6)

For the code in this book, we will be omitting the semicolon unless
it is really needed.

Spacing
One of the most vigorously fought over code conventions is whether to
use tabs or spaces for indenting. While there is essentially no right or
wrong answer to this, it is important to be consistent. If you use tabs,
then always use tabs for indents and likewise for spaces.
Unlike Python, indents play no functional role in JavaScript, but they
do serve to make your code more readable when others look at it.
While it is certainly fine to use tabs, spaces are going to cause you less
of a headache. That’s because different ecosystems and operating
systems can be configured to handle tabs differently, whereas spaces
are consistently sized across all systems.
In this book, we will indent with four spaces. Here is an example of
how that will look:

let myVariable = 5

if(myVariable === 5) {
console.log("The variable is 5!")
}

Note If you use the tab key instead of spaces in VS Code to indent
your code, you can configure VS Code to automatically convert these
to spaces if you want it to. The configuration option is found by
opening any file and selecting the “Spaces/Tab Size” option in the
bottom right-hand corner.

Variable and Function Naming

When it comes to naming functions and variables, you’ll come across
three different paradigms: camel case, pascal case, and underscores:
Camel case refers to naming a variable where every word after the
first has a capital letter, for example, thisIsCamelCase.
Pascal case is the same, except the first letter is capitalized too. For
example, ThisIsPasalCase.
Underscoring refers to separating words with underscores. For
example, these_are_underscored.
 When naming variables and functions, all of these are fine to use,
but again, it is important to be consistent. If you decide to use camel
case, then make sure you use it everywhere. For the purposes of this
book, we will be using camel case.

JavaScript Variables
As we begin writing JavaScript, the first thing you’re going to need to
learn about are variables. Variables are a way to assign a fixed name to
a data value. There are three ways to create a variable in JavaScript,
using three different keywords:
var
let
const
All JavaScript variables are case-sensitive, so myVariable is
different from MYVARIABLE. In JavaScript nomenclature, we
usually say that we “declare” variables.

Setting Variables with let

Most variables in JavaScript are set with let. A variable set with let
starts with the keyword let, followed by the variable name and an
equals sign, and then the value of your variable. In the following
example, we create a variable called myVariable, and console log it so
that it appears in the browser’s console:

let myVariable = 5
console.log(myVariable)

Note It may seem like we are putting data into the variable, but a
better way to think about it is we are making data and then pointing
the keyword “myVariable” at the data we just made.

It’s not possible to assign a variable with let twice. If you think of your
variable as pointing to some data, it’s easy to see why – the same
variable can’t point to two different pieces of data. For example, the
following code will produce the error, which is shown in Figure 2-2.

let myVariable = 5
let myVariable = 10
console.log(myVariable)

Figure 2-2 Variables defined with let cannot be defined multiple times. If you try to, it will
produce an error like the preceding one

So variables defined with let cannot be redefined again. They can,

however, be reassigned to a new piece of data by mentioning them
again without the let keyword. You can see that in the following
example, which console logs “10,” since we changed the value of
myVariable:

let myVariable = 5
myVariable = 10
console.log(myVariable)

It may seem like the data has changed (or “mutated”), but actually
we’ve just made new data somewhere and pointed our variable to that
instead. The data “5” still exists somewhere. It just has no variable
pointing to it anymore. When a piece of data is no longer referenced in
our code, JavaScript may remove it from memory using something
called “garbage collection.” This allows JavaScript to free up memory
when data is no longer used.

Block Scoping with Variables

In the previous example we saw that it is not possible to define the
same variable, but there are exceptions to this. That’s because variables
defined with let are block-scoped. Scope confines functionality,
variable names, and values to certain sections of our code.
 Block scopes are created with curly brackets {}. In most scenarios,
we create block scopes by defining new functions or logical statements.
Since standalone curly brackets also create a new block scope, a
variable can be set twice simply by defining it again inside { } curly
brackets:

let myVariable = 5

{
let myVariable = 10
console.log(myVariable)
}

console.log(myVariable)

Even though we created the same variable twice, no error is thrown,

and that’s because one is assigned to a new block scope. The first
variable is assigned to the “global” scope of our program, while the
second is assigned only to the “curly bracket” scope. The outcome of
this can be seen in Figure 2-3.

Figure 2-3 While using let, our console produces two different lines, 5 and 10. This is
because let is assigned to its current scope – so setting myVariable to 10 in a separate scope
does not affect the original variable. If we used var instead, both lines would say 10 since
scope is ignored
Setting Variables with var
Most variables are set with let, but you may also see the keyword var
being used to set variables sometimes. Using var is the original way to
set variables in JavaScript. It is valuable to know this exists, but it is
generally not recommended that you use it over let.
Setting a variable with var looks a lot like what we did with let.
For example, here is a variable called myVariable, with a value of 5:

var myVariable = 5

The reason why we use let rather than var is because var has a
few quirks that let does not. For example, you can define a variable
twice with var, and no errors will be thrown:

var myVariable = 5
var myVariable = 10
console.log(myVariable)

Variables defined with var are also not block-scoped, meaning your
code can produce some odd results when redefining variables in block
scopes with var.
You may be wondering, “Why does JavaScript have two ways of
defining variables when let is a more controlled version of var?” The
answer to that is pretty simple, and it’s because var used to be the only
way to define variables in JavaScript, and a lot of legacy code uses it.
Later on, JavaScript created a better way to define variables using let,
but var couldn’t be removed since it would break many older code
bases.

Setting Variables with const

The final variable type we will cover is const. When we defined
variables with let, we talked about how a variable can be reassigned
to another value:

let myVariable = 5
myVariable = 10
console.log(myVariable)

Remember, we don’t actually change or “mutate” the data here – we

just create new data and “re-point” our variable to that new data
source.
While this works for let, it will not work for const. Variables
defined with const are constants and cannot be reassigned:

const myConst = 5
console.log(myConst)

If you try to reassign the value of a const variable, you’ll get an

error instead.

const myConst = 5
myConst = 10
console.log(myConst)

Using const to define variables is better when you’re able to use it.
To understand why, you can think about the example we
discussed earlier where we used let to reassign a variable from “5” to
“10”. We talked about how the value “5” still exists in memory unless it
gets garbage collected. Since const variables cannot be changed,
garbage collection never has to run. That means less cleanup is
required, resulting in more efficient memory utilisation.

Mutation of const Variables

Variables cannot be reassigned with const, but they can be mutated.
That’s because reassignment and mutation are not the same thing.
When we reassign a variable, no data changes – but it is possible to
change underlying data in JavaScript using mutation instead. In
JavaScript, mutation of primitive values like numbers, strings, and
booleans is not possible, but objects can be mutated.
We will cover how arrays and objects work in more depth in the
next chapter. For now, all you need to understand is that arrays and
objects are containers of data. An array can be defined as shown in the
following example:
const myArray = [ "some", "set", "of", "content" ]
console.log(myArray)

Arrays can contain a lot of data, and we can push new data to an
array using a special method called push:

const myArray = [ "some", "set", "of", "content" ]

myArray.push("new data!")
console.log(myArray)

By using push we can mutate our array, meaning the underlying

data changes and the data continues to be referenced and stored in the
same place. In other words, we did not create new data and point our
variable somewhere else, but instead mutated the original data.
This is confusing to beginners since the array was pointed to by a
const variable, so it would therefore be assumed that since the const
variable is a constant, the data inside must always remain constant.
This is not the case in JavaScript. So, in summary, while reassignment
must remain constant in a const variable, data mutation is fine.

Defining Variables Without Values

It is also possible to define variables that point to nowhere. If you try to
console log a variable with no value assigned, you will get undefined
as a result:

let myVariable
console.log(myVariable)

This is sometimes done when a variable does not have a value when
you declare it but may be assigned a value later on in the code. When
many variables need to be declared without values, they can be
separated by commas. In the following example, we define three
variables with the let keyword:

let myVariable, myOtherVariable, myFinalVariable

 Although comma notation like this is more commonly used with
variables that have no value, you can declare variables with values this
way too:

let myVariable = 5, myOtherVariable = 4,

myFinalVariable = 3

Assignment Operators
Now that we’ve covered the basics of setting variables, let’s look at
assignment operators. These allow us to modify an existing variable, by
changing its value. For example, consider this variable:

let x = 5

Suppose we wanted to multiply x by 5. One way is to reassign x to 5

* 5, but a better way is to use an assignment operation. The reason it’s
better is because x may not always be 5, so this is particularly useful if
we want to change the value of variables based on conditions (which
we will cover in more detail in the following).
To multiply x by 5, we use the *= assignment operator:

let x = 5
x *= 5
console.log(x) // Console logs 25 (5 multiplied by
5 = 25)

There are many other assignment operators. They are shown in the
following example:

let x = 5
x *= 5
console.log(x) // Console logs 25 (5 multiplied by
5 = 25)

x += 5
console.log(x) // Console logs 30 (25 plus 5 = 30)
x /= 5
console.log(x) // Console logs 6 (30 divided by 5
= 6)

x -= 1
console.log(x) // Console logs 5 (6 minus 1 = 5)

x %= 4
console.log(x)
/*
Console logs 1 (if you divide 5 by 4, the
remainder is 1.
% is the remainder operator
*/

Variable Concatenation
When we have variables that consist of at least one string, using the +
operator causes the strings to become concatenated. To understand
this, take a look at the following example, where we concatenate two
strings into a new variable:

let myVariable = "hello"

let myOtherVariable = "world"
let combine = myVariable + myOtherVariable //
"helloworld"

If we need a space too – we can add that with another +:

let myVariable = "hello"

let myOtherVariable = "world"

// "hello world"
let combine = myVariable + " " + myOtherVariable

Just be careful, since if you try to use a + with numbers, it will add
them up instead!

let myVariable = 5
let myOtherVariable = 5

let combine = myVariable + myOtherVariable // 10

This brings us to a new quirk caused by JavaScript’s dynamic typing.

If a number is in quotation marks, it is assumed to be a string. Adding a
number and string results in a new concatenated string instead of a
calculation:

let myVariable = "5"

let myOtherVariable = 5

let combine = myVariable + myOtherVariable // "55"

Another way to combine string variables is with a special method

called concat. This is a method that exists on all strings, which will
add to the end of a string any number of new things that we separate
with commas:

let myVariable = "hello"

myVariable.concat(" ", "world", "!") // hello
world!

Different types of data have different built-in methods, which we’ll

look at in much more detail in future chapters.

Template Literals
Another final way to concatenate more elegantly is through a type of
functionality called template literals. Template literals are still strings,
but they use the backtick "`" to transform any content into a template
literal. Template literals have the added benefit of allowing line breaks
– something that numbers and quotation marks do not. They also allow
for substitution. Here is an example of a particularly messy template
literal with line breaks throughout:

let myVariable = `hello world

!!
how are you?`
 Template literals like the preceding one will be taken with line
breaks and white space included – which means you’ll avoid loss of this
content when using them. They also allow for substitution. Adding a
variable in ${} will substitute it into a template literal:

let someWord = "world"

let myVariable = `hello ${someWord}!` // hello
world!

JavaScript Comments
You may have already noticed that in the preceding code, I used double
slashes to leave some comments on what the code does. As our code
gets more complicated, it’s useful to leave messages to yourself or other
developers about what is going on. For this purpose, comments are
used.
A comment in JavaScript can take one of two forms. The first looks
like this:

// I am a comment!

And the second looks like this, where the comment is enclosed in /*
and */:

/* I am a comment! */

Both work the same, but the second allows for multiline comments.
Comments have no bearing on the functionality of your code and
instead can provide useful information on what’s going on. For
example, we could comment our previous code like so:

// This code will console log myConst

const myConst = 5
console.log(myConst)

Logical Statements
Now that we’ve covered variables, you’ll probably be wondering how
we can use them. Logical statements are one of the ways we can start to
put our variables to good use.
Logical statements are used when we want to check if something is
true or false and then run a particular action based on that outcome. If
a logical statement is found to be true, everything within its “block
scope” is executed. Likewise, if a logical statement is false, then the
block scope will never run at all. In other words, logical statements
allow us to build conditionality into our programs.

If…else Statements
if...else are perhaps one of the most commonly used logical
statements around. All they do is check if a statement is true. If it is,
they run some code, else, they run some other code. In the following
example, we check if myVariable is set to 5. If it is, we show “The
variable is 5!” in the console. If it’s not, then we show alternative text.
You can view this code running in Figure 2-4, where I run it directly
from the console in my web browser. You could also try this out by
updating your index.js file from earlier:

// We have set myVariable to 5

let myVariable = 5

if(myVariable === 5) {
console.log("The variable is 5!")
}
else {
console.log("The variable is not 5.")
}
Figure 2-4 Since myVariable is 5, the statement myVariable === 5 is always true. So the
block of code within the first if statement is executed, and the else statement never fires

We can add more conditions to our code by using else if after an

if statement. In the following example, we check for a third condition,
where myVariable could be 6:

// We have set myVariable to 5

let myVariable = 5

if(myVariable === 5) {
console.log("The variable is 5!")
}
else if(myVariable === 6) {
myVariable = 7
console.log("The variable is 6, but I set it
to 7!")
}
else {
console.log("The variable is not 5.")
}

As you can see in the else if condition, any code can be written
in the block scope created by a logical statement. In else if, we
reassigned myVariable to have a value of 7.
If the output of an if statement is one line of code, you can omit the
curly brackets and write it all on one line of code as shown in the
following example. This also applies to else if and else:

// We have set myVariable to 5

let myVariable = 5

if(myVariable === 5) console.log("The variable is

5!")

Our examples so far have dealt with strict equality – meaning we

are using the triple equals sign. There are more ways we can check
variable values, though! We’ll cover them all in this chapter.

Switch Statements
Another common way to create conditionality in your JavaScript is
through switch statements. They take a single variable and check if it
equals certain values using the case keyword to define the value it
might equal and a break to declare the end of that clause. For
example:

// Let's set x to 5
let x = 5

switch(x) {
case 5:
console.log("hello")
break
case 6:
console.log("goodbye")
break
}

In the previous example, we have two clauses: one where x equals

5, in which case we console log “hello,” and another where it equals 6,
where we console log “goodbye.” It is important to have a break after
each case clause since if you don’t, all cases will run after the one that is
correct! For example, the following code will console log both “hello”
and “goodbye” – which is quite confusing:

// Let's set x to 5
let x = 5

switch(x) {
case 4:
console.log("4!")
case 5:
console.log("hello")
case 6:
console.log("goodbye")
}
Figure 2-5 Since we didn’t use the keyword “break” in the preceding code and x is equal to 5,
both “hello” and “goodbye” are console logged. The “break” keyword is important for declaring
the end of a clause in a switch statement.

This “fall-through” mechanism where we leave out a break statement

can sometimes be used to your advantage, however. In the following
example, both Apples and Strawberries are red, so console logging the
same thing for both is not really an issue:

let x = "Apples"

switch(x) {
case "Apples":
case "Strawberries":
console.log("Apples and Strawberries can
be red.")
break
case "Bananas":
console.log("Bananas are yellow.")
}

Defaulting to a Clause with Switch Statements

Switch statements make use of the keyword default to declare what
needs to happen if none of the cases are matched. In the following
example, the console will show “goodbye” since no clause is correct:

// Let's set x to 5
let x = 5

switch(x) {
case 4: {
console.log("hello")
break
}
default: {
console.log("goodbye")
break
}
}

Equality with Switch Statements

Like our example before with if…else, switch statements require
“strict” equality. That means under the hood, they are using the triple
equals sign (===). Strict equality means that both the value and type of
the data must match for a clause to be true. This can sometimes be
confusing in JavaScript since types are inferred. In the following
example, both 5 and “5” have the same value but different types. As
such, only “goodbye” is shown in the console:

// Let's set x to 5
let x = 5

switch(x) {
case "5": {
console.log("hello")
break
}
case 5: {
console.log("goodbye")
break
}
}

Block Scoping with Logical Statements

Earlier, we discussed how block scopes affect let and const variables.
Standard if...else statements by default have block scopes; as they
use curly brackets {}, switch statements do not, by themselves,
create block scopes. We can add block scope to our switch statements
by enclosing each clause in curly brackets if we need to.
The outcome of the following code is an error since we reassign x
multiple times: Uncaught SyntaxError: Identifier 'x'
has already been declared:

// Let's set x to 5
let x = 5

switch(x) {
case 5:
let x = 6
console.log("hello")
break
case 6:
let x = 5
console.log("goodbye")
break
}

To avoid this error, a block scope can be created by adding curly

brackets {} to our switch statement:

// Let's set x to 5
let x = 5

switch(x) {
case 5: {
let x = 6
console.log("hello")
break
}
case 6: {
let x = 5
console.log("goodbye")
break
}
}

Conditional Operator in Variables

So far we’ve covered statements that convey conditionality, but
conditionality can also be extended to variable declarations themselves.
This is done via a special operator called the conditional operator.
 You can test any statement inside a variable by following it with a
question mark. This is then followed by two values separated by a
colon. The first value after the question mark will be what shows if the
statement is true, and the second will be returned if the statement is
false. In the following example, y becomes “Big Number” since x is
indeed bigger than 3:

let x = 5

// Returns "Big Number"

let y = x > 3 ? "Big Number" : "Small Number"

Logical Statement Comparison Operators

In our previous examples, we’ve covered basic logical statements using
strict equality (===). For example, if...else statements:

if(myVariable === 5)

and switch statements, which always use strict equality.:

switch(variable)

That means both the value and the type of data have to match for
the statement to be true. For example, '5' is not the same type as 5
even though the values are the same since the types are different:

let myVariable = 5
if(myVariable === 5) // True!
if(myVariable === "5") // False!

Besides strict equality, there are lots of other ways we can compare
data in logical statements. In the following example, we use the more
than operator to check if myVariable is more than specific values. The
outcome of this code can be seen in Figure 2-6.

let myVariable = 5
if(myVariable > 4) console.log("Hello World") //
True!
if(myVariable > 6) console.log("Hello World 2!")
// False!

Figure 2-6 Other operators can be used to test logical statements. In the preceding example,
we use the more than operator to check if myVariable meets certain conditions

We can check for “regular” equality too, which ignores type, using
the double equals (==) operator:

let myVariable = 5
if(myVariable == '5') // True!

The symbols we use to compare data in logical statements are

generally known as “operators.” All the operators we have access to are
summarized in Table 2-1.
Table 2-1 JavaScript operators for logical comparisons

Operators Definition Example

=== Strict equality. Both the type and value of the data must be the 5 === 5 //
same. True
5 === '5' //
False
== Regular equality. Only the value must be the same. 5 == 5 //
True
5 == '5' //
True
Random documents with unrelated
content Scribd suggests to you:
admiralo! Ni jam sufiĉe suferis per via kulpo! Vi evidente forgesis, ke
estas certaj limoj, kiujn oni ne rajtas malatenti!

Je la pordo de kajuto de Magalhaes ekfrapis Henriko.

“Sinjoro admiralo, venis maristoj.”

“Kiuj?”

“Reprezentantoj de ĉiuj ŝipoj, krom tiuj de Trinidado. Ili estas

gvidataj de ŝipoficiro.”

“Ili eniru!” diris admiralo.

La deputacio eniris. Rigardoj de maristoj por momento

maltrankviliĝis, kiam ili renkontiĝis kun okuloj de Magalhaes. Ili
preskaŭ perdis la memkonfidon, kun kiu ili eniris al sia supera
komandanto. Sed tio daŭris nur momenton. Ilin fortigis la ideo, ke
du cent maristoj volas la samon kiel ili.

“Kion vi deziras?” demandis Magalhaes.

“Sinjoro admiralo,” komencis la oficiro, “ni venas kiel senditoj de

oficiroj kaj ŝipanaro. Ni devas informi vin, ke ni ĉiuj havas ununuran
kaj la saman deziron: reveturi en Hispanujon.”

Magalhaes eĉ ne palpebrumis.

“Sidiĝu,” li diris trankvile. Nur kiam ili sidiĝis, li demandis: “Kaj kio
estas la kaŭzo de via deziro?”

“Ni estas lacaj, sinjoro admiralo,” respondis konfideme la oficiro,

surprizita per afableco de la supera komandanto. “La ŝipanaro estas
elĉerpita kaj nun oni intencis kvantojn de la nutraĵoj ankoraŭ
plimalgrandigi. Ni timas, ke pluajn suferojn ni ne plu sukcesus toleri.”

“En kies nomo vi parolas?” demandis mallonge admiralo.

“En la nomo de ĉiuj oficiroj kaj de la tuta ŝipanaro. Nu, parolu vi
mem,” la oficiro turniĝis al maristoj.

Tiuj vigle konfirmis veron de liaj vortoj.

Magalhaes silentis, pripensis, meditis.

“Kaj ĉu tio vin tute ne ĉagrenus — reveturi, kiam ni jam estas

atingintaj tiom malproksimajn landojn?”

“Nenio okazus, sinjoro admiralo,” daŭrigis vigle la oficiro. “Post

reveno en Hispanujon oni aranĝus novan ekspedicion. Ĝi jam ne
bezonus traserĉi ĉiun golfon, kiel ni devis tion fari. Ĝi celdirektus
rekte al golfo San Julian kaj de ĉi tie ĝi komencus pluan esploradon.”

“Rigardu,” diris admirinde milde Magalhaes, “via vidpunkto ne estas

ĝusta. Mi mem scias plej bone, kiom da penado oni bezonis por
aranĝo de ĉi tiu ekspedicio. Kiu garantias al ni, ke oni vere forsendus
novan ekspedicion? kaj — eĉ se tio okazus — kiom da jaroj estus
perditaj!”

“La perditaj jaroj signifas nenion en tiu kazo, se temas pri vivo de
homoj,” oponis energie la oficiro.

“Kion vi volas per tio diri?”

“Vi mem scias, sinjoro admiralo, kiom da viroj jam mortis kaŭze de
suferoj. Kaj vi povas imagi al vi, kio atendus nin dum plua veturo.”

“Mi scias tion. Kaj ĵus pro tio mi ordonis la dumvintran restadon. Ĉi
tie ni pasigos la plej malbonajn monatojn, kaj ĝis venos pli varma
vetero, ni veturos antaŭen.”

“Tio ne estas ebla, sinjoro admiralo,” rezistis la oficiro. “Ni venas por
peti vin, ke vi ordonu reveturon.”

Magalhaes kun peno superregis sin.

“Cetere,” aŭdiĝis unu el la maristoj, “ni alveturis tiom malproksimen,
kien ankoraŭ neniu Hispano sukcesis alveni. Via merito estos de Lia
Reĝa Moŝto certe juste rekompencita.”

“Ne temas pri rekompenco,” admiralo estis ĉiam ankoraŭ ŝajne

trankvila, “sed pri atingo de la starigita celo. Mi ĵuris al la reĝo, ke mi
faros ĉion por malkovri novan vojon al Molukoj. Vi ĵuris kun mi. Diru
mem: ĉu ni faris ĉion, kio estis en niaj fortoj?”

La maristoj embarasiĝis, sed oficiro diris rapide:

“Nian devon ni plenumis. Sed vi devigas nin plenumi tiajn aferojn,

kiuj ne estas plenumeblaj.”

Magalhaes sulkigis brovojn.

“Kaj kiam ni estis dungataj,” aldonis al vortoj de la oficiro plua

maristo kaj li sentime rigardis en okulojn de Magalhaes, “oni diris al
ni, ke ni veturos en varmajn regionojn, sed ne al glaciaj maroj.”

Fernao peze leviĝis.

“Mi esperis, ke mi trovos ĉe miaj maristoj pli da kuraĝo kaj aŭdaco

por venki la malfacilaĵojn. Nu... Diru al tiuj, kiuj sendis vin, ke mi
prefere mortus, ol ordoni la reveturon. La instrukcioj, kiujn mi donis,
tute ne ŝanĝiĝos: Ni dumvintre restos ĉi tie kaj poste ni veturos plue
al sudo, ĝis tiu tempo, kiam ni malkovros la trapasejon. Poste ni
ekvojaĝos al Molukoj.”

La deputacio rapide foriris.

Magalhaes profunde enpensiĝis. Ĉi tiu delegitaro, ĉi tiu deputacio —

ĝi estas certe la faro de hispanaj hidalgoj. Kaj precipe de Cartagena.
Li faris malbone allasinte, ke vicadmiralo vivu kun Mendoza sur la
sama ŝipo. Henriko jam kelkfoje atentigis lin, ke Viktorio estas
komandata propre de Cartagena, malgraŭ tio, ke li devas tie vivi kiel
arestito.
El pensoj de Fernao naskiĝis energia decido. Post kelkaj momentoj
veturis de Trinidado al Viktorio ŝalupo kun ordono de admiralo:

“La arestiton Cartagenan tuj translokigi al Concepcion, al kapitano

Queseda!”

Queseda ja estas ankaŭ Hispano, sed per subita translokiĝo de

Cartagena al Viktorio la hidalgoj estos almenaŭ tre akcente
atentigitaj, ke admiralo ne intencas pasive toleri iliajn intrigojn.

Ĉiuj ŝipanaroj transportis sur la bordon platojn, trabojn, hakilojn,

rabotilojn kaj aliajn instrumentojn. Post nelonge staris sur la kajo
kelkaj lignaj kabanoj, en kiujn estis transportataj provizoj da nutraĵoj
por sekura vintra depono. Magalhaes zorgeme kontrolis ĉiun laboron.
Apud la magazeno devas stari fidela, sindona patrolo. Kiu alia povus
esti ties komandanto ol Serrao?

Malgraŭ tio, ke Serrao havis multajn zorgojn, kien kaj kiamaniere

ĉion lokigi, liaj pensoj ĉiam revenadis al deputacio de ŝipanaro kaj
oficiroj. Kiel li povos efektivigi la veturon, kiu daŭros certe ankoraŭ
longan tempon, kun la ŝipanaro malkontenta, pensanta nur pri la
reveturo? Kiu kulpas pri tio, ke li ne scipovis entuziasmigi la
partoprenantojn de la ekspedicio por sia grandioza plano? Ĉu li ne
kulpas pri tio mem pro sia izolemo? Ĉu li agis ĝuste malrespektante
kapitanojn de la ceteraj ŝipoj? Eble ili havis iajn malhelajn planojn tuj
kiam li forlasis Hispanujon. Sed ĉu ili ne ŝanĝiĝus vidante, ke
admiralo kondutas al ili tiamaniere, kiel oni devas konduti al
kapitanoj? Se li informus ilin detale pri la celo kaj antaŭvidata
procedo de la veturo — se kompreneble oni povus ion antaŭvidi? Se
li antaŭ ĉiu grava decido konsiliĝus kun ili?

Tro multe da malkonfido estis semita en koron de Magalhaes antaŭ

forveturo sur vastan oceanon. Kaj kion li faris por liberigi sin de ĝi? Li
fermiĝis en sian izolecon kiel en firman konkon. Sola, sola, sola... Ĉu
tio estis ĝusta?
Vermo de duboj boris en pensoj de Fernao. Cetere — ĉu estas jam
malfrue por ĉio? Kun Cartagena estas fino, tio estas vero. La
vicadmiralo neniam pardonos al li pro tio, ke li estis arestita. Sed
krom Cartagena estas ĉi tie Queseda, Mendoza kaj finfine ankaŭ
degradita Cota. Ĉu vere estas malfrue?

Kaj kio okazus, se —?

Subita ideo heligis vizaĝon de Fernao. Jes, li faros tion! Nova sciigo
al ĉiuj ŝipoj: “Morgaŭ — la Paskan Dimanĉon — oni celebros sur la
bordo solenan meson. Poste sekvos revizia parado, kiun partoprenos
ĉiuj maristoj, oficiroj kaj kapitanoj.”

Kaj krom tio aparta sendito al komandantoj: “Admiralo invitas

kapitanojn al solena tagmanĝo post finita revizia parado.”

Tiun vesperon enlitiĝis Magalhaes kun stranga paco en la koro. Jes,

tiel estos ĉio en ordo. Ili ja vivos kune ankoraŭ longan tempon. Ilin
atendas ankoraŭ momentoj de novaj kaj novaj suferadoj. Kaj ĉion
oni pli facile toleros, se ili kondutos unu al la alia pli konfideme, pli
malkaŝe, pli sincere kaj pli afable.

Li, admiralo de la ekspedicio, etendas al hidalgoj manon por amikiĝo.

Ĉio sekvonta dependos jam de ili.

Kaj jam alproksimiĝis mateno de la unua aprilo 1520...

Sur la bordo estis konstruita simpla ligna altaro, ĉe kiu la pastro

celebris meson. Maristoj kaj oficiroj surmetis siajn plej bonajn
vestojn. Post la celebra ceremonio ili viciĝis kaj admiralo faris
revizian paradon. Jam longe li ne vidis ilin tiel kune. Estu kiel estu, ili
estas bravuloj, se ili tiel parade vestas sin, li ne bezonus honti pro ili
eĉ apud la reĝa kortego.

Li paŝis malrapide laŭ longa vico. Maristoj staris kiel statuoj. Li

rigardis iliajn vizaĝojn, kvazaŭ li volus trapenetri en iliajn animojn. Ili
travivis kune jam multajn momentojn, el kiuj nur malmultaj estis
ĝojigaj. Hieraŭ ili sendis la deputacion, hodiaŭ ili disciplinite obeis
ordonon de sia admiralo. Ne, ĉi tie ne estas necese malesperi. Kun
tiaj maristoj oni jam povas veturi!

La fluso ĵetis sur la bordon ondojn kaj frakasis ilin kun malhela bruo.
Krom tio estis trankvile. La birdo ne ekkantis, la arbo ne ekmoviĝis,
ĉar ĉi tie ne estis arboj, kaj ankaŭ homoj silentis.

Magalhaes finis la revizian paradon. Jam li venis al la loko, kie estis

envicigitaj oficiroj kaj kapitanoj.

Kapitanoj?

Kie ili estas?

En la vico staras nur Serrao kaj Mesquita!

Frosta tremiĝo trakuris korpon de Magalhaes.

“Kapitano Serrao, kie estas la ceteraj komandantoj?”

“Sur la ŝipoj, sinjoro admiralo!”

“Kial ili ne venis?”

“Mi ne scias.”

“Ĉu ili estas informitaj pri mia ordono?”

“Jes, sinjoro admiralo.”

“Ĉu ili senkulpigis sin?”

“Ne.”

“Jen...!”
La vorteto “Jen!” estis elparolita kun nuanco de amareco. Sed Fernao
Magalhaes estis forĝita el malmola ŝtalo. Apenaŭ li konsciiĝis pri la
monstra grandeco de nova disreviĝo, li tuj fariĝis la estinta Fernao.
Malmola, decidema, necedema. Li tuj rekonsciiĝis, kaj tiel okazis, ke
la vorto “Jen!” sonis kvazaŭ malhela minaco.

La kapitanoj rifuzis obei. Ili rifuzis tion dum tiaj cirkonstancoj, ke ne

estas eble dubi pri iliaj intencoj. Al ŝipanaroj estis hieraŭ komunikita
la ordono de admiralo pri la deviga partopreno ĉe diservoj. Ĉiuj
ŝipanoj vidas, ke tri komandantoj ne obeis.

Ĉu ribelo?

Estu! Eble estas pli bone tiel, se oni batalas kun malfermita viziero.
Ĝi ja kuŝis sur la ekspedicio kiel premeganta inkubo tuj de la
komenco — de la kolerigitaj homamasoj en Sevilo ĝis la hieraŭa
deputacio. Estos bone, se ĉio klariĝos.

“Ordonu disiron!” Magalhaes turniĝis al kapitano Serrao. “Vi mem

restu sur la bordo kaj gardu provizojn!”

“Laŭ ordono, sinjoro admiralo!”

Fernao paŝis al sia ŝalupo, kiu forveturigis lin al Trinidado.

Spirito de la ribelo pendis en la aero.

Kaj ribelo en ĉi tiu dezerto povas finiĝi per neniigo kaj ruinigo de la
tuta ekspedicio.
 XII.
Ribelo

La golfo de San Julian estis vualita en nokta mallumo.

En kajuto de admiralo sur Trinidado sidis Fernao Magalhaes kun

kapitano Alvar Mesquita. Lokoj por ceteraj gastoj restis ne okupitaj.

Magalhaes esperis ĝis lasta momento, ke la hispanaj hidalgoj

prudentiĝos kaj akceptos lian inviton. Sed kiam vesperiĝis kaj la
kapitanoj ne alvenis, li diris al Henriko, ke li alportu manĝaĵojn.

“Nur se ni scius, kion ili intencas,” esprimis laŭte siajn pensojn

Mesquita. “Ĉi tiu necerteco estas pli malbona ol malkaŝa atako.”

“Ĝi ne daŭros longe. Morgaŭ ĉio solviĝos.”

Kaj denove estis en kajuto malafabla silento.

Mesquita pensis pri sia ŝipanaro sur San Antonio. Li ja estis kapitano
nur ekde la restado en Brazilio, sed dum tiu tempo li lernis koni sian
ŝipanaron ĝis tia grado, ke li povu taksi, kiun li povas konfidi, kiun li
devas malkonfidi. La plej sindona estas certe Eloriago. La malmilda
maristo, kiu plenumas ĉiujn taskojn kun modela konscienco. Se
ceteraj murmuras pro io, li ĉiam scipovas trankviligi ilin. Kaj ne per
longaj paroloj. Iam li nur svingas per la mano kaj eklaboras, aliokaze
li diras trafan spritaĵon — maristoj ekridas kaj sekvas lin. Estas tie
kelkaj viroj, kiujn li povus konfidi en kazo de eventuala konflikto. Sed
la plejmulto?

Magalhaes reviziis en la animo tutan eskadron. Unu ŝipo post la alia

defilis antaŭ liaj okuloj kun ĉiuj apartenaĵoj: kun bombardiloj, kun
provizoj, kun maristoj, kun oficiroj, kun kapitano...

Viktorion komandas Mendoza. Li tro submetiĝis al influo de

Cartagena. Per tio, ke li ne partoprenis la revizian paradon, li
malkaŝis ĉion. Kaj tamen — la situacio en lia ŝipo ne estas la plej
malbona. Maristoj apartenas plejparte al portugala nacieco kaj
Magalhaes scias, ke portugaloj estas sindonaj al li.

Multe pli danĝera estas Concepcion. Ĝi estas propra centro de la

ribelo. Tie troviĝas Queseda kaj Cartagena. Ĝi estas granda, firme
konstruita ŝipo, kun plej granda nombro da kanonoj kaj provizoj da
nutraĵoj.

Do, ĉi tio estus unu parto, meditas Fernao. La duan parton faras lia
Trinidado. Santiago de Serrao kaj San Antonio de Mesquita.

Tri kontraŭ du, finas sian revizion admiralo. Eĉ se Santiago kaj San
Antonio estas pli malgrandaj karaveloj, finfine ĉi tie decidas la
nombro, la kapableco de pli moviĝema manovrado. Do situacio ne
aspektas iel senesperige. Eble eĉ nenio okazos. Povas esti, ke la
hidalgoj en dormo forgesos sian malpraviĝon kaj matene venos por
peti senkulpigon.

Antaŭ noktomezo akompanis admiralo Mesquitan al balustrado, kie li

kore adiaŭis lin. Momenton li aŭskultis, kiel remiloj de la forveturanta
ŝalupo monotone plaŭdtuŝis akvonivelon de la trankvila golfo. Li
atentrigardis la noktan mallumon, ĉu li ne ekvidos ion suspektan.

Sed karaveloj staris senmove. Profunda trankvilo estis ankaŭ sur la

bordo, kie gardis la deponitajn provizojn fidela Serrao.
Magalhaes ne eraris, kiam li en siaj meditoj indikis centron de la
ribelo al Concepcion. Apenaŭ estis tien transportita Cartagena el
Viktorio, li tuj interkonsentiĝis kun Queseda. Ili jam ne toleros plu la
ordoneman konduton de admiralo. La maristoj estas lacaj per longa
navigado kaj sopiras reveturi hejmen. La ordono de Magalhaes pri
limigo de la nutraĵoj kaj trinkaĵoj ribeligis ilin. Eskadro similas al
barelo da pulvo. Sufiĉas fajrero. Kaj restado en golfo de San Julian
estas kiel kreita por bruligi la ribelon. La ŝipanaroj ĉiutage
kontaktiĝos dum laboroj sur la bordo — kiom da okazoj gajni ĉiujn
maristojn en kontraŭadmiralan tendaron! Kaj kun tiuj, kiuj malgraŭ
ĉio restos fidelaj al Magalhaes, ili jam scipovos fari mallongan
procedon!

La neatendita ordono al surbordiĝo kaj invito al komuna tagmanĝo

estis la fajrero, kiu bruligis la ribelon.

“Nun, kiam li ne scias, kion fari, li estas subite respektplena kaj

afabla!” bruegis Cartagena. “Tiamaniere vi ne aĉetos nin, sinjoro
admiralo!”

“Ni devus honti, se ni akceptus la inviton!” konsentis kun vicadmiralo

Queseda. “Nun — post tiom da monatoj de ignorado!”

“Kaj ne nur al regalo!” decidis energie Cartagena. “Eĉ la paradon vi

ne partoprenos! Vi nek Mendoza!”

“Sed tio signifos malobeon de la ordono, per aliaj vortoj — malkaŝan

ribelon!”

“Jes! Ni jam nenion prokrastos. La admiralo mem decidis pri sia

sorto!”

Ŝalupo de Concepcion veturis al Viktorio. Queseda informis

Mendozon, pri kio li interkonsentiĝis kun vicadmiralo Cartagena.
Mendoza senhezite aliĝis al ili.
Post reveno el revizia parado kunvokis Queseda sian ŝipanaron en
subferdekon.

“Bravaj maristoj!” li alparolis ilin flate. “Mi volas danki al vi por ĉiu
laboro, kiun vi ĝis nun faris en servoj de la reĝo, kaj ankaŭ por ĉiuj
penoj, kiujn vi suferis. Veturante suden vi atingis tiel malproksimajn
landojn, kiujn atingi sukcesis neniu hispana ŝipo. Ĝis ni revenos
hejmen, la reĝo certe laŭ merito rekompencos viajn heroajn farojn.
Vi faris jam pli ol vian devon kaj nun venis tempo por reveturi
hejmen.”

La maristoj nekompreneme rigardis unu la alian. Ĉu tio estas ebla?

Hejmen? Tio, pri kio ili revis, kion ili sopiris kaj postulegis — ĉu tio
nun efektiviĝu? Post ĉi tiuj frostoj kaj veteraĉoj denove lasi sin
sunbruniĝi de arda suno de Hispanujo?

Kunfalditaj trajtoj de la vizaĝoj, kiuj rigidiĝis dum la parado sur

malvarma kajo de golfo San Julian, malrapide moliĝis. Sed ankoraŭ
estis ĉi tie duboj: Kion diros pri la afero la admiralo? Aŭ — ĉu tio
estas lia deziro?

“La admiralo volas veturi plue al la sudo,” daŭrigis Queseda, kvazaŭ li

legus iliajn pensojn, “sed ni, kapitanoj, jam ne submetiĝos al liaj
humoroj. Ni decidis reveturi Hispanujon — kaj tio okazos tuj!”

“Huraaa!” sonegis la subferdeko de ĝojiga perspektivo. Sed ĉiuj

maristoj ne ĝojkriis. Sur la maldekstra flanko aŭdiĝis akra voĉo:

“Kiuj kapitanoj interkonsentiĝis tiel, sinjoro Queseda?”

La voĉo apartenis al dua ŝipoficiro Lopez, kiu klare komprenis, pri kio
ĉi tie temas.

“Mi, vicadmiralo Cartagena kaj kapitano Mendoza!” sonis glacia

respondo, en kiu kuŝis malhela minaco.
Queseda tute ne dubis, ke li sukcesos loginstigi la ŝipanaron kontraŭ
la admiralo. Pro tio li rektiĝis ankoraŭ pli multe kaj kun batala
provokemo li elpaŝis al maldekstra flanko.

“Kaj kial vi demandas, Lopez?”

“Ĉar vi loginstigas nin al ribelo!” respondis kuraĝe Lopez. “Vi volas,

ke ni perfidu admiralon — sed tion ni neniam faros!” Kelkaj
portugalaj maristoj per malhela bruo malkaŝis sian konsenton kun
Lopez.

Queseda sentis, ke li devos agi rapide.

“Neniu devigas vin, Lopez,” li komencis ŝajne bonkore, sed kun ne

kaŝata moko, “nek vin nek tiujn, kiuj konsentus kun vi. Se vi ne volas
reveni en Hispanujon, bonvolu resti ĉi tie kun admiralo en tendaro
sur la bordo, frostu tie en lignaj kabanoj, manĝu vermajn biskvitojn
kaj trinku el malplenaj vinbareloj, tromanĝigu vin per ĉiam
malpligrandigataj nutraĵdozoj — kaj poste, ĝis la vintro finiĝos,
veturu plue en dezertajn regionojn, kiuj estas absolute senvivaj, kiel
ni rimarkas tion jam nun. Ne, ne, ne timu — neniu devigos vin, ke vi
revenu kun ni en florantan Brazilion kaj poste en patrujon.”

“Mi ja eĉ ne permesus, ke iu devigu min,” diris energie Lopez.

En okuloj de Queseda ekfulmis malbonsigna flamo, sed la kapitano

superregis sin.

“Ne aŭskultu lin!” li diris al ceteraj maristoj. “Tro baldaŭ li konos, kiel
li eraris. Mi sciigas al vi, ke en plena konfido je feliĉa reveturo mi
permesas hodiaŭ al la tuta ŝipanaro formanĝi tiom da nutraĵoj kaj
eltririki tiom da vino, kiom al ĉiu plaĉas!”

“Huraaa! Vivat kapitano Queseda!”

Plejmulto da maristoj subiĝis al allogoj de sia komandanto. Ili estis

lacaj per longa navigado. Ili sentis dolore foreston de varmega suno.
Ili suferis per limigitaj kvantoj da nutraĵoj kaj trinkaĵoj kaj timis la
perspektivon, ke iliaj suferoj estas ankoraŭ pligrandigotaj. Fantomo
de rapida finiĝo kun ĉiu suferado ravis ilin.

Avertoj de Lopez perdiĝis en ĝenerala ĝojkrio sen eĥo.

Cetere Queseda observis ĉi tiun grupon tre singarde. Kiam

vesperiĝis, li ordonis al kelkaj plej fidelaj maristoj, ke ili Lopezon kaj
liajn amikojn katenu kaj arestu.

La surprizita atako estis tiel neatendita, embuska, ke malgranda

areto da honestuloj ne havis eĉ tempon por defendi sin.

Similaj scenoj okazis ankaŭ sur ŝipo de Mendoza.

Patroloj el ambaŭ karaveloj de ribelantoj — el Concepcion kaj

Viktorio — zorgeme atentrigardis ŝipojn de admiralo. Sed krom
reveno de kapitano Mesquita al San Antonio ili rimarkis nenion
strangan. Ĉiuhore ili donis raporton al bonhumorigitaj kapitanoj.

Post duonnokto ekveturis de Concepcion ŝalupo, kiu estis plenplena

de ribelantoj. En frunto de tridek maristoj estis Cartagena, Queseda
kaj degradita Coca.

Ili veturis ataki San Antonion, ŝipon de Mesquita.

Queseda ja konsilis al vicadmiralo, ke li restu sur Concepcion, sed

Cartagena rifuzis:

“Atakon ni devos fari en absoluta trankvilo, por ke oni sur Trinidado

nenion rimarku, kaj mi konas sur la ŝipo ĉiun ŝtupeton, ĉiun pordon
— ĝi ja estas mia ŝipo!”

“Mi povas tie ankaŭ orientiĝi!” brulis batalavide Coca. “Mi kredas, ke
mi estos ĉe tiu amuzo ankaŭ iomete utila.”
Pli frue, ol patrolo sur San Antonio povis fari alarmon, ĝi estis
silentigita. Poste la konspirantoj sen malhelpaĵoj penetris en
subferdekon.

Cartagena kaj Coca atakis dormantan Mesquiton. Ankaŭ ceteraj

maristoj, kiujn Coca indikis nefidindaj, estis facile katenitaj. Plejmulto
da ŝipanaro aliĝis al ribelantoj.

La tuta atako okazis rapide kaj senbrue. Ununura, kiu volis defendi
sin, estis Eloriago.

Piedfrapado kaj brueto en subferdeko vekis lin. En flagranta lumo de

laterno li ekvidis Quesedon, malantaŭ lin Cocan kaj areton da armitaj
maristoj el Concepcion. Li tuj divenis, kio okazas. Per raŭka voĉo li
kriis:

“Kion vi serĉas ĉi tie?”

“Silentu!” siblis Queseda. Per du saltoj li troviĝis ĉe duondormanta

maristo kaj per ponardo li mortigis lin.

Cartagena ordonis ariĝi tutan ŝipanaron kaj per obtuza voĉo li

komunikis, kio okazis hodiaŭ en San Julian. Morgaŭ oni informos
admiralon, ke ĉiuj estas jam sataj de ĉi tiu sensenca veturo.
Samtempe li diris, ke la kapitano de San Antonio estas ekde ĉi tiu
momento Elcano.

Elcano estis simpla maristo, sed navigadarton li komprenis kiel

sperta kapitano.

Li estis energia, ĉiam preta, senrespekta.

Ĉiu dormemo de maristoj, vekitaj per tia stranga maniero, subite

malaperis. La imago, ke ili baldaŭ adiaŭos la malafablan regionon kaj
revenos hejmen, plenigis ilin per ebriiga ĝojo. Kaj ilia entuziasmo
kulminis, kiam laŭ ordono de Cartagena ankaŭ al ili estis malfermita
magazeno kaj ĉiu povis preni kion ajn laŭplaĉe.
“Kapitano Elcano,” adiaŭis vicadmiralo, “ni konfidas vian kuraĝon. Se
estos necese, ni ekbatalos kontraŭ la admiralo.”

“Kiel mi konas lin,” respondis Elcano, “li ne rezignos sen batalo. Laŭ
mia opinio estus pli bone ne atendi, sed komenci tuj.”

“En ĉi tiu momento estas admiralo egale jam senpova,” ridis

Cartagena. “Ni superas lin. Kaj Magalhaes estas tro sperta, ol
entrepreni ion dum tiaj cirkonstancoj.”

Ĝuste tiel senbrue, kiel ili alveturis, revenis la ribelantoj al

Concepcion. Ili estis pli multe ol nur kontentaj. Netuta horo ŝanĝigis
subite situacion por ilia prospero.

Komencis malserena, nebula mateno.

Magalhaes staris ekde la unua krepusko sur ferdeko de Trinidado kaj

klopodis penetri per sia rigardo tra la grizlumo al ĉiuj ŝipoj. Nenie
okazis io okulfrapanta. La karaveloj staris sur siaj lokoj senmove,
same kiel hieraŭ.

Kaj tamen! San Antonio ankras multe pli proksime al Concepcion!

Kial faris tion Mesquita?

Ĵus li volis sendi ŝalupon al San Antonio, kiam de Concepcion

forveturis boato kun kelkaj maristoj. Ĝi celdirektis al Trinidado.

Magalhaes streĉe atendis la proksimiĝantajn senditojn.

“Sinjoro admiralo,” diris komandanto de la patrolo, “ni portas al vi

leteron de vicadmiralo.”

“Venu supren!” instigis ilin Magalhaes.

La viroj en boato necerte rigardis unu la alian, momenton ili flustre

parolis, sed poste ili grimpis helpe de malsuprenĵetita ŝtupetaro sur
la ferdekon de Trinidado.
Ili transdonis leteron al admiralo kaj volis foriri.

“Atendu,” postulis ilin Fernao. “Mi tralegos ĝin kaj mi tuj donos
respondon al vi.”

La letero estis skribita per mano de Queseda.

Ribelantaj kapitanoj komunikis al admiralo, pri kio ili decidiĝis kaj kio
dumnokte okazis. Kio kapitanon Mesquita koncernas, li povas esti
senzorga, ĉar tiu estas bone sekurita. La admiralo povos resti en sia
rango, sed venonte li devos agi laŭ deziro de plejmulto da oficiroj kaj
kapitanoj. La decido de ŝipanaro estas firma: reveno hejmen. La
supereco de kapitanoj estas tiom granda, ke estus tute sensenca
komenci fratomurdan batalon, kapitanoj esperas, ke admiralo
komprenos iliajn farojn kaj agos laŭ ilia deziro.

Magalhaes tralegis la leteron kaj turniĝis al la enmaniginto:

“Kiu gvidis la noktan atakon?”

“Kapitanoj Queseda, Coca kaj vicadmiralo.”

“Ĉu iu perdis vivon?”

“Eloriago.”

“Kiel okazis tio?”

La sendito priskribis atakon kontraŭ San Antonio.

“Do — tiel aspektas la afero!” diris kvazaŭ por si Magalhaes, “Nu —

jen la malkaŝa ribelo.”

Li donis signon al Spinoza kaj kelkaj maristoj, kiuj ĉeestis lian

intertraktadon kun la delegitaro.

“Ĉi tiujn virojn sekurigu,” li diris. “Kaj ilian boaton alligu al Trinidado.”
La ordono estis tuj plenumita.

Poste li invitis Spinozon, Barboson kaj kelkajn oficirojn al konsilo en

sian kajuton. Li parolis kun ili longan tempon.

Kiam ili fine leviĝis, diris Spinoza firme:

“Ĝi estas kuraĝa ideo, sinjoro admiralo. Sed ni realigos ĝin.”

Magalhaes skribis leteron por kapitano Mendoza kaj donis ĝin al

Spinoza, kiu akompanata de kvin maristoj enboatiĝis kaj veturis al
Viktorio.

“Sinjoro kapitano, jen letero de la admiralo,” komunikis Spinoza,

kiam ili estis alproksimiĝantaj al Viktorio.

“Sendu ĝin supren!” respondis Mendoza, kiu ne sopiris renkontiĝi

kun ŝipgvidisto de admiralo.

“Mi devas enmanigi ĝin persone. Mi devas interkonsentiĝi kun vi pri

kelkaj detalaĵoj.”

“Do venu! Sed sola!”

Finaĵo de ŝnurega ŝtupetaro falis en la boaton.

Spinoza lerte grimpis supren. Samtempe li kaŝeme rigardis al la

bordo. Neniu atentrigardis ŝalupon el Trinidado, plene okupitan de
maristoj sub komando de Barbosa, kiu proksimiĝis al Viktorio.

Kaj jam estis Spinoza sur la ferdeko. Li transdonis leteron de

admiralo al Mendoza, kiu tuj komencis legi. La admiralo invitis lin sur
Trinidadon al konsilo. Laŭskribe li kunvokis ĉiujn kapitanojn kaj tie ili
interkompreniĝos.

Subite la ŝipgvidisto de Magalhaes eligis ponardon, kiun li havis

zorgeme kaŝitan en la maniko, kaj per unu pikbato li mortigis
Mendozon. Sur la ferdeko troviĝis grupo da maristoj. Kiam ili vidis
falantan kapitanon, ili restis kvazaŭ rigidaj. Iliaj vizaĝoj cindriĝis de
ektimo. Iliaj membroj kvazaŭ ligniĝis.

Nur kiam ili ekvidis akompanantojn de Spinoza, kiuj surgrimpis

sekvante sian komandanton, ili batalpreparis armilojn. Sed en tiu
momento jam kuregis el kontraŭa flanko sur la ferdekon Barbosa
kun siaj armitoj.

“Submetiĝu!” li tondris al terurigitaj maristoj.

Ankaŭ ĉi tiu dua atako estis tiom neatendita, ke la maristoj tuj perdis
ĉiun kuraĝon. Ili rapide forĵetis armilojn kaj falis sur genuojn. Post
kelkaj momentoj ili estis katenitaj.

En sekvanta momento bruegis super la golfo tondra ĝojkrio de tiuj,

kiuj restis fidelaj al admiralo. La flagetoj heroldantaj venkon estis
suprentirataj. La ankro estis levita kaj Viktorio celdirektis al
Trinidado.

Admiralo ordonis siajn fidelajn ŝipojn forveturi al fino de golfo kaj

tiamaniere malebligi forkuron de Concepcion kaj San Antonio.

Sed la ŝipoj de ribelantoj faras nek plej etan movon. La kapitanoj kaj
ceteraj maristoj, kiuj jam vidis admiralon sur genuoj, estas
mortpalaj. Lia nekredebla aŭdaco, kiun li montris atakinte dum hela
tago, plenumis ilin per konsterniĝo. Senmove kiel statuoj ili observis
lertan manovradon de admiralaj ŝipoj. Konfuzita Cartagena forsendis
Quesedon sur San Antonion, ke li tie helpu al Elcano gvidi la batalon.

La ribelantoj ne estis kapablaj kontraŭbatali eĉ en tiu momento,

kiam Magalhaes donis ordonon al rekta atako kontraŭ San Antonio.
Nur kiam Trinidado kaj Viktorio kunpremis la ŝipon de Elcano kvazaŭ
en prenilon kaj admiralo en frunto de siaj maristoj transsaltis sur
ferdekon de San Antonio. Queseda rekonsciiĝis.

Li elŝovis glavon kaj instigis maristojn, ke ili defendu sin. Areto da

plej fidelaj heziteme prenis armilojn. Sed la plejmulto rigardegis la
laman admiralon kun senlima mirego. Kiam li elpuŝegis glavon al
Queseda kaj ordonis kateni lin, la ribelanta ŝipanaro ĵetis sin sur
genuojn kaj kun kunmetitaj manoj ĝi petis pardonon.

La lasta ŝipo de ribelintoj jam tute ne defendis sin. Cartagena estis

militkaptita kaj Mesquita liberigita.

Poste sekvis la juĝo.

Tri kapitanoj kaj kvindek maristoj, kiuj subiĝis al iliaj allogoj, atendis
en katenoj verdikton. Ili sciis, ke ĝi estos senkompata. La leĝoj de
oceanoj, kie interrilatoj de homoj estas multe pli respondecaj ol tiuj
sur la kontinento, estas malmildaj. La ribelon sur la maro oni punis
per la morto — tion sciis ĉiu marista lernanto. Ĉu admiralo ordonos
senkapigi ĉiujn ribelintojn, tio signifas kvinonon de la ekspedicio?

La procesa debato daŭris kelkajn tagojn. Magalhaes ordonis enskribi

ĉiujn okazintaĵojn, kiuj estis decidaj por eldiro de la verdikto.

Kaj denove estis donita ordono ekmarŝi sur la teron.

Tiun tagon — la 7-an de aprilo 1520 — prezentis golfo de San Julian

malĝojigan bildon. La ribelintoj marŝis kun ĉenoj sur la manoj kaj sur
la piedoj. En frunto Cartagena, Queseda, Coca kaj pastro, kiu — kiel
oni konstatis dum demandesplorado — sisteme instigis la ŝipanaron
al la ribelo.

Ceteraj maristoj estis vicigitaj tiamaniere, ke ĉiu bone vidu la liberan

lokon, kie oni verdiktojn tralegos kaj plenumos.

Queseda estis kondamnita al puno de la morto kaj tuj ekzekutita.

Kadavro de Mendoza estis kvarontranĉita.

Cartagena kaj la ribelinta pastro estis punitaj plej kruele. Ĝis finiĝos
la dumvintra restado kaj ekspedicio estas preparita por forveturi, ili
estos transportitaj sur la bordon kaj lasitaj en la dezerta regiono por
malrapide morti.
Maristoj estis punitaj malpli severe. Admiralo rigardis ilin kiel
delogitajn viktimojn. Dum tiu tempo, kiam la ekspedicio restos en la
haveno, ili laboros en la ĉenoj. La katenoj estos al ili demetitaj nur
tiam, kiam la ekspedicio daŭrigos pluan veturon.
 XIII.
Trapasejo

Kiam la ribelo estis subpremita, ĉiuj ŝipanaroj eklaboris. Estis multe

da laboro. Ŝipoj estis post longdaŭra veturo tiom difektitaj, ke estis
necese tiri ilin sur la bordon kaj tie fari la riparojn. La putriĝintaj
lignotabuloj estis anstataŭigataj per novaj. Truoj, tra kiuj penetris
internen akvo, estis ŝtopataj per stupo. Malfirmigitaj hokoj estis
firmigataj. Tra la tuta golfo aŭdiĝis batoj de marteloj, grincado de
segiloj, frapoj de hakiloj.

Tiaspeca ĝenerala ŝipriparo estas peniga laboro, ankaŭ se oni faras

ĝin en normalaj ŝipkonstruejoj, kiuj estas ekipitaj per ĉiu necesa
ilaro.

Des pli peniga ĝi estis por ekspedicio de Magalhaes, kiu faris ĝin en
libera naturo, sen ŝipkonstruejoj, nur per la plej necesa ilaro. Kaj ĝi
estis des pli peniga pro la kruelaj frostoj kaj sovaĝaj neĝblovadoj. Al
viroj frostis la manoj dum la laboro. Akraj glacipingloj pikis ilin en
vizaĝon. Grandaj neĝflokoj blindigis iliajn okulojn.

Magalhaes kontrolis la riparojn. Li denove aplikis siajn riĉajn

spertojn, kiujn li akiris sur la maro en pasintaj jaroj. Nenio restis
kaŝita al lia akra vidpovo. Al li sufiĉis ununura esplorema rigardo kaj
li tuj malkovris mankon, kiun ne rimarkis oficiroj nek kapitanoj.

Ĉ
Ĉi tie, en sudamerika golfo de San Julian, la ŝipanaro vidis bone, ke
en frunto de ekspedicio staras viro, kiu estas eminenta spertulo sur
la maro kaj pri ĉio, kio koncernas la vivon sur ĝi. Homoj sur
Trinidado sciis tion jam longe. Sed ceteraj maristoj komencis valorigi
liajn kapablecojn nur nun, kiam ili havis eblon vidi lin ĉiutage
laboranta. Neniu ordono de admiralo devis esti pli poste ŝanĝata aŭ
revokata. Ĉiu estis klara, fiksa kaj preciza, kvazaŭ li pripensus ĝin
duontagon, kaj tamen li donadis ilin tuj sur la loko, laŭ la bezono.

Tiel la ŝipanaro malrapide konvinkiĝis, ke admiralo estas la

komandanto de la ekspedicio meritite. Ne nur pro tio, ke lin dekretis
la reĝo, sed ankaŭ pro liaj fakaj konoj, scioj kaj kapabloj. Kaj de ĉi
tiu ekkono estis jam nur malgranda paŝeto al aŭtoritato kaj estimo.

Kaj ankoraŭ alia afero vekis ilian admiron: la justeco de la admiralo.

Ili bone memoris tiun malhelan tagon, kiam ili staris sur la bordo de
golfo kaj timegante atendis juĝon de Magalhaes. Ĝi estis malmilda
kaj severa — sed ĉiuj sentis, ke ĝi estas justa. Sur la maro ili ne estis
novuloj. Ĉiuj kvindek ribelintoj, kiuj estis indikitaj kiel ĉefaj partianoj
de hispanaj hidalgoj, atendis morton. Anstataŭ ekzekuto ili ricevis
pardonon — escepte inspirantoj de la ribelo. Ke ili devas nun labori
en katenoj? Estas vero, la ĉenoj tintas kaj bruegas ĉe ĉiu movo,
katenoj pezigas kaj tiras al la tero, malhelpas dum iro. Malfacila vivo.
Sed tamen — vivo! Vi povas spiri, moviĝi de loko al loko, manĝi kaj
trinki, vi povas esperi kaj kredi, ke iam ĉi tiu mizero finiĝos, ke oni
fartos denove pli bone, vi povas en fantazio pentri bildojn de la feliĉa
reveno el ĉi tiu senfina kaj danĝera navigado.

Kaj la mizero de nunaj momentoj estas des pli tolerebla, ke admiralo

jam je neniu nubmienas. La ribelintojn li rigardas per la samaj okuloj
kiel la fidelajn. Ĉu ili ribelis? Ili estis punitaj kaj al ili certe jam ne
venos ideo je similaj aventuroj. Ĝis ili forpentos la punon, ĉio estos
forgesita. Ili ja ricevadas eĉ egalajn porciojn da nutraĵoj!

Jes, la admiralo estas justa. Ĉu tio gravas, ke li estas neparolema?

Cetere, se estas necese, li scipovas paroli. Li diras nur kelkajn
vortojn, sed ĉiu penetros en vian cerbon kiel ardigita pinglo.

De tago al tago plifrostiĝis. Maristoj bruligis sur la bordo fajrojn, ke

ili povu labori. Magalhaes iradis inter ili, konsilis, edifis, kaj li pensis
pri trapasejo.

Se nur jam finiĝus la vintra restado! Ĝi estas deteniĝo, kiun li ne

enkalkulis en sian veturplanon. Kie ili povis jam intertempe esti!
Kiom da aliaj golfoj ili povis jam esplori! La tagoj forflugas, jam ses
semajnojn ili estas en la golfo...

Subita decido maturiĝis en Fernao. Ĉu estas necese, ke la tuta

ekspedicio restu en kaptiteco? Ĉu almenaŭ unu ŝipo ne povus veturi
plue? Dume la ceteraj atendos en San Julian venon de printempo, tiu
ŝipo esploros ĉiujn golfojn kuŝantajn en suda direkto de ĉi tie — kaj
kiam veturos la tuta eskadro, ĝi ne estos devigata deteniĝi per
trarigardo de lokoj, kiuj estas sensignifaj.

Por ĉi tiu veturo estis destinita Serrao kun sia ŝipo Santiago.
Magalhaes konfidis lin plej multe el ĉiuj kapitanoj.

“Vi veturos ĉiam suden, Juano,” li donis al li lastajn instrukciojn. “Se

vi dum dek kvar tagoj malkovros nenion, vi revenos. Komence de
junio mi atendas vin.”

“Laŭ ordono, sinjoro admiralo!”

Al Fernao kvazaŭ falus ŝtono de sur la koro. Finiĝu la ekspedicio de

Serrao kiel ajn, ĝi estas tamen paŝo antaŭen.

Baldaŭ post forveturo de Serrao neatendita okazintaĵo vekis grandan

intereson en la vintra tendaro.

La ĉirkaŭaĵo de golfo estis dezerta, negastema. Tie ne estis arboj

nek bestaro nek homoj. Nur malaltaj embuskoj tiriĝis en senfinan
malproksimon. Maristoj kelkfoje provis penetri en tiun dezerton. Eble
ili malkovros tie iajn bestojn aŭ indiĝenojn. Sed ili ĉiam revenis ne
sukcesinte. Fine ili komencis kredi, ke ĉi tiuj regionoj estas ne
loĝeblaj.

Iun tagon alvenis Pigafetta al admiralo tute emociita.

“Sinjoro admiralo, okazis io... io... nu, mallonge dirite io grandioza!”

“Kio do?” ridetis Magalhaes.

“Maristoj malkovris postsignojn!”

“Kie?”

“Proksime ĉe la haveno!”

“Ĉu homajn postsignojn?”

“Jes!”

“Tio estas stranga,” skuis per kapo admiralo. “Kiomfoje ni jam serĉis
indiĝenojn, sed ĉiun fojon sen sukceso. Ĉu la maristoj ne eraris? Ĉu
ĝi ne estas postsigno de iu el niaj homoj, kiu tien erariris?”

“Nepenseble, sinjoro admiralo!”

“Laŭ kio vi opinias tiel?”

“Ĝi propre ne estas postsigno de iu normala homo, li devas esti ia

giganto.”

“Sinjoro Pigafetta!” bridis lian fantazion admiralo. “Eble vi fine diros,

ke ĉi tie vivas supernaturaj estaĵoj?”

“Mi preskaŭ kredus tion. La postsigno estas nome minimume dufoje

pli granda ol postsignoj de aliaj homoj. Cetere, venu rigardi! Ni ĉiuj
estas kiel en ekstazo.”
“Mi estas vere scivola,” diris Magalhaes kaj iris kun Pigafetta rigardi
la interesan postsignon. Li ne dubis, ke entuziasmema Italo ĉion
pligrandigis.

Sed kiam li venis al la loko, li ĉesis ridi. La postsigno estis vere tiom
granda, ke similan li ankoraŭ neniam vidis.

“Kion vi diras, sinjoro admiralo?” kun ĝuo observis lian miregon

Pigafetta.

“Estas vere nenormala longeco de piedo,” diris medite admiralo. “Mi

ŝatus vidi tiun viregon. Kaj pli da postsignoj vi ne trovis?”

“Ne,” respondis ĥore maristoj, kiuj intertempe ĉi tie ariĝis. Sed jam la
sekvantan tagon ili malkovris pluajn postsignojn. Kaj ĉiuj estis tiel
nenormalaj, grandegaj.

“Ili estas iuj patagonianoj[4],” baptis ilin memvole admiralo.

“Versimile ili timas nin, pro tio ili kaŝas sin.”

Baldaŭ poste la tuta tendaro estis sur la piedoj. Maristoj, oficistoj,

kapitanoj, admiralo — ĉiuj rigardis miregante strangan estaĵon, kiu
saltetis sur malproksima loko.

Patagoniano!

Li dancis sur la loko kaj samtempe li superŝutis siajn harojn per la

sablo. Magalhaes ekkomprenis, ke la indiĝeno montras tiamaniere
sian deziron interkonatiĝi kun maristoj.

“Garcia, iru al li kaj faru la samajn movojn kiel li,” li diris. “Tiel li
scios, ke vi venas kiel amiko.”

Garcia ne lasis sin dufoje instigi. Li malgracie saltetis kaj per fortega
baritono li kantis ian kanteton. La maristoj ridis pri liaj groteskaj
movoj ĝis ili larmis.
Patagoniano komprenis. Kaj Garcia ne bezonis tro peni por alkonduki
lin en la havenon.

Tie ariĝis ĉirkaŭ la timema sovaĝulo preskaŭ ĉiuj maristoj. Ili

observrigardis lin de ĉiuj flankoj. Li estis vere grandegulo, li superigis
ilin pli ol je la kapo — sed Pigafetta tamen skuis la kapon.

“Mi imagis lin al mi multe pli grandan,” li grumblis trompite. “Se mi

konkludas laŭ la postsignoj, li devus esti almenaŭ dufoje pli granda
ol ni!”

Li alproksimiĝis al la Patagoniano kaj rigardis liajn piedojn. Kaj

momente eksonis lia gaja rido.

“Sinjoro admiralo, rigardu!” li vokis. “Ja tiu homo havas sur la piedoj
tutajn boatojn! Nun mi jam komprenas!”

Patagoniano havis piedojn en dikaj feloj, kiuj postlasis la enigmajn

grandegajn postsignojn...

“Do ni nomiĝis lin Patagoniano maljuste,” diris Magalhaes. “Sed

povas esti, ke la nomo estas tute bela kaj al ni restos almenaŭ la
rememoro je ĉi tieaj homoj kaj regiono.”

“Jes, la rememoro je — Patagonio!” vokis vigle Pigafetta. “Mi tuj

notos tion!”

La alveno de la Patagoniano estis por monotona vivo en la tendaro

multsignifa okazintaĵo. Maristoj miregante rigardobservis lian
grandegan staturon. Ili montris al 1i diversajn ludilojn kaj ĝojis pro
liaj entuziasmaj ekkrioj.

Kiam Spinoza metis antaŭ liajn okulojn speguleton. Patagoniano

rigardante sian vizaĝon terurege ektimis. Li saltis malantaŭen tiom
fortege, ke li faligis teren kvar maristojn starantajn en lia proksimo.
Kaj la ridantaj marnavigantoj devis multe penegi, ol ili sukcesis
konvinki sian gaston, ke la speguleto estas nepre sendanĝera, ja
male tre utila objekto.

Ilia mirego pligrandiĝis, kiam Patagoniano komencis manĝi kaj trinki.

Per unu trinko — kiel rimarkas Pigafetta — li trinkis duonsitelon da
akvo kaj dum unu manĝo en li malaperis duonkorbo da biskvitoj.

Sed la plej granda surprizo nur atendis ilin. Manĝinte la indiĝeno

sidiĝis sur benketon antaŭ la magazeno kaj li kontente ĉirkaŭrigardis.
Subite li ekvidis raton, kiu flugaperis inter la pordo. Li rapidege
elsaltis kaj en momento li tenis ĝin en sia granda manplato. Li
ekpremis ĝian kapon, kaj malgraŭ tio, ke ĝi ankoraŭ moviĝis, li
formanĝis ĝin en natura stato — kun haŭto kaj hararo. Poste duan,
trian kaj kvaran...

Kiam ili adiaŭis lin, admiralo donis al li kelkajn sonoriletojn kaj

montrosciigis lin, ke li alkonduku ankaŭ niajn kunulojn.

La sekvantan tagon ili alvenis kaj kondutis tute amike. Sed

interŝanĝo da varoj estis preskaŭ senvalora, ĉar krom hejmaj bestoj,
kiujn ili nomis guanakoj, ili havis por vendo preskaŭ nenion.

Poste venadis indiĝenoj ĉiutage en la tendaron kaj rigardis laborojn

de maristoj. Ili alkondukis guanakojn kaj forportis diversajn ludilojn.

Ĉi tiu bona humoro estis subite interrompita per sciigo, kiu efikis kiel
batego de la tondro.

La ŝipo de Serrao forveturis antaŭ tri semajnoj. Fernao komencis

pensi pri ĝi ĉiam pli ofte. Ĉu ili malkovros ion? Aŭ ĉu ili revenos
denove malsukcesinte? Li staris ĉiutage sur Trinidado kaj iomete
maltrankviligita li rigardis al la sudo. Li sciis, ke li ne bezonas
maltrankviliĝi. Li ja diris al Serrao malimplicitite, ke li veturu suden
dek kvar tagojn. Dek kvar tagojn tien, dek kvar tagojn reen — do
ankoraŭ restas unu semajno. Kaj tamen io faris lin maltrankvila.

Sed la informo pri Santiago ne venis de sur la maro.

Iun tagon rimarkis patrolo du staturojn, kiuj treniĝis sur la bordo. Ili
paŝis malrapide, malrapidege al la golfo. Ĉiumomente ili haltis.

Kiuj povas ili esti? Patagonianoj tio ne estas — kaj de kie venus en ĉi
tiun forgesitan landon aliaj homoj?

Gvardio vokis admiralon. Kun li venis kelkaj maristoj.

Magalhaes rigardis la proksimiĝantajn homojn. Lia vizaĝo subite

plilongiĝis de mirego.

“Estas ja la niaj el Santiago!” li vokis per duonsufokita voĉo. “Iru

renkonten al ili!”

Sed li mem tuj rapidis al la venantaj maristoj. Kaj jam ili estis tiom
proksime, ke li distingis ilin: la dua ŝipoficiro Lopez kaj ŝipgvidisto
Barnolas.

Magalhaes kaj grupo da maristoj svingis manojn por saluti ilin. La

viroj volis respondi, sed ili estis tiom elĉerpitaj, ke ili nur suprenlevis
la manojn kaj lasis ilin senpove sinki. Poste Lopez ruinigis en
neĝamason kaj restis kuŝi senmova. Barnolas volis levi lin, sed liaj
fortoj jam ne sufiĉis por tio.

Kaj jam alrapidegis Magalhaes.

“Barnolas, kio okazis? Kaj kie estas la ceteraj?”

“Nia ŝipo averiis, sinjoro admiralo,” diris per malforta voĉo Barnolas.

“Kaj maristoj?”

“Savitaj.”

“Ĉu ĉiuj?”

“Jes.”
“Dank’ al dio!” respiris admiralo, kiu jam komencis timi la plej
malbonon.

Du maristoj prenis Lopezon kaj portis lin en la tendaron. Lia kunulo

marŝis ankoraŭ mem.

Nur kiam ili plifortiĝis, Barnolas daŭrigis siajn informojn.

“Ni veturis laŭlonge de la bordo kaj trarigardis golfojn,” li diris. “Post

kelktaga veturo atakis nin tempesto. Ĝi deŝiregis al ni direktilon kaj
ni estis ĵetitaj kontraŭ la roko. La fundo estis feliĉe malprofunda. Alie
ni estus mortintaj. Kiam la tempesto ĉesis, ni eltiris la ŝipruinojn sur
la bordon. Ni savis preskaŭ ĉiujn provizojn. La kapitano ordonis al ni
iri al vi.”

“Kiel longe vi iris?”

“Dek unu tagojn.”

Dek unu tagojn! Dek unu tagojn tra la dezerta kaj nepriloĝata
regiono! Dek unu senfinajn noktojn en frostaj neĝamasoj!

Magalhaes leviĝis kaj senvorte premis manojn de ambaŭ viroj. Ĉiuj

sciis, ke ĉi tiu rekono signifas pli multe ol la plej entuziasmaj dank-
vortoj.

“Kaj golfoj?” demandis post momento admiralo.

“Ni esploris multajn,” respondis Barnolas hezite.

Kaj —?”

“Ĉiuj estis fermitaj.”

Nek muskoleto moviĝis en la vizaĝo de Fernao. Cetere, kial li

demandis? Se ili estus ion trovintaj, ili certe dirus tion al li kiel unuan
informon!
Welcome to our website – the perfect destination for book lovers and
knowledge seekers. We believe that every book holds a new world,
offering opportunities for learning, discovery, and personal growth.
That’s why we are dedicated to bringing you a diverse collection of
books, ranging from classic literature and specialized publications to
self-development guides and children's books.

More than just a book-buying platform, we strive to be a bridge

connecting you with timeless cultural and intellectual values. With an
elegant, user-friendly interface and a smart search system, you can
quickly find the books that best suit your interests. Additionally,
our special promotions and home delivery services help you save time
and fully enjoy the joy of reading.

Join us on a journey of knowledge exploration, passion nurturing, and

personal growth every day!

ebookbell.com