_Your main.js file should be below all other scripts_. It is very important to remember this.
_Votre fichier main.js doit être placé en dessous de tous les autres fichiers scripts_. Il est très important de s'en souvenir.
## Introduction to Data types
## Introduction aux types de données
In JavaScript and also other programming languages, there are different types of data types. The following are JavaScript primitive data types: _String, Number, Boolean, undefined, Null_, and_Symbol_.
En JavaScript et dans d'autres langages de programmation, il existe différents types de données. Voici les types de données primitives en JavaScript: _Chaine de caractère, Nombre, Booleen, undefined, Null_, et_Symbol_.
### Numbers
### Les nombres
- Integers: Integer (negative, zero and positive) numbers
- Nombres entiers : Nombres entiers (négatifs, nuls et positifs)
Example:
Exemple
... -3, -2, -1, 0, 1, 2, 3 ...
... -3, -2, -1, 0, 1, 2, 3 ...
- Float-point numbers: Decimal number
- Nombres à virgule flottante : Nombre décimal
Example
Exemple
... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ...
... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ...
### Strings
### Les chaîne de caractère
A collection of one or more characters between two single quotes, double quotes, or backticks.
Ensemble d'un ou plusieurs caractères compris entre deux guillemets simples, deux guillemets doubles ou deux barres obliques.
**Example:**
**Exemple:**
```js
```js
'a'
'a'
'Asabeneh'
'Asabeneh'
"Asabeneh"
"Asabeneh"
'Finland'
'Finland'
'JavaScript is a beautiful programming language'
'JavaScript est un beau langage de programmation'
'I love teaching'
'J\'aime enseigner'
'I hope you are enjoying the first day'
'J\'espère que vous appréciez ce premier jour'
`We can also create a string using a backtick`
`Nous pouvons également créer une chaîne de caractères à l'aide d'un backtick`
'A string could be just as small as one character or as big as many pages'
'Une chaîne de caractères peut être aussi petite qu\'un seul caractère ou aussi grande que plusieurs pages.'
'Any data type under a single quote, double quote or backtick is a string'
'Tout type de données placé sous un guillemet simple, un guillemet double ou une coche est une chaîne de caractères.'
```
```
### Booleans
### Booléens
A boolean value is either True or False. Any comparisons returns a boolean value, which is either true or false.
A boolean data type is either a true or false value.
Une valeur booléenne est soit vraie, soit fausse. Toute comparaison renvoie une valeur booléenne, qui est soit vraie, soit fausse.
Un type de données booléen est soit une valeur vraie, soit une valeur fausse.
**Example:**
**Exemple:**
```js
```js
true // if the light is on, the value is true
true // si la lumière est allumée, la valeur est vraie
false // if the light is off, the value is false
false // si la lumière est éteinte, la valeur est fausse
```
```
### Undefined
### Indéfini(Undefined)
In JavaScript, if we don't assign a value to a variable, the value is undefined. In addition to that, if a function is not returning anything, it returns undefined.
En JavaScript, si nous n'attribuons pas de valeur à une variable, cette valeur est indéfinie. En outre, si une fonction ne renvoie rien, elle renvoie une valeur indéfinie.
```js
```js
let firstName
let firstName
console.log(firstName) // undefined, because it is not assigned to a value yet
console.log(firstName) // indéfini, car il n'est pas encore affecté à une valeur
```
```
### Null
### Null
Null in JavaScript means an empty value.
Null en JavaScript signifie une valeur vide.
```js
```js
let emptyValue = null
let emptyValue = null
```
```
## Checking Data Types
## Vérification des types de données
To check the data type of a certain variable, we use the **typeof** operator. See the following example.
Pour vérifier le type de données d'une certaine variable, nous utilisons la fonction **typeof** de l'opérateur. Voir l'exemple suivant.
```js
```js
console.log(typeof 'Asabeneh') // string
console.log(typeof 'Asabeneh') // chaîne de caractère
console.log(typeof 5) // number
console.log(typeof 5) // nombre
console.log(typeof true) // boolean
console.log(typeof true) // booléen
console.log(typeof null) // object type
console.log(typeof null) // type object
console.log(typeof undefined) // undefined
console.log(typeof undefined) // undefini
```
```
## Comments Again
## Encore des commentaires
Remember that commenting in JavaScript is similar to other programming languages. Comments are important in making your code more readable.
Rappelez-vous que les commentaires en JavaScript sont similaires à ceux des autres langages de programmation. Les commentaires sont importants pour rendre votre code plus lisible.
There are two ways of commenting:
Il existe deux façons de commenter :
- _Single line commenting_
- _Commentaire sur une seule ligne_
- _Multiline commenting_
- _Commentaires multilignes_
```js
```js
// commenting the code itself with a single comment
// commenter le code lui-même avec un seul commentaire
// let firstName = 'Asabeneh'; single line comment
// let firstName = 'Asabeneh'; commentaire sur une seule ligne
// let lastName = 'Yetayeh'; single line comment
// let lastName = 'Yetayeh'; commentaire sur une seule ligne
```
```
Multiline commenting:
Commentaires en plusieurs lignes :
```js
```js
/*
/*
let location = 'Helsinki';
let location = 'Helsinki';
let age = 100;
let age = 100;
let isMarried = true;
let isMarried = true;
This is a Multiple line comment
Il s'agit d'un commentaire de plusieurs lignes
*/
*/
```
```
## Variables
## Variables
Variables are _containers_ of data. Variables are used to _store_ data in a memory location. When a variable is declared, a memory location is reserved. When a variable is assigned to a value (data), the memory space will be filled with that data. To declare a variable, we use _var_, _let_, or _const_ keywords.
Les variables sont des _conteneurs_ of data. Les variables sont utilisées pour _stocker_ des données dans un emplacement de mémoire. Lorsqu'une variable est déclarée, un emplacement mémoire est réservé. Lorsqu'une variable est affectée à une valeur (données), l'espace mémoire sera rempli avec ces données. Pour déclarer une variable, on utilise_var_, _let_, or _const_ keywords.
Pour une variable qui change à un autre moment, nous utilisons_let_. _const_. Si les données ne changent pas du tout, nous utilisons l'exemple suivant, PI, nom de pays, ne changent pas, et nous pouvons utiliser _const_.
For a variable that changes at a different time, we use _let_. If the data does not change at all, we use _const_. For example, PI, country name, gravity do not change, and we can use _const_. We will not use var in this challenge and I don't recommend you to use it. It is error prone way of declaring variable it has lots of leak. We will talk more about var, let, and const in detail in other sections (scope). For now, the above explanation is enough.
Nous n'utiliserons pas _var_ dans ce défi et je ne vous recommande pas de l'utiliser. C'est une façon de déclarer une variable qui peut être source d'erreurs et qui comporte de nombreuses fuites. Nous parlerons plus en détail de var, let et const dans d'autres sections (scope). Pour l'instant, l'explication ci-dessus est suffisante.
A valid JavaScript variable name must follow the following rules:
Un nom de variable JavaScript valide doit respecter les règles suivantes :
- A JavaScript variable name should not begin with a number.
- Le nom d'une variable JavaScript ne doit pas commencer par un chiffre.
- A JavaScript variable name does not allow special characters except dollar sign and underscore.
- Le nom d'une variable JavaScript n'autorise pas les caractères spéciaux, à l'exception du signe du dollar et du trait de soulignement.
- A JavaScript variable name follows a camelCase convention.
- Le nom d'une variable JavaScript suit la convention camelCase.
- A JavaScript variable name should not have space between words.
- Le nom d'une variable JavaScript ne doit pas comporter d'espace entre les mots.
The following are examples of valid JavaScript variables.
Voici des exemples de variables JavaScript valides.
```js
```js
firstName
firstName
@ -592,9 +592,9 @@ year2020
year_2020
year_2020
```
```
The first and second variables on the list follows the camelCase convention of declaring in JavaScript. In this material, we will use camelCase variables(camelWithOneHump). We use CamelCase(CamelWithTwoHump) to declare classes, we will discuss about classes and objects in other section.
La première et la deuxième variables de la liste suivent la convention camelCase de déclaration en JavaScript. Dans ce document, nous utiliserons des variables en camelCase (camelWithOneHump). Nous utilisons la camelCase (camelWithTwoHump) pour déclarer les classes, nous discuterons des classes et des objets dans d'autres sections.
Example of invalid variables:
Exemple de variables non valides :
```js
```js
first-name
first-name
@ -602,24 +602,24 @@ Example of invalid variables:
num_#_1
num_#_1
```
```
Let us declare variables with different data types. To declare a variable, we need to use _let_ or _const_ keyword before the variable name. Following the variable name, we write an equal sign (assignment operator), and a value(assigned data).
Déclarons des variables avec différents types de données. Pour déclarer une variable, nous devons utiliser _let_ or _const_ avant le nom de la variable. Après le nom de la variable, on écrit un signe égal (opérateur d'affectation), et une valeur (donnée affectée).
```js
```js
// Syntax
// Syntax
let nameOfVariable = value
let nameOfVariable = value
```
```
The nameOfVriable is the name that stores different data of value. See below for detail examples.
Le nom de l'objet est le nom qui stocke les différentes données de la valeur. Voir ci-dessous pour des exemples détaillés.
**Examples of declared variables**
**Exemples de variables déclarées**
```js
```js
// Declaring different variables of different data types
// Déclarer différentes variables de différents types de données
let firstName = 'Asabeneh' // first name of a person
let firstName = 'Asabeneh' // prénom d'une personne
let lastName = 'Yetayeh' // last name of a person
let lastName = 'Yetayeh' // nom de famille d'une personne
let country = 'Finland' // country
let country = 'Finland' // pays
let city = 'Helsinki' // capital city
let city = 'Helsinki' // capitale
let age = 100 // age in years
let age = 100 // age
let isMarried = true
let isMarried = true
console.log(firstName, lastName, country, city, age, isMarried)
console.log(firstName, lastName, country, city, age, isMarried)
// Variables can also be declaring in one line separated by comma, however I recommend to use a seperate line to make code more readble
// Les variables peuvent également être déclarées sur une seule ligne séparée par une virgule, mais je recommande d'utiliser une ligne séparée pour rendre le code plus lisible.
let name = 'Asabeneh', job = 'teacher', live = 'Finland'
let name = 'Asabeneh', job = 'teacher', live = 'Finland'
console.log(name, job, live)
console.log(name, job, live)
```
```
@ -652,32 +652,32 @@ console.log(name, job, live)
Asabeneh teacher Finland
Asabeneh teacher Finland
```
```
When you run _index.html_ file in the 01-Day folder you should get this:
Lorsque vous exécutez _index.html_ dans le fichier 01-Jour vous devriez obtenir ceci:
🌕 You are amazing! You have just completed day 1 challenge and you are on your way to greatness. Now do some exercises for your brain and muscle.
🌕 Vous êtes extraordinaire ! Vous venez de relever le défi du premier jour et vous êtes sur la voie de la grandeur. Maintenant, fais quelques exercices pour ton cerveau et tes muscles.
# 💻 Day 1: Exercises
# 💻 Day 1: Exercises
1. Write a single line comment which says, _comments can make code readable_
1. Rédigez un commentaire d'une seule ligne qui dit, _les commentaires rendent le code plus lisible_
2. Write another single comment which says, _Welcome to 30DaysOfJavaScript_
2. Rédigez un autre commentaire unique qui dit, _Bienvenue dans 30 jours de JavaScript_
3. Write a multiline comment which says, _comments can make code readable, easy to reuse_
3. Rédigez un commentaire de plusieurs lignes qui dit, _les commentaires peuvent rendre le code lisible et facile à réutiliser_
_and informative_
_et informatif_
4. Create a variable.js file and declare variables and assign string, boolean, undefined and null data types
4. Créez un fichier variable.js, déclarez des variables et attribuez des types de données string, boolean, undefined et null.
5. Create datatypes.js file and use the JavaScript **_typeof_** operator to check different data types. Check the data type of each variable
5.Créer le fichier datatypes.js et utiliser le JavaScript **_typeof_** pour vérifier les différents types de données. Vérifier le type de données de chaque variable
6. Declare four variables without assigning values
6. Déclarer quatre variables sans leur attribuer de valeur
7. Declare four variables with assigned values
7. Déclarer quatre variables avec des valeurs assignées
8. Declare variables to store your first name, last name, marital status, country and age in multiple lines
8. Déclarez des variables pour stocker votre prénom, votre nom de famille, votre état civil, votre pays et votre âge sur plusieurs lignes.
9. Declare variables to store your first name, last name, marital status, country and age in a single line
9. Déclarez des variables pour stocker votre prénom, votre nom, votre état civil, votre pays et votre âge sur une seule ligne.
10. Declare two variables _myAge_ and _yourAge_ and assign them initial values and log to the browser console.
10. Déclarer deux variables _myAge_ and _yourAge_ et leur assigner des valeurs initiales et se connecter à la console du navigateur.
Os-humble-man
2 years ago