In this first chapter, we'll learn the basics of programming and the Javascript language.

Programming means writing code. A book is made up of chapters, paragraphs, sentences, phrases, words and finally punctuation and letters, likewise a program can be broken down into smaller and smaller components. For now, the most important is a statement. A statement is analogous to a sentence in a book. On its own, it has structure and purpose, but without the context of the other statements around it, it isn't that meaningful.

A statement is more casually (and commonly) known as a line of code. That's because statements tend to be written on individual lines. As such, programs are read from top to bottom, left to right. You might be wondering what code (also called source code) is. That happens to be a broad term which can refer to the whole of the program or the smallest part. Therefore, a line of code is simply a line of your program.

Here is a simple example:

var hello = "Hello";
var world = "World";

// Message equals "Hello World"
var message = hello + " " + world;

This code can be executed by another program called an interpreter that will read the code, and execute all the statements in the right order.

While Loops repetitively execute a block of code as long as a specified condition is true.

For example, the loop in this example will repetitively execute its block of code as long as the variable i is less than 5:

The Do/While Loop is a variant of the while loop. This loop will execute the code block once before checking if the condition is true. It then repeats the loop as long as the condition is true:

Note: Be careful to avoid infinite looping if the condition is always true!

Some advanced operators can be used, such as:

• Modulus (division remainder): x = y % 2

• Increment: Given a = 5

  • c = a++, Results: c = 5 and a = 6

  • c = ++a, Results: c = 6 and a = 6

• Decrement: Given a = 5

  • c = a--, Results: c = 5 and a = 4

  • c = --a, Results: c = 4 and a = 4

A condition is a test for something. Conditions are very important for programming, in several ways:

First of all conditions can be used to ensure that your program works, regardless of what data you throw at it for processing. If you blindly trust data, you’ll get into trouble and your programs will fail. If you test that the thing you want to do is possible and has all the required information in the right format, that won’t happen, and your program will be a lot more stable. Taking such precautions is also known as programming defensively.

The other thing conditions can do for you is allow for branching. You might have encountered branching diagrams before, for example when filling out a form. Basically, this refers to executing different “branches” (parts) of code, depending on if the condition is met or not.

In this chapter, we'll learn the base of conditional logic in Javascript.

You can define strings in JavaScript by enclosing the text in single quotes or double quotes:

// Single quotes can be used
var str = 'Our lovely string';

// Double quotes as well
var otherStr = "Another nice string";

In Javascript, Strings can contain UTF-8 characters:

"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어";

Note: Strings can not be subtracted, multiplied or divided.

It's easy in Javascript to know how many characters are in string using the property .length.

// Just use the property .length
var size = 'Our lovely string'.length;

Note: Strings can not be substracted, multiplied or divided.

You can apply mathematic operations to numbers using some basic operators like:

• Addition: c = a + b

• Subtraction: c = a - b

So you have your array of data elements, but what if you want to access a specific element? That is where indices come in. An index refers to a spot in the array. indices logically progress one by one, but it should be noted that the first index in an array is 0, as it is in most languages. Brackets [] are used to signify you are referring to an index of an array.

The difference between objects and primitive values is that we can change objects, whereas primitive values are immutable.

Arrays have a property called length, and it's pretty much exactly as it sounds, it's the length of the array.

JavaScript strings share many similarities with string implementations from other high-level languages. They represent text based messages and data.

In this course we will cover the basics. How to create new strings and perform common operations on them.

Here is an example of a string:

Functions, are one of the most powerful and essential notions in programming.

Functions like mathematical functions perform transformations, they take input values called arguments and return an output value.

Creating a number is easy, it can be done just like for any other variable type using the var keyword.

Numbers can be created from a constant value:

// This is a float:
var a = 1.2;

// This is an integer:
var b = 10;

Or from the value of another variable:

var a = 2;
var b = a;

The easiest condition is an if statement and its syntax is if(condition){ do this … }. The condition has to be true for the code inside the curly braces to be executed. You can for example test a string and set the value of another string dependent on its value:

Note: Conditions can also be nested.

Lets now focus on the conditional part:

The conditional part is the variable country followed by the three equal signs (===). Three equal signs tests if the variable country has both the correct value (France) and also the correct type (String). You can test conditions with double equal signs, too, however a conditional such as if (x == 5) would then return true for both var x = 5; and var x = "5";

Object's property is a propertyName: propertyValue pair, where property name can be only a string. If it's not a string, it gets casted into a string. You can specify properties when creating an object or later. There may be zero or more properties separated by commas.

The following code demonstates how to get a property's value.

The following example shows how to add a new property or change an existing one.

There are two ways to create an object in JavaScript:

1. literal

   Copy

    var object = {};
     // Yes, simply a pair of curly braces!

   Note: this is the recomended way.

2. and object-oriented

   Note: it's almost like Java.

The easiest form of a loop is the for statement. This one has a syntax that is similar to an if statement, but with more options:

Lets for example see how to execute the same code ten-times using a for loop:

Note: i = i + 1 can be written i++.

Furthermore you can concatenate different conditions with "or” or “and” statements, to test whether either statement is true, or both are true, respectively.

In JavaScript “or” is written as || and “and” is written as &&.

Say you want to test if the value of x is between 10 and 20—you could do that with a condition stating:

if(x > 10 && x < 20) {
    ...
}

If you want to make sure that country is either “England” or “Germany” you use:

if(country === 'England' || country === 'Germany') {
    ...
}

Note: Just like operations on numbers, Condtions can be grouped using parenthesis, ex: if ( (name === "John" || name === "Jennifer") && country === "France").

Every object is linked to a prototype object from which it inherits properties.

All objects created from object literals ({}) are automatically linked to Object.prototype, which is an object that comes standard with JavaScript.

When a JavaScript interpreter (a module in your browser) tries to find a property, which You want to retrieve, like in the following code:

First, the interpreter looks through every property the object itself has. For example, adult has only one own property — age. But besides that one it actually has a few more properties, which were inherited from Object.prototype.

This book is no longer maintained, and will be deleted at some point!

Amazing work

 -1,7 +1,18 @@
 describe('Feature: Adding a book', () => {
   test('Example: User can add a book', async () => {
     // Pour l'instant je me contente d'écrire le code le plus simple possible
+    class BookRepository {
+      lastSavedBook: { title: string } | undefined;
+    }
+
     const bookRepository = new BookRepository();
-    const addBook = new AddBookUseCase(bookRepository);
+
+    class AddBookUseCase {
+      async execute(book: { title: string }) {
+        bookRepository.lastSavedBook = book;
+      }
+    }
+
+    const addBook = new AddBookUseCase();

     await addBook.execute({ title: 'Clean Code' });

Published on GitHub

This book will teach you the basics of programming and Javascript. Whether you are an experienced programmer or not, this book is intended for everyone who wishes to learn the JavaScript programming language.

JavaScript (JS for short) is the programming language that enables web pages to respond to user interaction beyond the basic level. It was created in 1995, and is today one of the most famous and used programming languages.

Programmers frequently need to determine the equality of variables in relation to other variables. This is done using an equality operator.

The most basic equality operator is the == operator. This operator does everything it can to determine if two variables are equal, even if they are not of the same type.

For example, assume:

var foo = 42;
var bar = 42;
var baz = "42";
var qux = "life";

foo == bar will evaluate to true and baz == qux will evaluate to false, as one would expect. However, foo == baz will also evaluate to true despite foo and baz being different types. Behind the scenes the == equality operator attempts to force its operands to the same type before determining their equality. This is in contrast to the === equality operator.

The === equality operator determines that two variables are equal if they are of the same type and have the same value. With the same assumptions as before, this means that foo === bar will still evaluate to true, but foo === baz will now evaluate to false. baz === qux will still evaluate to false.

JavaScript has only one type of numbers – 64-bit float point. It's the same as Java's double. Unlike most other programming languages, there is no separate integer type, so 1 and 1.0 are the same value.

In this chapter, we'll learn how to create numbers and perform operations on them (like additions and subtractions).

The do...while statement creates a loop that executes a specified statement until the test condition evaluates to be false. The condition is evaluated after executing the statement. Syntax for do... while is

do{
    // statement
}
while(expression) ;

Lets for example see how to print numbers less than 10 using do...while loop:

var i = 0;
do {
    document.write(i + " ");
    i++; // incrementing i by 1  
} while (i < 10);

Note: i = i + 1 can be written i++.

Concatenation involves adding two or more strings together, creating a larger string containing the combined data of those original strings. This is done in JavaScript using the + operator.

var bigStr = 'Hi ' + 'JS strings are nice ' + 'and ' + 'easy to add';

Arrays are a fundamental part of programming. An array is a list of data. We can store a lot of data in one variable, which makes our code more readable and easier to understand. It also makes it much easier to perform functions on related data.

The data in arrays are called elements.

Here is a simple array:

// 1, 1, 2, 3, 5, and 8 are the elements in this array
var numbers = [1, 1, 2, 3, 5, 8];

There is also an else clause that will be applied when the first condition isn’t true. This is very powerful if you want to react to any value, but single out one in particular for special treatment:

var umbrellaMandatory;

if(country === 'England'){
    umbrellaMandatory = true;
} else {
    umbrellaMandatory = false;
}

The else clause can be joined with another if. Lets remake the example from the previous article:

if(country === 'England') {
    ...
} else if(country === 'France') {
    ...
} else if(country === 'Germany') {
    ...
}

Functions, like variables, must be declared. Let's declare a function double that accepts an argument called x and returns the double of x :

function double(x) {
    return 2 * x;
}

Note: the function above may be referenced before it has been defined.

Functions are also values in JavaScript; they can be stored in variables (just like numbers, strings, etc ...) and given to other functions as arguments :

var double = function(x) {
    return 2 * x;
};

Note: the function above may not be referenced before it is defined, just like any other variable.

Computers are sophisticated and can make use of more complex variables than just numbers. This is where variable types come in. Variables come in several types and different languages support different types.

The most common types are:

• Numbers

  • Float: a number, like 1.21323, 4, -33.5, 100004 or 0.123

  • Integer: a number like 1, 12, -33, 140 but not 1.233

• String: a line of text like "boat", "elephant" or "damn, you are tall!"

• Boolean: either true or false, but nothing else

• Arrays: a collection of values like: 1,2,3,4,'I am bored now'

• Objects: a representation of a more complex object

• null: a variable that contains null contains no valid Number, String, Boolean, Array, or Object

• undefined: the undefined value is obtained when you use an object property that does not exist, or a variable that has been declared, but has no value assigned to it.

JavaScript is a “loosely typed” language, which means that you don't have to explicitly declare what type of data the variables are. You just need to use the var keyword to indicate that you are declaring a variable, and the interpreter will work out what data type you are using from the context, and use of quotes.

Loops are repetitive conditions where one variable in the loop changes. Loops are handy, if you want to run the same code over and over again, each time with a different value.

Instead of writing:

doThing(cars[0]);
doThing(cars[1]);
doThing(cars[2]);
doThing(cars[3]);
doThing(cars[4]);

You can write:

for (var i=0; i < cars.length; i++) { 
    doThing(cars[i]);
}

Comments are statements that will not be executed by the interpreter, comments are used to mark annotations for other programmers or small descriptions of what your code does, thus making it easier for others to understand what your code does.

In Javascript, comments can be written in 2 different ways:

• Line starting with //:

// This is a comment, it will be ignored by the interpreter
var a = "this is a variable defined in a statement";

• Section of code starting with /*and ending with */, this method is used for multi-line comments:

Mark the editor's contents as a comment

Higher order functions are functions that manipulate other functions. For example, a function can take other functions as arguments and/or produce a function as its return value. Such fancy functional techniques are powerful constructs available to you in JavaScript and other high-level languages like python, lisp, etc.

We will now create two simple functions, add_2 and double, and a higher order function called map. map will accept two arguments, func and list (its declaration will therefore begin map(func,list)), and return an array. func (the first argument) will be a function that will be applied to each of the elements in the array list (the second argument).

The functions in the above example are simple. However, when passed as arguments to other functions, they can be composed in unforeseen ways to build more complex functions.

For example, if we notice that we use the invocations map(add_2, ...) and map(double, ...) very often in our code, we could decide we want to create two special-purpose list processing functions that have the desired operation baked into them. Using function composition, we could do this as follows:

Now let's create a function called buildProcessor that takes a function func as input and returns a func-processor, that is, a function that applies func to each input in list.

Let's look at another example. We'll create a function called buildMultiplier that takes a number x as input and returns a function that multiplies its argument by x :

Objects are never copied. They are passed around by reference.

The primitive types of JavaScript are true, false, numbers, strings, null and undefined. Every other value is an object.

In JavaScript objects contain propertyName: propertyValue pairs.

The for in statement can loop over all of the property names in an object. The enumeration will include functions and prototype properties.

var fruit = {
    apple: 2,
    orange:5,
    pear:1
},
sentence = 'I have ',
quantity;
for (kind in fruit){
    quantity = fruit[kind];
    sentence += quantity+' '+kind+
                (quantity===1?'':'s')+
                ', ';
}
 // The following line removes the trailing coma.
sentence = sentence.substr(0,sentence.length-2)+'.';
 // I have 2 apples, 5 oranges, 1 pear.

If you are developing a module, which might be running on a web page, which also runs other modules, then you must beware the variable name overlapping.

Suppose we are developing a counter module:

var myCounter = {
    number : 0,
    plusPlus : function(){
        this.number : this.number + 1;
    },
    isGreaterThanTen : function(){
        return this.number > 10;
    }
}

Note: this technique is often used with closures, to make the internal state immutable from the outside.

The module now takes only one variable name — myCounter. If any other module on the page makes use of such names like number or isGreaterThanTen then it's perfectly safe, because we will not override each others values;

The first step towards really understanding programming is looking back at algebra. If you remember it from school, algebra starts with writing terms such as the following.

3 + 5 = 8

You start performing calculations when you introduce an unknown, for example x below:

3 + x = 8

Shifting those around you can determine x:

x = 8 - 3
-> x = 5

When you introduce more than one you make your terms more flexible - you are using variables:

You can change the values of x and y and the formula can still be true:

or

The same is true for programming languages. In programming, variables are containers for values that change. Variables can hold all kind of values and also the results of computations. Variables have a name and a value separated by an equals sign (=). Variable names can be any letter or word, but bear in mind that there are restrictions from language to language of what you can use, as some words are reserved for other functionality.

Let's check out how it works in Javascript, The following code defines two variables, computes the result of adding the two and defines this result as a value of a third variable.

delete can be used to remove a property from an object. It will remove a property from the object if it has one. It will not look further in the prototype chain. Removing a property from an object may allow a property from the prototype chain to shine through:

var adult = {age:26},
    child = Object.create(adult);
    child.age = 8;

delete child.age;
 /* Remove age property from child, revealing the age of the prototype, because then it is not overriden. */
var prototypeAge = child.age;
 // 26, because child does not have its own age property.