Apprendre un nouveau langage de programmation [code exemple]

Quand on connait déjà un premier langage de programmation, il est beaucoup plus facile d’en apprendre d’autres. On connait déjà les grands principes et la logique de programmation, il ne reste qu’à apprendre les spécificités du nouveau langage.

Pourquoi apprendre un nouveau langage de programmation c’est plus facile ?

La partie algorithmique est en grande partie indépendante du langage dans laquelle on va la programmer. De même que la pensée est en grande partie indépendante de la langue dans laquelle on va l’exprimer.
Les notions de bases telles que variables, types, fonctions, conditions, boucles, opérateurs, concaténation, interpolation, tableaux, objets, méthodes… sont déjà familières.
Si on a besoin d’apprendre un nouveau langage, c’est généralement parce que celui qu’on connait déjà n’est pas adapté à notre projet. C’est plus motivant de mettre directement et concrètement en application les nouvelles connaissances 🙂
On peut faire des recherches d’équivalence entre les fonctions et méthodes natives du nouveau langage et celui qu’on connait déjà.
Les réflexes de consultation de la doc (officielle, stackoverflow et/ou chatGPT), de debug et de tests sont acquis.

Comparaison entre 4 langages : PHP, JavaScript, C#, Python

Avec ce tableau, si vous maitrisez déjà un de ces langages de programmation, vous aurez les bases des 3 autres.

Faire défiler horizontalement pour voir tous les langages

	PHP	JavaScript	C#	Python
Extension	.php	.js	.cs	.py
Structure	<?php … ?>
Fin d’instruction	;	;	;	retour à la ligne
Bloc	{ … }	{ … }	{ … }	: (indentation) … …
Commentaire	// ou #	//	//	#
Commentaire multi-ligne	/* … */	/* … */	/* … */
Afficher	echo(“PHP”);	console.log(“JS”);	Console.WriteLine(“C#”);	print(“Python”)
Typage	dynamique	dynamique	statique	dynamique
Types natifs	int float bool string array object null ressource	number bigint boolean string object (array) (date) null undefined symbol	int long float double bool char string	int float complex bool str list tuple range dict set frozenset bytes bytearray memoryview NoneType
Variable	$code=”PHP”;	let code=”JS”;	string code=”C#”;	code=”Python”
Concaténation	.	+	+	+
Opérateurs arithmétiques	+ – * / % ** ++ —	+ – * / % ** ++ —	+ – * / % Math.Pow(x,y) ++ —	+ – * / % ** //
Opérateurs de comparaison	== === != <> !== > < >= <= <=>	== === != !== > < >= <=	== != > < >= <=	== != > < >= <=
Opérateurs logiques	&& \|\| ! and or xor	&& \|\| !	&& \|\| !	and or not
Interpolation	“langage : $code”	``langage : ${code}``	$”langage : {code}”	f”langage : {code}”
constante	define(“PI”,3.14);	const PI=3.14;	const float Pi=3.14F
tableau	$t=[1,2,3]; echo $t[0] //1	const t=[1,2,3]; echo t[0] //1	int[] t={1,2,3}; Console.WriteLine(t[0]);//1	#pas de tableau on peut utiliser des listes à la place t=[1,2,3] print(t[0]) #1
fonction	`function love($lang="PHP"){ return "I love $lang"; } echo love("ObjectifSEO.fr");`	`function love(lang="JS"){ return "I love "+lang; } /ou avec une fonction fléchée const love = (lang="JS") => { return "I love "+lang; } / console.log(love("ObjectifSEO.fr"));`	`//uniquement des méthodes class Program { static string love(string lang="C#"){ return "I love "+lang; } static void Main(string[] args) { Console.WriteLine(love("ObjectifSEO.fr")); } }`	`def love(lang="Python"): return "I love "+lang; print(love("ObjectifSEO.fr"))`

Si je connais déjà un langage de programmation, c’est facile de faire une condition dans un autre langage

Restons sur les 4 langages précédents et voyons différentes façons de gérer les conditions.

//Si sinon si sinon
if (langage>1){
  Console.WriteLine("Trop facile !");
}else if (langage==1){
  Console.WriteLine("Ça me dit quelque chose.");
}else{
  Console.WriteLine("Faut bien commencer quelque part...");
}

//switch
switch (langage){
  case 0:
    Console.WriteLine("Faut bien commencer quelque part...");
    break;  
  case 1:
    Console.WriteLine("Ça me dit quelque chose.");
    break;
  default:
    Console.WriteLine("Trop facile !");
    break;
}

//opérateur ternaire
Console.WriteLine( (langage>0) ? "Trop facile !" : "Faut bien commencer quelque part...");

Python

#Si sinon si sinon
if langage>1:
  print("Trop facile !");
elif langage==1:
  print("Ça me dit quelque chose.");
else:
  print("Faut bien commencer quelque part...");

#match
match langage:
  case 0:
    print("Faut bien commencer quelque part...");
  case 1:
    print("Ça me dit quelque chose.");
  case _:
    print("Trop facile !");

#opérateur ternaire
print("Trop facile !" if langage>0 else "Faut bien commencer quelque part..."

JavaScript

//Si sinon si sinon
if (langage>1){
  console.log("Trop facile !");
}else if (langage==1){
  console.log("Ça me dit quelque chose.");
}else{
  console.log("Faut bien commencer quelque part...");
}

//switch
switch (langage){
  case 0:
    console.log("Faut bien commencer quelque part...");
    break;  
  case 1:
    console.log("Ça me dit quelque chose.");
    break;
  default:
    console.log("Trop facile !");
}

//opérateur ternaire
console.log( (langage>0) ? "Trop facile !" : "Faut bien commencer quelque part...");

PHP

<?php
//Si sinon si sinon
if ($langage>1){
  echo "Trop facile !";
}else if ($langage==1){
  echo "Ça me dit quelque chose.";
}else{
  echo "Faut bien commencer quelque part...";
}

//switch
switch ($langage){
  case 0:
    echo "Faut bien commencer quelque part...";
    break;  
  case 1:
    echo "Ça me dit quelque chose.";
    break;
  default:
    echo "Trop facile !";
}

//opérateur ternaire
echo ($langage>0) ? "Trop facile !" : "Faut bien commencer quelque part...";

//match
echo match($langage){
  0 => "Faut bien commencer quelque part...",
  1 => "Ça me dit quelque chose.",
  default => "Trop facile !",
};
?>

Tant que j’apprends un nouveau langage, faire des boucles devient de plus en plus facile

Comme pour le conditions, les boucles sont très semblables d’un langage à l’autre. En plus, vous savez déjà quand utiliser un “pour”, un “tant que”, un “faire tant que” ou un “pour chaque”.

//Boucle For
for (int i=2;i<=10;i++){
  Console.WriteLine($"C'est {i} x plus facile la {i}ème fois!");
}

//Boucle While
int i=2;
while (i<=10){
  Console.WriteLine($"C'est {i} x plus facile la {i}ème fois!");
  i++;
}

//Boucle Do While
int i=2;
do
{
    Console.WriteLine($"C'est {i} x plus facile la {i}ème fois!");
    i++;
} while (i<=10);

//Boucle Foreach
string[] langages={"PHP","JS","C#","Python"};
foreach (string langage in langages){
  Console.WriteLine("Je programme en "+langage);
}

Python

#Boucle For
for i in range(2,10)
  print(f"C'est {i} x plus facile la {i}ème fois!");

#Boucle While
i=2
while i<=10:
  print(f"C'est {i} x plus facile la {i}ème fois!");
  i+=1;

#Pas de boucle Do While en Python on peut la simuler
i=2;
while True:
    console.log(f"C'est {i} x plus facile la {i}ème fois!");
    i+=1;
    if i>=10:
      break

#Boucle For in
langages=["PHP","JS","C#","Python"]
for langage in langages:
  print("Je programme en "+langage)

JavaScript

//Boucle For
for (let i=2;i<=10;i++){
  console.log(`C'est ${i} x plus facile la ${i}ème fois!`);
}

//Boucle While
let i=2;
while (i<=10){
  console.log(`C'est ${i} x plus facile la ${i}ème fois!`);
  i++;
}

//Boucle Do While
let i=2;
do
{
    console.log(`C'est ${i} x plus facile la ${i}ème fois!`);
    i++;
} while (i<=10);

//Boucle For of
const langages=["PHP","JS","C#","Python"];
for (let langage of langages){
  console.log("Je programme en "+langage);
}

PHP

//Boucle For
for ($i=2;$i<=10;$i++){
  echo "C'est $i x plus facile la {$i}ème fois!");
}

//Boucle While
$i=2;
while ($i<=10){
  echo "C'est $i x plus facile la {$i}ème fois!");
  $i++;
}

//Boucle Do While
$i=2;
do
{
    echo "C'est $i x plus facile la {$i}ème fois!");
    $i++;
} while ($i<=10);

//Boucle Foreach
$langages=["PHP","JS","C#","Python"];
foreach ($langages as langage){
  echo "Je programme en ".$langage);
}

Pour les langages orienté objet, les principes de la POO restent les mêmes quelque soit le langage même si les mots clés et la mise en application peuvent un peu varier.

Sur quoi se concentrer quand on apprend un nouveau langage de programmation ?

Quand on apprend un nouveau langage de programmation, il faut déjà se poser quelques questions :

Est-il compatible avec notre IDE ou va t’on devoir en installer un autre ?
Est-il orienté objet, procédural ou les deux ?
Comment gère-t-il :
- le nettoyage de la mémoire ?
- le typage des variables ?
- la déclaration des variables ?
- Les différentes portées ?
- le polymorphisme ?
- l’encapsulation ?
- le communication avec la base de données le cas échéant ?
- …
Et pour tout ça, est-ce similaire à ce que je connais déjà ?

Ensuite il faut noter les différences qu’il présente par rapport à celui ou ceux qu’on connait déjà. C’est là qu’il faudra être attentif pour nepas faire d’erreurs.

Et enfin on peut se concentrer sur les spécificités du nouveau langage : fonctions et objets internes, librairies et modules, éventuellement framework.

À quoi faire attention quand on apprend un nouveau langage de programmation ?

Avant tout à ne pas faire d’erreurs d’étourderies dues à des reflexes acquis avec l’ancien langage. Exemple en Python ne pas mettre de “;” en fin d’instruction si on vient du PHP.

Il faut aussi faire attention lors de la phase algorithmique à ne pas s’appuyer sur des concepts qui n’existent pas dans le nouveau langage de programmation.

Mais comme toujours, la pratique nous rend meilleur et l’erreur est le meilleur professeur!

Apprendre un nouveau langage de programmation