Cours bases en Algo

Calcul du produit et vérification du signe 

                    
                    
                        
    fonction produit() {
        // Déclaration des variables
    variable a;
    variable b;
    
    // Saisie de la première valeur
    a = parseFloat prompt "Veuillez Saisir une valeur a;
    
    // Saisie de la deuxième valeur
    b = parseFloat(prompt("Veuillez Saisir une valeur b"));
    
    // Calcul du produit
    variable result = a fois b;
    
    // Vérification du signe du résultat
    si result est supérieur à 0 {
        alerte"Le resultat est positif " + result;    
    } sinon si (result est inférieur à 0) {
        alerte "Le resultat est negatif " + result;
    } else {
        alerte "Le resultat est nul";
        }
    }

Vérification nombre pair ou impair (version 1) 

                    
                    
    function pair() {
        // Déclaration de la variable
        var a;
        
        // Saisie de la valeur
        a = parseFloat(prompt("Veuillez Saisir une valeur a"));
        
        // Vérification si le nombre est pair ou impair
        if(a%2 == 0) {
            alert("Le nombre est pair");
        } else {
            alert("Le nombre est impair");
        }
    }

Vérification nombre pair ou impair (version 2) 

                    
                    
    // Saisie directe de la valeur
    let n = parseInt(prompt("Veuillez Saisir une valeur n"));
    
    // Vérification si le nombre est pair ou impair
    if(n%2 == 0) {
        alert("Le nombre est pair");
    } else {
        alert("Le nombre est impair");
    }

Calcul du produit avec variables x et y 

                    
                    
    // Déclaration des variables
    let x;
    let y;
    let result;
    
    // Saisie des valeurs
    x = parseFloat(prompt("Veuillez Saisir une valeur x"));
    y = parseFloat(prompt("Veuillez Saisir une valeur y"));
    
    // Calcul du produit
    result = x * y;
    
    // Vérification du signe du résultat
    if (result > 0) {
        alert("Le resultat est positif " + result);
    } else if (result < 0) {
        alert("Le resultat est negatif " + result);
    } else {
        alert("Le resultat est nul");
    }

Utilisation d'une fonction pour calculer le produit 

                    
                    
    function produit(a, b) {
        // Fonction qui calcule le produit de deux nombres
    
    
        // Saisie des valeurs
        let a = parseInt(prompt("Veuillez Saisir une valeur a"));
        let b = parseInt(prompt("Veuillez Saisir une valeur b"));
        
        // Calcul du produit en utilisant la fonction
        let result_produit = produit(a, b);
        
        // Vérification du signe du résultat
        if(result_produit < 0) {
            alert("le produit est négatif " + result_produit);
        } else if(result_produit > 0) {
            alert("le produit est positif " + result_produit);
        } else {
            alert("le produit est nul");
        }
    }

Conditions if-else et switch pour les feux de circulation 

                    
                    
    var feu;
    
    if (feu == "vert") {
        alert("J'avance");
    } else if (feu == "orange") {
        alert("Je m'arrête");
    } else if (feu == "rouge") {
        alert("Je m'arrête");
    } else {
        alert("Couleur invalide");
    }
    
    // utilisation de case 
    
    switch (feu) {
        case "vert":
            alert("J'avance");
            break;
        case "orange":
            alert("Je m'arrête");
            break;
        case "rouge":
            alert("Je m'arrête");
            break;
        default:
            alert("Couleur invalide");
            break;
    }

Utilisation de switch pour afficher les mois 

                    
                    
                
    var mois;    
    mois = parseInt(prompt("Veuillez Saisir un mois par son numero"));
    
    switch(mois) {
        case 1:
            alert("Janvier");
            break;
        case 2:
            alert("Février");
            break;
        case 3:
            alert("Mars");
            break;
        case 4:
            alert("Avril");
            break;
        case 5:
            alert("Mai");
            break;
        case 6:
            alert("Juin");
            break;
        case 7:
            alert("Juillet");
            break;
        case 8:
            alert("Août");
            break;
        case 9:
            alert("Septembre");
            break;
        case 10:
            alert("Octobre");
            break;
        case 11:
            alert("Novembre");
            break;
        case 12:
            alert("Décembre");
            break;
        default:
            while(mois < 1 || mois > 12) {
                alert("Mois invalide");
                mois = parseInt(prompt("Veuillez Saisir un mois par son numero"));
            }
        }

Utilisation d'un tableau pour afficher les mois 

                    
                    
    // avec un tableau
    let mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"];
    let insertMois = parseInt(prompt("Veuillez Saisir un mois par son numero"));
    
    let result = mois[insertMois - 1];
    
    if (insertMois <= 12) {
        alert("Votre mois est : " + result);
    } else {
        while(insertMois > 12 || insertMois < 1) {
            alert("Mois invalide");
            insertMois = parseInt(prompt("Veuillez saisir un mois par son numero"));
        }
    }

Boucle for avec compteur croissant 

                    
                    
    // boucle for
    let egg;    
    for(egg = 1; egg <= 10; egg++) {
        alert("🥚 : " + egg);
    }

Boucle for avec compteur décroissant 

                    
                    
    let compteur;
    
    for(compteur = 10; compteur >= 1; compteur--) {
        alert("Bonsoir x" + compteur);
    }

Boucle for avec affichage "Bonsoir" 

                    
                    
    let i;

    for(i = 1; i <= 10; i++) {
        alert("Bonsoir x" + i);
    }

Boucle while avec compteur 

                    
                    
    let i = 0;

    while(i <= 10) {
        alert("Bonsoir x" + i);
        i++;
    }

Calcul de somme avec boucle while 

                    
                    
    let somme = 1;
    let i = 1;

    while(i <= 9) {
        i+=1;
        somme += i;
    }
    alert("La somme est : " + somme);

Calcul de somme avec boucle for (version 1) 

                    
                    
    // boucle for
    let somme = 0;
    
    for(let i = 1; i <= 9; i++) {
        somme = i+1;
    }
    alert("La somme est : " + somme);

Calcul de somme avec boucle for et saisie utilisateur 

                    
                    
    // boucle for
    let somme = 0;
    let saisie = parseInt(prompt("Veuillez Saisir une valeur"));
    
    for(let i = 1; i <= saisie; i++) {
        somme += i;
    }
    alert("La somme est : " + somme);

Calculer la somme des nombres impairs entre deux nombres donnés 

                    
                    
    let nombreX = parseInt(prompt("Veuillez Saisir une valeur x"));
    let nombreY = parseInt(prompt("Veuillez Saisir une valeur y"));

    let somme = 0;

    if (nombreX > nombreY) {
        let change = nombreX;
        nombreX = nombreY;
        nombreY = change;
    }

    for (let i = nombreX; i <= nombreY; i++) {
        if (i % 2 !== 0) { 
            somme += i; 
        }
    }

    alert("La somme des nombres impairs est : " + somme);

Vérifier si une chaîne de caractères donnée est un palindrome 

                    
                    
    let phrase = prompt("Un palindrome c'est une phrase qui se lit de la même façon dans les deux sens" + "\n" + "Veuillez Saisir une chaîne de caractères");

    // Nettoyer la chaîne : enlever les espaces et mettre en minuscules
    let phraseNettoyee = phrase.replace(/ /g, "").toLowerCase();

    // Inverser la chaîne nettoyée
    let phraseInversee = phraseNettoyee.split("").reverse().join("");

    // Comparer la chaîne nettoyée avec sa version inversée
    if (phraseNettoyee === phraseInversee) {
        alert("La phrase est un palindrome : " + phrase);
    } else {
        alert("La phrase n'est pas un palindrome : " + phrase);
    }

Bouton pour activer le dark mode 

                    
                    
    function toggleDarkMode() {
        document.body.classList.toggle("dark-mode");
    }

Générateur de mot de passe

Cours en JS - Bases du JS

Javascript c'est quoi ?

  • Crée en 10j par Brendan Eich chez Netscape en 1995
  • Utilisé pour les petites interactions, (alert, formulaires)
  • Langage puissant avec l'arrivée d'Ajax, plusieurs frameworks, VueJS, React
  • Controle le comportement des pages et peut etre utilisé coté serveur
  • Acronyme AJAX:
    • Asynchrone
    • Javascript
    • And
    • XML
    • Il y a 3 grands types:
      • Const: Ne va jamais changer (let prenom = "Gwenhael";)
      • let : Variable qui peut changer au cours du temps (let age = 20;)
      • var : est booléen donc true ou false.

    Générer une phrase avec les variables 

                            
                        
                            function phrase() {
                                const prenom = 'Gwenhael';
                                //const nom = 'Le Thiec';
                                let age = 22;
                                const birth = '19.05.2003';
                                const villeDeNaissance = "Le Coudray";
                                const sexe = "masculin";

                                alert("Regardez dans la console")
                                console.log(`Je m'appelle ${prenom} j'ai ${age} ans, je suis né le ${birth} de sexe ${sexe} `);
                            }

    Programmation Orientée Objet

    Programmation Orientée Objet

    La programmation orientée objet (POO) est une approche de la conception de logiciels qui met l'accent sur la conceptualisation des éléments impliqués comme des « objets ». Elle repose sur la structuration du code via des classes et des objets, facilitant la gestion de la complexité des logiciels modernes. Les concepts fondamentaux de la POO incluent l'abstraction, l'encapsulation, l'héritage et le polymorphisme, qui sont cruciaux pour une architecture de code maintenable et évolutive.

    Boucles While et for

    Boucle for

                            
                        
                            // Va parcourir le tableau même après avoir trouvé le resultat

                            function boucleFor() {
                                let str = "";

                                for (let i = 0; i < 9; i++) {
                                    str = str + i;
                                }

                                console.log(str);
                            }

    Boucle while

                            
                        
                            // While va parcourir une fois le tableau

                            function boucleWhile() {
                                let index = 0;

                                while (index < 10) {
                                    alert("index", index++);
                                }
                            }

    While sapin

                            
                        
                            const rows = 5;
                            const char = "*";
                            const space = " ";

                            for (let i = 1; i <= rows; i++) {
                                    let row = "";

                                    for (let j = 1; j <= rows - i; j++) {
                                            row += space;
                                    }

                                    for (let k = 1; k <= 2 * i - 1; k++) {
                                            row += char;
                                    }

                                    console.log(row);
                            }

                            ----------Résultat---------------
                                         *
                                        ***
                                       *****
                                      *******
                                     *********

    Les fonctions

                            
                        
        function fonction() {
            alert("Voici la fonction")
        }

    Cours de Programmation de Jeu Spatial

    Partie 1: Variables et opérations de base

    
// Création des variables de base
let stationEnergy = 500;
let stationLevel = 1;
let stationHero = "";
const generatorEnergy = 50;

// Opérations sur les variables
alert("Regardez la console pour voir les résultats");
console.log("La station possède " + stationEnergy + " points d'énergie et est de niveau " + stationLevel + " et elle n'a pas de héro");
stationEnergy += generatorEnergy;
console.log(generatorEnergy);
stationEnergy -= 100;
console.log(stationEnergy);
stationEnergy += 27;
console.log(stationEnergy);
stationLevel += 1;
stationEnergy += 100;
stationHero = "Gaspard";
console.log("Après tous les évènements, " + stationHero + " a sauvé la station et la station possède " + stationEnergy + " points d'énergie et est de niveau " + stationLevel);

    Partie 2: Objets et leurs propriétés

    
let Objet = {
    name: "Aurora",
    stationLevel: 1,
    healthStation: 500,
    hero: ""
};

let ennemySpaceShip = {
    name: "Destroyer-x",
    degats: 100,
};

// Manipulation des propriétés de l'objet
alert("Regardez la console pour voir les résultats");
Objet.healthStation += 50;
console.log(Objet.healthStation);
Objet.healthStation -= ennemySpaceShip.degats;
console.log(Objet.healthStation);
Objet.healthStation += 27;
console.log(Objet.healthStation);
Objet.stationLevel += 1;
console.log(Objet.stationLevel);
Objet.healthStation += 100;
console.log(Objet.healthStation);
Objet.hero = "Alice";
alert(`Grâce à ${Objet.hero} ${Objet.name} est maintenant au niveau ${Objet.stationLevel} avec ${Objet.healthStation} points d'énergie !`);

    Partie 3: Tableaux et leurs manipulations

    
let flottePrincipale = ["Falcon", "Orion", "Nebula"];
alert("Regardez la console pour voir les résultats");
console.log(flottePrincipale[0]);
flottePrincipale.push("Phoenix");
flottePrincipale.pop();

// Copie de tableau
let copieFlotte = flottePrincipale;
copieFlotte.push("Spectre");
console.log(`Tableau 1: ${flottePrincipale}`);
console.log(`Tableau 2: ${copieFlotte}`);

// Clone de tableau
let flotteClonee = [...flottePrincipale];
flotteClonee.push("Nova");
console.log(`Tableau 1: ${flottePrincipale}`);
console.log(`Tableau 2: ${copieFlotte}`);
console.log(`Tableau 3: ${flotteClonee}`);

    Partie 4: Conditions et structures de contrôle

    
const ennemySpaceShip = {
    name: "Ennemy Ship",
    damage: {
        type: "laser",
        amount: 10,
    }
};

const station = {
    name: "Station",
    health: 100,
};

const bonus = 5;
station.health -= ennemySpaceShip.damage.amount * bonus;

alert("Regardez la console pour voir les résultats");
if (station.health > 0) {
    if (station.health < 50) {
        console.log("Station is damaged");
    } else {
        console.log("Station is alive");
    }
} else {
    console.log("Station is Dead !!");
}

    Partie 5: Switch et gestion d'énergie

    
let stationEnergy = 300;
const damageType = {
    laser: 100,
    collision: 200,
    hacker: 150,
    none: "",
};

let damageTypePrompt = prompt("Entrez un type de dégat");
switch (damageTypePrompt) {
    case "laser":
        stationEnergy -= 100;
        alert(`Niveau d'énergie: ${stationEnergy}`);
        break;
    case "collision":
        stationEnergy -= 200;
        alert(`Niveau d'énergie: ${stationEnergy}`);
        break;
    case "hacker":
        stationEnergy -= 150;
        alert(`Niveau d'énergie: ${stationEnergy}`);
        break;
    default:
        alert("Commande de type invalide");
        break;
}

if (stationEnergy < 100) {
    alert("Alerte maximale !");
}

    Partie 6: Boucles et tableaux

    
stationLogs = ['Bienvenue', 'Bonsoir', "Bonne nuit"];

alert("Les messages vont s'afficher dans des alertes");
for (let i = 0; i < stationLogs.length; i++) {
    const reslog = alert(stationLogs[i]);
    console.log(reslog);
}

alert("Fin de transmission");

    Partie 7: Boucles avancées

    
// Exemple avec while
let damageType = prompt("Enter the damage type");
while (damageType !== "laser" && damageType !== "collision" && damageType !== "hacker") {
    damageType = prompt("Mauvaise saisie: ")                     
}

// OU avec tableau
const damageTypes = ["laser", "collision", "hacker"];
while(!damageTypes.includes(damageType)) {
    damageType = prompt("Bad damage type, please try again !!");
}

    Partie 8: Triangles avec boucle

    
// Triangle normal
for (let i = 0; i < 5; i++) {
    let charsign = "*";
    for (let j = 0; j < i; j++) {
        charsign += "*";
    } 
    console.log(charsign);
}

// Triangle inversé
for (let i = 5; i > 0; i--) {
    let charsign = "";
    for (let j = 0; j < i; j++) {
        charsign += "*";
    }
    console.log(charsign);
}

// Sapin
const rows = 5;
const char = "*";
const space = " ";

for (let i = 1; i <= rows; i++) {
    let row = "";
    for (let j = 1; j <= rows - i; j++) {
        row += space;
    }
    for (let k = 1; k <= 2 * i - 1; k++) {
        row += char;
    }
    console.log(row);
}