N.B. Cette page qui sera modifiée lors du cours est destinée aussi à servir de référence :
ce n'est pas le contenu du cours !
(C'est plus un aide mémoire)
Pour l'instant, vous n'avez pas BESOIN de lire cette page (mais vous pouvez si vous voulez :) )
N'ayez pas peur : tout ça vous paraitra évident dans quelques temps !
La programmation est une discipline qui consiste à écrire des instructions pour un ordinateur afin de lui donner des directives précises.
Chaque langage de programmation utilise des instructions spécifiques pour décrire les actions à effectuer par le programme. Ces instructions sont toutes en anglais qui est, de fait, la langue utilisée pour quasiment tous les langages de programmation.
La syntaxe (l'enchainement des instructions...) est propre à chaque langage mais comme la logique sous-jacente est quasiment la même d'un langage à un autre, il n'est pas difficile du tout de passer d'un langage à un autre. Un programmeur professionnel changera plusieurs fois de langage dans sa carrière de toute façon (ou en utilisera plusieurs à la fois).
L'on peut écrire des commentaires dans son code (il faut le faire !) pour en faciliter la compréhension. Ces commentaires seront ignorés par le programme.
On peut écrire un commentaire seul sur une ligne ou après des instructions sur la même ligne.
N.B. Il existe aussi, dans certains langages, des commentaires sur plusieurs lignes avec une autre syntaxe.
# Ceci est un commentaire sur une seule ligne
// Ceci est un commentaire sur une seule ligneOn peut décrire des constantes comme des valeurs auxquelles on fait référence par leur nom ou comme des variables dont la valeur ne change jamais.
Elles sont utilisées par soucis de clarification de la compréhension d'un programme à sa lecture et pour pouvoir changer une valeur lors de la phase de développement sans avoir à chercher partout où elle est utilisée.
Par convention, les constantes sont écrites en majuscules.
Les conventions de programmation sont des rècles qui n'interviennent pas dans le fonctionnement du programme (si elles ne sont pas respectées cela ne change rien à son fonctionnement) mais qui facilitent la lecture et la compréhension du code par les développeurs.
Les variables sont des espaces de stockage dans la mémoire d’un ordinateur, utilisés pour contenir des valeurs telles que des nombres, du texte ou d’autres types de données. Elles permettent aux programmeurs de manipuler et d’accéder à ces valeurs tout au long du programme.
Le nom de la variable que l'on va utiliser à la place de sa valeur dans le code
Si truc est une variable de type Entier qui contient 5. Sa "valeur" est 5 !
Cela correspond à la portion de code où elle est accessible. Si une variable est déclarée au tout début du programme, par exemple, elle pourra être utilisée dans tout le programme. En revanche, si elle est déclarée dans une boucle (voir plus loin), elle n'existera qu'à l'intérieur de celle-ci.
Python et Javascript, par exemple, sont des langages faiblement typés. Bien sur, les types de variables existent dans tous les langages mais ici une variable peut changer de type en cours de route (uneVariable = "Bonjour" puis uneVariable=10.23 sans déclanchement d'erreur). Non seulement la valeur de la variable peut changer mais son type aussi.
L'avantage est que cela simplifie l'écriture car l'on n'a pas besoin de préciser le type de la variable à sa création.
L'inconvénient est que c'est une source d'erreurs de programmation.
En effet, dans la pratique, il est rarissime que l'on ait besoin de changer le type d'une variable dans un programme. Lorsque ça arrive, c'est très souvent une erreur du développeur.
Dans un langage fortement typé comme Java par exemple, un changement de type renvoie une erreur ce qui permet de les trouver bien plus facilement.
Un peu de vocabulaire !
+ - * = sont des opérateurs de même que < > >= (plus grand ou égal) == (pour vérifier que 2 éléments ont la même valeur) += (pour ajouter une valeur à un élément) ...
Un peu de vocabulaire !
Un bloc d'instruction est une suite d'instructions (de commandes de programmation)... voir les parties suivantes pour des exemples !
Les structures conditionnelles permettent au programme d’exécuter différentes actions en fonction d’une condition donnée. Par exemple, si une certaine condition est vraie, le programme exécute un bloc spécifique de code; sinon, il passe à une autre partie du code.
numero = 23
if numero == 4:
print("Le numéro est 4")
numero = 23 if numero == 4: print("Le numéro est 4") else: print("Je ne sais pas quel est le numéro")
int numero = 4;
if (numero == 4) {
print("Le numéro est 4");
}
N.B. L'indentation est une convention. On pourrait aussi bien écrire (par exemple) :
int numero = 4; if (numero == 4) {print("Le numéro est 4");}
int numero = 23;
if (numero == 4) {
print("Le numéro est 4");
}
else {
print("Je ne sais pas quel est le numéro");
}
C'est presque comme en Java.
let numero = 4;
if (numero == 4) {
alert("Le numéro est 4");
}
N.B.
let numero = 4; if (numero == 4) {alert("Le numéro est 4");}
let numero = 23;
if (numero == 4) {
alert("Le numéro est 4");
}
else {
alert("Je ne sais pas quel est le numéro");
}
(ça reste à écrire !)
Les boucles sont utilisées pour répéter l’exécution d’un bloc spécifique de code jusqu’à ce qu’une certaine condition soit remplie ou jusqu’à ce qu’une limite soit atteinte. Cela permet aux programmes d’effectuer des tâches itératives plus rapidement et efficacement.
chiffre = 0 while chiffre < 10: print(chiffre) chiffre = chiffre+1
int chiffre = 0;
while (chiffre < 10) {
print(chiffre);
chiffre = chiffre+1;
}
let chiffre = 0;
while (chiffre < 10) {
alert(chiffre);
chiffre = chiffre+1;
}
ou plutôt, pour avoir l'affichage des chiffres en une seule fois :
let chiffre = 0;
let tousleschiffres = "";
while (chiffre < 10) {
tousleschiffres = tousleschiffres+chiffre;
chiffre=chiffre+1;
}
alert(tousleschiffres);
Ecrire les chiffres en partant de 0
for i in range(10):
print(i)
range(10) est une liste de nombre de 0 à 9, ça peut se noter aussi : [0,1,2,3,4,5,6,7,8,9]
On peut donc aussi écrire :
chiffres = [0,1,2,3,4,5,6,7,8,9]
for i in chiffres:
print(i)
int [] chiffres={0,1,2,3,4,5,6,7,8,9};
for (int i : chiffres) {
print(i);
}
N.B. int [ ] indique un tableau (ici, une liste) d'entiers
On peut aussi écrire :
for (int i=0;i<10;i=i+1) {
print(i);
}
let chiffres = [0,1,2,3,4,5,6,7,8,9];
chiffres.forEach(i => {
alert(i);
});
N.B. - Les tableaux (Array) sont des objets qui ont une méthode forEach() (Pour comprendre, cela nécessite de savoir ce qu'est une classe donc une méthode !) : cf la partie en annexe sur la Programmation Orientée Objet ! - Comprendre le => nécessite en plus de savoir ce qu'est une classe anonyme !
ou (plus évident à comprendre !) :
for (i=0;i<10;i=i+1) {
alert(i);
}
Les fonctions sont des blocs autonomes de code qui effectuent une tâche spécifique lorsqu’elles sont appelées par le reste du programme. Elles permettent aux développeurs d’organiser leur code en morceaux réutilisables et modulaires.
Exemple avec un programme compteur(a) où a est un nombre entier : écrit les nombres de 1 à a
On a d'abord la définition de la fonction puis un exemple de son utilisation.
def compteur(stop):
i = 1
while i < stop+1:
print(i)
i = i + 1
compteur(4)
La déclaration de fonction :
compteur(int stop) {
int i = 1;
while (i < stop+1) {
System.out.print(i);
i = i + 1;
}
Son utilisation (à l'endroit approprié !) :
compteur(4)function compteur(stop) {
let i = 1;
while (i < stop+1) {
alert(i);
i = i + 1;
}
}
compteur(4);
(une partie n'est pas encore écrite !)
Cette partie va au delà de l'initiation à la programmation !
Il s'agit cependant juste d'un aperçu pour comprendre en gros de quoi il s'agit !
Les structures de données définissent comment les données peuvent être organisées, stockées et manipulées dans un programme informatique. Des exemples courants incluent les tableaux, les listes et les dictionnaires, qui permettent de stocker et d’accéder à des ensembles de données plus complexes.
N.B. Ceci n'est pas un cours de P.O.O. : Programmation Orientée Objet mais une vue générale de ce qu'est un objet.
Les tous premiers programmes étaient écrits en langage machine en utilisant les instructions disponibles dans les microprocesseurs. C'est ce que l'on appelle l'assembleur. Ce sont des instructions très simples et basiques (En savoir plus ici...). Chaque microprocesseur à son propre jeu d'insctructions.
Ensuite, ont été dévelopés les compilateurs : ce sont des programmes écrits dans des langages évolués qui transforment ces langages en instructions comprises par les microprocesseurs. wikipedia
Ainsi, on peut écrire un programme avec un langage évolué et le compiler pour des ordinateurs différents (les programmes sont différents car ils s'adressent à des microprocesseurs différents et à des systèmes d'exploitation différents : Linux, Mac, Windows, Android...). Le résultat est qu'on utilise un programme qui fonctionne indépendement des programmes du langage associé puisqu'il est en langage machine.
Un interpréteur fonctionne différemment. C'est le cas de Python (généralement) par exemple. Dans ce cas, les instructions évoluées du langage ne sont pas traduites en langage machine. En gros, c'est le programme Python qui va faire la traduction en langage machine au fur et à mesure que le programme fonctionne. Le programme ne peut donc pas fonctionner sans un autre programme qui lui est compilé et qui permet au code non traduit de fonctionner.
Et puis... le bytecode... Chacune des méthodes précédentes à ses avantages et ses inconvénients. Les programmes compilés sont très rapide mais demandent une phase de compilation qui prend un peu de temps pour pouvoir être testés. Les programmes interprétés sont plus lents mais il démarrent plus rapidement en général.
Une approche intermédiare existe : le bytecode : Il s'agit de précompiler les programmes dans un jeu d'instructions basiques qui ne dépendent pas d'un microprocesseur en particulier. Ce code spécifique sera interprété à l'exécution. Etant donné que le jeu d'instructions en question est proche du langage machine, il fonctionne beaucoup plus rapidement que pour le cas d'un programme interprété.
Les 2 exemples les plus connus de cette approche sont les programmes écrits en Java et le webassembly qui est le bytecode des navigateurs (cela permet d'avoir des programmes pour les jeux vidéos dans le navigateur). Les programmes écrits avec Godot Engine fonctionnent ainsi dans les navigateurs.
Pour Java, on peut écrire des programmes (compilés en bytecode Java) qui peuvent fonctionner sur n'importe quel ordinateur de bureau.
La compilation Just in Time (juste à temps) : Malgré cela, comme les programmes Java (déjà rapides) ne fonctionnaient pas assez vite pour certaines applications que les programmes compilés, il y a aussi une compilation qui est effectuée aujourd'hui pendant le fonctionnement d'un programme : c'est de cela qu'il s'agit.
A noter, les programmes en Javascript qui s'exécutent dans les navigateurs sont interprétés ET souvent compilés avec des systèmes JIT !!! C'est pourquoi ils peuvent aussi être plutôt rapides. La compilation étant un processus qui prend un certain temps, ce genre de programmes s'accélère au bout d'un certain temps d'utilisation car il commence par être interprété au départ pour fonctionner.
Noter que certaines versions de Python sont compilées et qu'il existe une version de Python qui tourne sur la machine virtuelle de Java qui peut ainsi interargir avec toutes les bibliothèques Java
Cependant, les programmes écrits en Python sont réputés être relativement lents par rapport aux autres systèmes ! D'autre part, les grosses applications sont rarement écrites en Python. En revanche, il semble que le temps de développement soit plus réduit avec Python.
Godot Engine avec GDscript : un langage interprété avec l'utilisation intensive de bibliothèques internes déjà compilées (donc très rapides). De plus, il y a diverses optimisations notamment avec l'utilisation de variables fortement typées qui accélèrent les jeux et les applications.
Javascript : un langage avec compilation JIT dans les navigateurs.
Typescript est une variante de Javascript qui est utilisée pour écrire des applications plus robustes (les programmes en Typescript sont "transpilés" en Javascript, c'est à dire réécrits en javascript par des programmes pour fonctionner notamment dans les navigateurs).
Java et C# : des langages avec bytecode et compilation JIT de ce bytecode
Des langages compilés : C/C++, Rust, Go, FreePascal...
La grande majorité des langages de programmation sont écrits en C/C++ (comme les systèmes d'exploitation : Linux, Mac, Windows) avec une partie écrite en Rust pour certains d'entre eux (comme Linux).
La plupart de ces langages peuvent aussi être compilés en Webassembly qui est le "bytecode de bas niveau" compris par les navigateurs...