Etudes/Development-basis

Fork 0

BURST Célian 55f783a679

Corrigé du titre & update de l'ordre du chapitre 1

2021-11-19 16:11:57 +01:00

23 KiB

Raw Blame History

Cours et exercices pour les débutants en programmation

Ce cours prendra pour exemple trois langages de programmation comme support, les langages seront PHP, Javascript ainsi que le Java.

Chapitres

Types, Variables & Constantes
- Types
- Variables
- Constantes
Opérateurs logiques et de comparaisons
Conditions
Boucles
Erreurs
Exercices

Types, Variables & Types

Comme vous avez pu le lire dans le titre, nous allons voir dans ce premier chapitre des notions de base en programmation. Ces notions sont les types,variablesainsi les les constantes .

Types

En informatique, lorsque nous parlons de types, il est question de types de données. Un type est ce qui défini la nature des valeurs que peut prendre une donnée. Il existe différents type de données que vous retrouverez ci-dessous :

String (chaîne de caractères), est un type qui s'écrit entre ", il peut contenir toutes les sortes de caractères. Exemple → "string"
Integer (Nombre entier relatif), est un type qui contient tous les entiers naturels auquel on ajoute un signe positif ou négatif. Exemple → 12 ou -3
Float (Nombre réel ou flottant), est un type contenant tous les nombres de l'ensemble réel, c'est à dire tous les nombres, ayant un nombre fini ou infini de décimal(s). Exemple → 1.465
Boolean (Booléen), est un type possédant uniquement 2 états, qui sont généralement TRUE ou FALSE. Exemple → TRUE
Array (Tableau), est un type de données paramétrées, contrairement aux précédent, il peut contenir plusieurs données . Sa syntaxe est généralement [ ] et chaque élément est séparé des autres par une ,. Exemple → ["ma variable", "12", "TRUE"]

Variables

Avant toutes choses, definissons ce qu'est une variable, afin de partir avec les mêmes bases. Le terme de variable est un terme provenant des mathématiques, d'après le site stephonsays, les variables mathématiques sont des éléments qui peuvent contenir une valeur qui peut être modifiée. Les principales utilisations des variables sont dans les équations ou les fonctions. Dans l'exemple ci-contre, x est un variable représentant l'inconnu. x²-2x+4=0

En programmation, les variables fonctionne sur le même principe, c'est un élément qui peut changer de valeur durant l'éxécution d'un programme.

Comment déclare-t-on une variable ?

Les façons de déclarer une variable sont diverses et variées, chaque langage possède une syntaxe propre pour déclarer une variable. Le mieux est de se renseigner sur la documention du langage informatique que vous utilisez.

Començons les exemples avec le PHP

// Déclarations variables
$a = "ma variable";
$b = 12;

// Output
echo $a; // Renvoie => ma variable
echo $b; // Renvoie => 12

Exemple avec Javascript

// Déclarations variables
let a = "ma variable"; // let a un "scope" ou porté LIMITE au bloc dans lequel il est utilisé
var b = 12; // var a un "scope" ou porté GLOBAL, accessible dans tout le code

// Output
console.log(a); // Renvoie => ma variable
console.log(b); // Renvoie => 12

Exemple avec Java

// Déclarations variables
char A = "ma variable";
int B = 12;

// Output
System.out.println(A); // Renvoie => ma variable
System.out.println(B); // Renvoie => 12

Java étant un langage fortement typé, il est nécessaire de comprendre les types.

Constantes

Il est temps de passé aux constantes, les constantes sont des éléments, comme les variable, provenant des mathématiques, qui peuvent contenir des données. Les constantes sont généralement visible dans les sciences de la nature ou la physique et la chimie, par exemple il existe la constante d'Avogadro. Cependant à la différence des variables, une constante ne peut pas changer de valeur.

En programmation, les constantes possèdent le même fonctionnement, elles ne peuvent pas changer de valeur durant l'exécution. Si un programme essaie de modifier la valeur d'une constante, le programme sera stopper et affichera une erreur.

Comment déclare-t-on une constante ?

Tout comme pour les variables, il existe plusieurs façon de déclarer une constante, cela dépend également du langage utilisé. Si vous essayez de redéfinir ou modifier la valeur d'une constante, le programme s'arretera et affichera une erreur.

Voici les exemples pour les différents langages support.

Exemple pour PHP

// Déclarations constantes
define("a", "ma variable");
define("b", 12);

// Output
echo a; // Renvoie => ma variable
echo b; // Renvoie => 12

Exemple pour Javascript

// Déclarations constantes
const a = "ma variable";
const b = 12;

// Output
console.log(a); // Renvoie => ma variable
console.log(b); // Renvoie => 12

Exemple pour Java

// Déclarations constantes
final char A = "ma variable";
final int B = 12;

// Output
System.out.println(A); // Renvoie => ma variable
System.out.println(B); // Renvoie => 12

Opérateurs logiques et de comparaisons

⚠️ Les opérateurs logiques et les opérateurs de comparaisons sont des opérateurs qui vous seront utile pour le prochain chapitre sur les conditions, il est donc essentiel de comprendre ce chapitre avant de passé à la suite !

Les opérateurs logiques

Liste d'opérateurs logiques existant

Opérateur	Syntaxe	Exemple	Résultat	Fonctionnement
AND (ET)	&&	a && b	Renvoie TRUE si a ET b valent TRUE	`&&` vérifie les opérations dans l'ordre (gauche à droite) et s'arrête lorqu'une opérations renvoie FALSE
AND (ET)	&	a & b	Renvoie TRUE si a ET b valent TRUE	`&` vérifie les deux opérations quoi qu'il arrive
OR (OU)	\|\|	a \|\| b	Renvoie TRUE si a OU b vaut TRUE	`\|\|` vérifie les opérations dans l'ordre (gauche à droite) et s'arrête lorsqu'une opérations renvoie FALSE
OR (OU)	\|	a \| b	Renvoie TRUE si a OU b vaut TRUE	`\|` vérifie les deux opérations quoi qu'il arrive (gauche à droite) et s'arrête lorsqu'une opérations renvoie FALSE
NOT (NON)	!	!a	Renvoie TRUE si a VAUT FALSE	`!` vérifie le caractère contraire d'une opérations

Les opérateurs de comparaisons

Liste des opérateurs de comparaisons

Opérateur	Syntaxe	Exemple	Résultat	Fonctionnement
Egal	==	a == b	Renvoie TRUE si a et b sont EGAUX	`==` vérifie que les deux éléments ont le même valeur
Identique	===	a === b	Renvoie TRUE si a et b sont EGAUX et DE MÊME TYPE	`===` vérifie que les deux éléments ont la même valeur et sont de même type
Différent	!=	a != b	Renvoie TRUE si a et b sont DIFFERENT	`!=` vérifie que les deux éléments ne possède pas la même valeur
Différent	!==	a !== b	Renvoie TRUE si a et b sont DIFFERENT et de TYPE DIFFERENT	`!==` vérifie que les éléments ne possède ni la même valeur ni le même type
Inférieur	<	a < b	Renvoie TRUE si a est INFERIEUR à b	`<` vérifie que le premier élément est strictement inférieur au second
Inférieur ou égal	<=	a <= b	Renvoie TRUE si a est INFERIEUR OU EGAL à b	`<=` vérifie que le premier élément est inférieur ou égal au second
Supérieur	>	a > b	Renvoie TRUE si a est SUPERIEUR à b	`>` vérfie que le premier élément est strictement suprieur au second
Supérieur ou égal	>=	a >= b	Renvoie TRUE si a est SUPERIEUR OU EGAL à b	`>=` vérifie que le premier est supérieur ou égal au second

Les conditions

Une condition est un des éléments les plus important en programmation. C'est cet élément qui permettra de vérifier que l'utilisateur entre le bon type de données pour les calculs, ou pour un mots de passe par exemple. Mais avant de se lancer dans le développement de conditions, regardons de quoi elles se composent.

Nous retrouvons dans la majorité des langages la structure ci-dessous

if (condition)
{
    code...
} else if (condition)
{
    code...
} else
{
    code...
}

Premièrement nous pouvoir voir le mot-clé if désignant si, c'est lui qui va initialiser la condition. Après nous voyons la condition entouré de parenthèses, c'est ici que vous entrerez votre ou vos opérations(s) logique(s) ou de comparaison(s). Entre les accolades, vous trouverez le code qui sera effectué si la condition vaut TRUE.

{

}

Le mot-clé else est le mot-clé qui défini le code a exécuter si la condition n'est pas rempli, il est comparable à sinon, il peut être suivi d'une nouvelle condition if (condition). À savoir que else n'est pas obligatoire lors de mise en place d'une condition.

Malgré beaucoup de similitude sur les conditions dans les langages, certains ne suivent pas exactement la même syntaxe.

Le PHP ne déroge pas à la règle

// Déclarations variables
$a = "mot de passe";
$b = 12;

// Conditions simple
if ($a == "mot de passe")
    echo "Le mot de passe est correct"; // Renvoie => Le mot de passe est correct

// Multi conditions
if ($b > 20) {
    echo "b est supérieur à 20"; // Ne renvoie rien, le code n'est pas exécuter car la condition n'est pas remplie
}
elseif ($b < 10 ) {
    echo "b est inférieur à 10"; // Ne renvoie rien, le code n'est pas exécuter car la conditions n'est pas remplie
}
else {
    echo "b est un nombre compris entre 10 et 20"; // Renvoie => b est un nombre compris entre 10 et 20
}

Le javascript lui, suit bien la structure

// Déclarations variables
let a = "mot de passe";
let b = 12;

// Conditions simple
if (a == "mot de passe") {
	console.log("le mot de passe est correct"); // Renvoie => Le mot de passe est correct
}

// Multi conditions
if (b > 20) {
	console.log("b est supérieur à 20"); // Ne renvoie rien, le code n'est pas exécuter car la condition n'est pas remplie
} else if (b < 10) {
	console.log("b est inférieur à 10"); // Ne renvoie rien , le code n'est pas exécuter car la conditions n'est pas remplie
} else {
	console.log("b est un nombre compris entre 10 et 20"); // Renvoie => b est un nombre compris entre 10 et 20
}

De même pour le Java

// Déclarations variables
char A = "mot de passe";
int B = 12;

// Conditions simple
if (A == "mot de passe") {
    System.out.println("le mot de passe est correct"); // Renvoie => le mot de passe est correct
}

// Multi conditions
if (B > 20) {
    System.out.println("B est supérieur à 20"); // Ne renvoie rien, le code n'est pas exécuter car la condition n'est pas remplie
} else if (B < 10) {
    System.out.println("B est inférieur à 10"); // Ne renvoie rien, le code n'est pas exécuter car la condition n'est pas remplie
} else {
    System.out.println("B est un nombre compris entre 10 et 20"); // Renvoie => B est un nombre compris entre 10 et 20
}

Ce n'est pas tout !

Mais ce n'est pas la seule manière pour créer une condition, il existe une façon plus simple qui vous sera utile si vous enchainer les conditions.

Vous trouverez dans la plupart des langages les instructions swicth / case. Avec ces instructions il sera plus simple de créer uns suite de conditions.

switch (expression) {
    case "vérification":
        code...
    break;
    case "vérification":
        code...
    break;
    case "vérification":
        code...
    break;
    default:
        code...
    break;
}

Analysons l'exemple présent ci-dessus, en premier temps on trouve l'instruction switch, elle permet d'initier. Entre parenthèses, ce trouve l'expression a utilisé. Chaque case contient la vérification à faire sur l'élément de l'expression. Pour finir, break permet de mettre fin à l'instruction switch (ou non) dans le case précédent. default est une instruction qui sera exécuter si aucun des case n'est vérifié.

La vérification des case se fait l'une après l'autre dans le sens d'écriture (haut vers le bas).

Exemple PHP

$i = 2;

switch ($i) {
    case "1":
        echo "i est égal à 1"; // Ne renvoie rien, le code n'est pas exéuter car la vérification n'est pas passé
    break;
    case "2":
        echo "i est égal à 2"; // Renvoie => i est égal à 2
    break;
    case "3":
        echo "i est égal à 3"; // Ne renvoie rien, le code n'est pas exécuter car la vérification n'est pas passé
    break;
    default:
        echo "i est inconnu"; // Ne renvoie rien, le code n'est pas exécuter car la vérification de case "2" est passé
    break;
}

Exemple Javascript

let i = 2;

switch (i) {
	case "1":
		console.log("i est égal à 1"); // Ne renvoie rien, le code n'est pas exéuter car la vérification n'est pas passé
		break;
	case "2":
		console.log("i est égal à 2"); // Renvoie => i est égal à 2
		break;
	case "3":
		console.log("i est égal à 3"); // Ne renvoie rien, le code n'est pas exécuter car la vérification n'est pas passé
		break;
	default:
		console.log("i est inconnu"); // Ne renvoie rien, le code n'est pas exécuter car la vérification de case "2" est passé
}

Exemple Java

int i = 2;

switch (i) {
    case "1":
        System.out.println("i est égal à 1"); // Ne renvoie rien, le code n'est pas exéuter car la vérification n'est pas passé
    break;
    case "2":
        System.out.println("i est égal à 2"); // Renvoie => i est égal à 2
    break;
    case "3":
        System.out.println("i est égal à 3"); // Ne renvoie rien, le code n'est pas exécuter car la vérification n'est pas passé
    break;
    default:
        System.out.println("i est inconnu"); // Ne renvoie rien, le code n'est pas exécuter car la vérification de case "2" est passé
}

Les boucles

Les boucles sont des fonctionnalités disponible dans une grande majorité de langages informatiques, elles permettent de répeter une séquence de code. Il existe plusieurs sorte de boucle.

Les différentes boucles

Une boucle est un élément de prorramation qui permet d'exécuter un code plusieurs fois de suite, sans pour autant à ajouter le code plusieurs fois.

Boucles "for"

Cette boucle est une boucle qui s'exécute le nombre de fois prédéfini. On retrouve trois éléments qui constituent la structure de cette boucle.

Un élément d'itinitialisation, exéuter avant toutes les boucles
Une condition, qui est vérifié avant chaque boucle
Une instruction, Incrémentation ou Décrémentation exécuter après chaque boucle

for (defVariable; condition; instruction) {
    code...
}

Ci-dessus, nous initialisons la variable, ensuite nous entrons une conditions qui sera vérifiée à chaque nouvelle séquence de la boucle. Et pour finir, nous précisons l'instruction à effectuer à la fin de chaque occurence de la boucle.

Exemple en PHP

for ($i = 1; $i <= 10; $i++) {
    echo $i; // Renvoie verra 1, puis 2, puis 3, ..., puis 10
}

Exemple pour Javascript

for (let i = 0; i <= 10; i++) {
	console.log(i); // Renvoie verra 1, puis 2, puis 3, ..., puis 10
}

Exemple avec Java

for (int i = 0; i <= 10; i++) {
    System.out.printIn(i); // Renvoie verra 1, puis 2, puis 3, ..., puis 10
}

Boucles "while"

À la différence des boucles "for", la boucle while n'exécute pas le code un nombre de fois défini. Elle exécute tant que la condition renvoie TRUE

Sa structure se construit de la sorte

while (condition) {
    code...
}

Le mot clé while permet de commener l'usage de la boucle while, ensuite on retrouve la condition qui, tant que renvoie TRUE comme résultat, fera exécuter le code à l'intérieur de la boucle.

Passons à aux exemple concrets PHP

$i = 0;
while ($i <= 10) {
    echo $i; /// Renvoie verra 1, puis 2, puis 3, ..., puis 11
    i++; // Incrémente (ajoute) 1 à la valeur i, i = i+1 ou i++
}

Javascript

let i = 0;
while (i <= 10) {
	console.log(i); // Renvoie verra 1, puis 2, puis 3, ..., puis 11
	i++; // Incrémente (ajoute) 1 à la valeur i, i = i+1 ou i++
}

Java

int i = 0;
while (i <= 10) {
    System.out.printIn(i); // Renvoie verra 0, puis 1, puis 2, ..., puis 11
    i++; // Incrémente (ajoute) 1 à la valeur i, i = i+1 ou i++
}

Boucles do-while

Le fonctionnement de la boucle do-while est le même que que celui de la boucle while, à la différence que la condition est vérifé après le bloque d'instruction de la boucle ce qui assure une exécution.

La syntaxe de cette boucle est la suivante

do {
    code...
} while (condition);

Le début de l'instruction est do c'est lui qui initialise la boucle, à la suite on retrouve le code à exécuter à l'intérieur du bloc

{

}

Ensuite nous mettons le mot clé while le même que pour la boucle while, enfin la condition est présente pour vérifier lorsque la boucle doit être arrêté.

Exemple avec PHP

$i = 0
do {
    echo $i; // Renvoie 0, puis 1, puis 2, ..., puis 11
    $i++; // Incrémente (ajoute) 1 à la valeur de $i
} while ($i <= 10);

Pour Javascript

let i = 0;
do {
	console.log(i); // Renvoie 0, puis 1, puis 2, ..., puis 11
	i++; // Incrémente (ajoute) 1 à la valeur de i
} while (i <= 10);

Et Java

int i = 0;
do {
    System.out.printIn(i); // Renvoie 0, puis 1, puis 2, ..., puis 11
    i++; // Incrémente (ajoute) 1 à la valeur de i
}

Boucle "forEach"

La dernière des boucles est la boucle forEach. Comme le dit son nom, elle permet de parcourir tout les éléments d'un tableau.

Sa structure diffère un peu d'un langage à l'autre, nous vous conseillons donc de vous renseigner pour le langage que vous souhaitez utiliser si ce dernier ne fait pas parti des langages supports de ce cours.