Introduction aux Variables C#

Les variables en C# servent à stocker des valeurs. Chaque variable a un type spécifique qui détermine la taille de la donnée stockée, la représentation de la donnée, et les opérations possibles. Pour bien maîtriser l’environnement de travail, vous pouvez en savoir plus sur l’introduction à C# et l’installation de Visual Studio. C# est un langage typé, ce qui signifie que le type de chaque variable doit être déclaré lors de sa déclaration. Découvrons les bases de la déclaration des variables et l’importance de choisir le bon type pour vos besoins.

// Exemple de déclaration de variables en C#
int age = 30;
string nom = "Alice";
double temperature = 36.6;
bool isMarried = true;

Types de Variables Primitives en C#

En C#, les types de variables prédéfinis sont généralement appelés types primitifs. Ils incluent les entiers, les booléens, les caractères, et les flottants. Pour mieux comprendre leur fonctionnement, explorez la structure et syntaxe en C#. Chaque type offre des propriétés uniques et est utilisé en fonction du type de données avec lequel vous travaillez.

int nombreEntier = 100;     // Stocke des nombres entiers
float nombreFlottant = 10.5f; // Stocke des nombres décimaux simples
char caractere = 'A';         // Stocke un unique caractère
bool resultat = false;        // Stocke un état vrai ou faux

Les Variables de Référence: Classes et Objets

Outre les variables primitives, C# permet l’utilisation de variables de référence qui pointent vers un emplacement mémoire où les données réelles sont stockées. Les objets, créés à partir de classes, sont des exemples de ces variables de référence. Cela est crucial dans la programmation orientée objet en C#. En travaillant avec des objets, vous pouvez encapsuler des données et des fonctionnalités, rendant votre code plus modulaire et réutilisable.

class Personne
{
    public string Prenom;
    public int Age;
}

Personne personne = new Personne();
personne.Prenom = "Bob";
personne.Age = 25;

Portée et Durée de Vie des Variables en C#

La portée et la durée de vie d’une variable font référence à l’endroit dans votre code où une variable est accessible et combien de temps elle reste en mémoire. Il est crucial de comprendre ces concepts pour éviter les erreurs de portée et les fuites de mémoire dans vos programmes.

void ExempleDeFonction()
{
    int variableLocale = 10; // Variable locale
    if (variableLocale > 0)
    {
        int variableInterne = 20; // Variable dans le bloc if
    }
    // variableInterne n'est PAS accessible ici
}
// variableLocale n'est PAS accessible ici

Constantes et Variables en Lecture Seule

Les constantes sont des variables dont la valeur est définie au moment de la compilation et ne peut pas changer. Pour comprendre comment elles se différencient d’autres structures, consultez le guide complet sur les mots-clés ref et out. En revanche, les variables en lecture seule (readonly) peuvent être initialisées à l’exécution mais ne peuvent plus être modifiées post-initialisation. Ces concepts sont utilisés pour sécuriser certaines valeurs critiques contre les modifications accidentelles.

const double PI = 3.14159; // Constante
readonly string cheminFichier = "/user/data.txt"; // Variable en lecture seule

En explorant les variables en C#, nous constatons qu’elles servent de pilier à la construction de programmes efficaces et structurés. Pour en apprendre davantage sur les variables en C#, la compréhension et l’utilisation adéquate des types de variable, de leur portée, et la distinction entre constantes et variables en lecture seule sont essentielles pour éviter les erreurs courantes et optimiser les performances. Pour approfondir vos connaissances sur la programmation en C#, consultez la documentation officielle sur Microsoft Learn ou explorez des cours pratiques sur le site de Coursera. Un bon savoir-faire dans ce domaine s’accompagne également de techniques d’optimisation, telles que l’exploration des méthodes principales en C#.

Conclusion sur les Variables C#

Comprendre l’utilisation des variables en C# est indispensable pour tout développeur ciblant le développement d’applications robustes. Grâce à leur capacité à stocker diverses données et à leur manipulation efficace, les variables constituent un élément essentiel de la programmation. Continuez à expérimenter et à explorer les divers aspects que C# a à offrir. Pour élargir vos horizons, nous vous recommandons de vous plonger dans des conversions de types. Poussez plus loin vos connaissances en participant à des communautés de développeurs et en explorant des projets ouverts pour vous améliorer continuellement.

L’article 2.2 Les Variables en C# : Utilisation et Guide Complet Indispensable est apparu en premier sur CodeSpace.

Introduction à la Structure Syntaxe C# Parfaite

En C#, une programme bien structuré démarre avec l’utilisation des namespaces, qui organisent votre code, suivie par des classes qui encapsulent les données et méthodes. Une syntaxe précise garantit des déclarations de variables claires, des fonctions bien conçues et des structures de contrôle qui façonnent une logique fluide dans votre application.

Compréhension des Namespaces et Classes en C#

Les namespaces C# sont essentiels pour organiser les bibliothèques. Généralement, un fichier C# commencera par la déclaration du namespace et la définition d’une ou plusieurs classes. Voyons un exemple :

using System;

namespace MonApplication
{
    class Programme
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Bonjour, Monde!");
        }
    }
}

Déclaration et Initialisation des Variables

En C#, il est impératif que les variables soient déclarées avec un type avant utilisation. Vous pouvez également les initialiser au moment de la déclaration :

int nombre = 10;
string message = "Salut";
double pi = 3.14159;
bool estVrai = true;

Utilisation des Structures de Contrôle

C# dispose de structures de contrôle comme les boucles et conditions pour réguler le flux :

int age = 18;

if (age >= 18)
{
    Console.WriteLine("Adulte.");
}
else
{
    Console.WriteLine("Mineur.");
}

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Numéro: " + i);
}

Définition et Utilisation des Fonctions

Les fonctions en C# partitionnent le code en petites unités pour une meilleure réutilisation :

using System;

namespace MonApplication
{
    class Programme
    {
        static void Main(string[] args)
        {
            Saluer("Alice");
        }

        static void Saluer(string nom)
        {
            Console.WriteLine("Bonjour, " + nom);
        }
    }
}

Pratiques Recommandées pour un Code C# Efficace

Élaborer un code C# efficace impose le respect des conventions, l'emploi de méthodes efficaces, et l'optimisation pour performance. Ces pratiques influencent largement la qualité finale du logiciel.

Conseils Avancés pour la Programmation C#

Pour améliorer encore davantage votre maîtrise du C#, envisagez les conseils suivants :

Gestion des Exceptions

L'utilisation de blocs try et catch est cruciale pour éviter les défaillances :

try
{
    int[] nombres = {1, 2, 3};
    Console.WriteLine(nombres[3]); // Provoque une exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("Erreur: " + ex.Message);
}

Utilisation des Interfaces

Les interfaces définissent des signatures de méthodes à respecter :

interface ITranportable
{
    void Deplacer();
}

class Voiture : ITranportable
{
    public void Deplacer()
    {
        Console.WriteLine("La voiture se déplace.");
    }
}

Structure Syntaxe C# : Conclusion

La Structure Syntaxe C# Parfaite permet à tout développeur de concevoir des applications performantes et maintenables. Ce guide présente les points clés d'un code structuré et les pratiques pour les incorporer dans vos projets C#. Continuez à explorer pour renforcer vos compétences et créer des applications innovantes.

L’article 2.1 Structure et Syntaxe Parfaite d’un Programme C# : Guide Détaillé est apparu en premier sur CodeSpace.

Découvrez Rapidement Visual Studio et Exécutez Votre Premier Programme

Visual Studio est un éditeur puissant qui facilite le développement d’applications grâce à son environnement intégré. Que vous soyez débutant ou professionnel, exécuter un programme sur Visual Studio peut marquer le début d’une expérience de codage enrichissante. Explorons ensemble comment configurer et utiliser cet outil renommé.

Introduction à Visual Studio

Visual Studio, conçu par Microsoft, est un environnement de développement intégré (IDE) qui vous permet de créer des applications pour Windows, Web, mobile, et plus encore. Il supporte diverses langues, telles que C#, C++, Python, et bien d’autres, offrant ainsi une flexibilité aux développeurs. Ce tutoriel vous guidera à travers les étapes nécessaires pour configurer Visual Studio et exécuter votre premier programme.

Visual Studio Découverte : TéLéChargement et Installation de Visual Studio

Pour commencer, téléchargez la dernière version de Visual Studio depuis le site officiel de Microsoft. Durant l’installation, vous aurez le choix d’ajouter des charges de travail pour spécifier les types de développement que vous souhaitez faire, tel que .NET desktop ou Python development.

Explorer notre guide détaillé sur l’installation de Visual Studio pour une assistance plus complète sur les processus d’installation et de configuration.

Création d’un Nouveau Projet

1. Lancement de Visual Studio: Ouvrez l’application et sélectionnez « Créer un nouveau projet ».
2. Choix du Modèle: Choisissez un modèle adapté à votre langage de programmation préféré. Par exemple, sélectionnez « Application Console » pour C#.
3. Configurer le Projet: Donnez un nom à votre projet, choisissez l’emplacement du fichier, et sélectionnez le framework ciblé.

Pour une vue plus approfondie, jetez un œil à notre tutoriel sur la découverte et l’exécution de projets Visual Studio.

Visual Studio Découverte : Écriture et Exécution de Votre Programme

Exemple Simple en C#

Une fois votre projet créé, Visual Studio ouvre un fichier Program.cs pré-rempli contenant un modèle de code standard.

using System;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Bonjour, Monde!");
        }
    }
}

1. Construire le Projet: Allez dans le menu « Build » et sélectionnez « Build Solution » pour compiler le programme.
2. Exécuter le Code: Cliquez sur « Start » ou appuyez sur F5 pour exécuter le programme. La console affichera « Bonjour, Monde! ».

Pour plus d’exemples et de détails sur la structure et la syntaxe du code C#, consultez notre guide sur la structure et la syntaxe C#.

Ajouter des Fonctionnalités à Votre Projet

Pour enrichir votre programme, explorez les bibliothèques disponibles via NuGet Package Manager, un outil intégré dans Visual Studio. Cela vous permettra d’ajouter de nouvelles fonctionnalités comme des outils de gestion de bases de données, des bibliothèques graphiques, etc.

Visitez notre guide complet sur l’utilisation des listes en C# pour découvrir comment intégrer des structures de données efficaces dans vos projets.

Conseils pour Maximiser l’Efficacité

• Utilisation des Raccourcis: Visual Studio offre une variété de raccourcis clavier pour augmenter votre productivité. Par exemple, Ctrl+K, Ctrl+C commente des lignes de code.
• Explorer les Extensions: Visitez Visual Studio Marketplace pour découvrir des extensions qui peuvent améliorer votre flux de travail, comme des outils pour le debugging ou des thèmes personnalisés.

Pour des astuces supplémentaires, explorez notre guide sur le polymorphisme en C# pour des techniques avancées de programmation.

Conclusion

La découverte de Visual Studio vous ouvre la porte à de nombreuses possibilités dans le développement logiciel. Que vous soyez un novice ou un développeur expérimenté, cet IDE puissant vous aidera à construire des projets robustes et polyvalents. Avec cet aperçu et ce guide pas à pas, vous êtes prêt à débuter dans le développement et à explorer les fonctionnalités infinies qu’il propose. Si vous souhaitez approfondir vos connaissances, visitez notre tutoriel avancé sur Visual Studio pour des compétences de niveau supérieur.

Pour plus d’informations, explorez notre guide sur la gestion des exceptions en C# pour manipuler efficacement les erreurs dans vos programmes.

L’article 1.3 Découverte Rapide de Visual Studio et Exécution de votre Programme est apparu en premier sur CodeSpace.

Introduction à Visual Studio Installation de Community

Visual Studio Community est une version gratuite et extensible de l’environnement de développement intégré (IDE) de Microsoft. Il est utilisé pour des développer des applications pour Windows, Android, iOS, le Web et le cloud. Découvrons comment l’installer simplement et rapidement.

Télécharger le Programme d’Installation de Visual Studio

Pour commencer, accédez à la page de téléchargement de Visual Studio Community. Cliquez sur le bouton “Télécharger” pour obtenir le programme d’installation. En outre, vous pouvez en apprendre plus sur les possibilités de Visual Studio pour C#.

# Commande non requise, téléchargement via navigateur

Lancer le Programme d’Installation

Une fois téléchargé, exécutez le programme d’installation. L’installateur va préparer votre système pour l’installation principale de Visual Studio. Pour savoir comment créer des projets C#, consultez notre guide détaillé sur la syntaxe C#.

Choisir les Composants à Installer

Après le lancement, vous aurez à choisir parmi les composants et les charges de travail disponibles. Voici quelques recommandations basées sur vos besoins :

• ASP.NET et développement web : Pour les projets web.
• Développement .NET de bureau : Pour créer des applications de bureau Windows.
• Développement mobile avec .NET : Si vous envisagez de développer pour Android ou iOS.
• Développement de jeux avec Unity : Pour les projets de gaming.

# Sélectionnez les charges de travail adéquates en fonction de votre projet

Installer Visual Studio Community

Une fois les composants sélectionnés, cliquez sur “Installer”. Le processus peut prendre quelques minutes, en fonction des composants choisis et de la vitesse de votre connexion Internet. Pour en savoir plus sur les fonctionnalités de Visual Studio, vous pouvez explorer notre introduction à l’interface Windows Forms.

Configuration Initiale lors de la Première Exécution

Après l’installation, démarrez Visual Studio. Il vous sera demandé de sélectionner un thème (tel que Clair ou Sombre) et de vous connecter avec un compte Microsoft pour débloquer toutes les fonctionnalités. Pour mieux comprendre cette étape, vous pouvez consulter la personnalisation de la console avec C#.

# Lancez Visual Studio et configurez selon vos préférences

Explorer Visual Studio Community

Maintenant que Visual Studio Community est installé, prenez le temps d’explorer l’interface utilisateur. Familiarisez-vous avec les solutions, les projets, et les divers outils disponibles pour maximiser votre efficacité. L’exploration de concepts comme l’introduction à la POO en C# peut grandement améliorer votre productivité.

Conclusion

L’installation de Visual Studio Community vous prépare à entreprendre des projets ambitieux dans un environnement de développement complet et intuitif. Que vous travailliez sur des applications de bureau, mobiles ou web, cet IDE offre une solution adaptée à de nombreuses exigences. Continuez à explorer les ressources et tutoriels en ligne pour perfectionner votre usage de cet outil puissant. Pour améliorer encore vos compétences, envisagez de suivre notre formation C# sur Learnify.

L’article 1.2 Installation Facile de Visual Studio Community (IDE) en Détails est apparu en premier sur CodeSpace.

Pourquoi Apprendre le C# ?

C# (prononcé C-Sharp) est un langage de programmation moderne orienté objet, développé par Microsoft. Sa polyvalence et sa robustesse le rendent idéal pour développer des applications de bureau, web, et mobiles. De plus, grâce à sa popularité dans l’environnement Windows, il bénéficie d’une large communauté et de nombreux outils de développement. Il est particulièrement apprécié pour sa clarté et sa capacité à gérer des projets de grande échelle efficacement.

Commencer avec le C#

Pour débuter avec C#, il est essentiel de se familiariser avec un environnement de développement intégré (IDE) comme Visual Studio, abordé en détail dans cet article. Une fois installé, vous pouvez créer votre premier projet en suivant ces étapes :

Installer Visual Studio

Visual Studio est un IDE complet offrant un support exceptionnel pour le développement en C#. Téléchargez et installez la version Community gratuite pour accéder à une multitude de fonctionnalités professionnelles. Pour une aide détaillée sur l’installation et la configuration initiale, consultez notre guide sur Visual Studio.

Créer un Nouveau Projet C#

Une fois Visual Studio installé, suivez ces étapes pour créer un projet console :

// Exemple de création d'un projet console simple en C#
using System;

namespace HelloWorldApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Bonjour, monde !");
        }
    }
}

Comprendre les Concepts de Base

Le C# est riche en fonctionnalités. Voici quelques concepts clés qui seront essentiels pour votre progression, comme expliqués dans notre guide détaillé sur la syntaxe et les structures C# :

• Variables : Stockent des informations pour être utilisées dans votre programme. Ex : int, string, bool.
• Structures de contrôle : Orientez le flux de votre programme avec les conditions (if, switch) et les boucles (for, while). Découvrez plus sur les instructions conditionnelles.
• Fonctions : Encapsulent des blocs de code pour une réutilisation facile, un aspect crucial documenté ici.

Exemple Pratique : Calculatrice de Base

Pour illustrer ces concepts, créons une calculatrice simple qui mettra en avant les opérations arithmétiques :

// Calculatrice simple en C#
using System;

namespace BasicCalculator
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Entrez le premier numéro:");
            double num1 = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("Entrez le second numéro:");
            double num2 = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("Choisissez une opération (+, -, *, /):");
            char operation = Console.ReadLine()[0];

            double result = 0;

            switch (operation)
            {
                case '+':
                    result = num1 + num2;
                    break;
                case '-':
                    result = num1 - num2;
                    break;
                case '*':
                    result = num1 * num2;
                    break;
                case '/':
                    result = num2 != 0 ? num1 / num2 : double.NaN; // Gérer la division par zéro
                    break;
                default:
                    Console.WriteLine("Opération invalide.");
                    break;
            }

            Console.WriteLine($"Le résultat est: {result}");
        }
    }
}

En pratiquant ces exemples, vous commencerez à comprendre comment structurer le code en C# et à utiliser les différents types de données et structures de contrôle. Explorez aussi les tableaux en C# pour un stockage et une manipulation de données plus efficaces. Cette base solide vous aidera à explorer des concepts plus avancés comme la programmation asynchrone, la gestion des exceptions, et le développement d’applications graphiques.

Pour approfondir, visitez également des ressources externes telles que Microsoft Learn, ainsi que des plateformes d’apprentissage comme Udemy et Codecademy pour des tutoriels interactifs.

Conclusion : Maîtriser le C# Introduction

Le C# est un langage extrêmement puissant, utilisé dans de nombreux domaines du développement logiciel. En apprenant ses fondamentaux, vous vous donnez les outils nécessaires pour développer des applications robustes et interactives. Continuez à expérimenter, et explorez davantage les bibliothèques et les frameworks associés à C# pour maximiser votre potentiel. Pour un apprentissage structuré, pensez à suivre un cours complet tel que celui proposé par Learnify, qui offre maintenant une réduction considérable. Bénéficiez de l’expertise de nos formateurs pour naviguer facilement dans le monde de la programmation C#.

L’article 1.1 Introduction au C-Sharp : Guide Complet et Explications est apparu en premier sur CodeSpace.

Introduction à setTimeout et setInterval

setTimeout et setInterval sont des méthodes JavaScript utilisées pour exécuter du code après un délai spécifié ou de manière répétée respectivement. setTimeout permet de planifier l’exécution d’une fonction une seule fois après une période donnée, tandis que setInterval exécute une fonction répétitivement à un intervalle de temps spécifié.

Utiliser setTimeout pour Différer l’Exécution

La fonction setTimeout prend en entrée une fonction et un délai en millisecondes. Elle exécute la fonction après le délai spécifié :

function sayHello() {
    console.log('Hello, world!');
}

// Exécuter la fonction après 2000 millisecondes (2 secondes)
setTimeout(sayHello, 2000);

Utiliser setInterval pour Répéter une Tâche

setInterval fonctionne de manière similaire à setTimeout, mais elle exécute la fonction de manière répétée à intervalles réguliers :

function displayTime() {
    console.log('Current time: ' + new Date().toLocaleTimeString());
}

// Exécuter la fonction toutes les 1000 millisecondes (1 seconde)
setInterval(displayTime, 1000);

Annuler les Tâches Planifiées avec clearTimeout et clearInterval

Vous pouvez annuler une tâche planifiée à l’aide de clearTimeout ou clearInterval. Ces fonctions prennent en argument le timer renvoyé par setTimeout ou setInterval :

// Planifier une tâche
let timeoutId = setTimeout(function() {
    console.log('This will not be logged');
}, 5000);

// Annuler la tâche planifiée
clearTimeout(timeoutId);

// Planifier une tâche répétée
let intervalId = setInterval(function() {
    console.log('This will not be logged after clearInterval is called');
}, 1000);

// Annuler la tâche répétée
clearInterval(intervalId);

Gestion des Tâches Asynchrones Complexes avec setTimeout et setInterval

Vous pouvez également utiliser ces fonctions pour gérer des tâches asynchrones plus complexes. Par exemple, pour créer une animation ou pour effectuer des requêtes périodiques à un serveur :

function startAnimation() {
    let element = document.getElementById('movingElement');
    let position = 0;
    let increment = 1;

    function move() {
        position += increment;
        element.style.left = position + 'px';

        if (position >= 100 || position <= 0) {
            increment = -increment; // Inverser le mouvement
        }

        timeoutId = setTimeout(move, 10);
    }

    move();
}

// Commencer l'animation
startAnimation();

Réaliser une Animation Simple avec setTimeout

Utilisons setTimeout pour créer une animation simple qui déplace un élément sur la page :

document.addEventListener('DOMContentLoaded', function() {
    const element = document.getElementById('animate');
    let position = 0;

    function animate() {
        position += 1;
        element.style.left = position + 'px';

        if (position < 200) {
            setTimeout(animate, 10);
        }
    }

    animate();
});

Utiliser setInterval pour Mettre à Jour une Interface de Façon Récurrente

Pour des mises à jour récurrentes de l'interface utilisateur, setInterval est plus appropriate. Par exemple, pour afficher une horloge en temps réel :

document.addEventListener('DOMContentLoaded', function() {
    const clock = document.getElementById('clock');

    function updateClock() {
        clock.textContent = new Date().toLocaleTimeString();
    }

    setInterval(updateClock, 1000); // Mise à jour chaque seconde
});

Exemples Avancés d'Utilisation de setTimeout et setInterval

Pour vous permettre d'approfondir l'usage de setTimeout et setInterval, voici quelques exemples avancés d'utilisation.

Planifier des Requêtes HTTP Répétées

Vous pouvez utiliser setInterval pour effectuer des requêtes HTTP répétées à un serveur afin de récupérer des données périodiquement :

function fetchData() {
    fetch('https://api.example.com/data')
        .then(response => response.json())
        .then(data => {
            console.log('Data fetched:', data);
        })
        .catch(error => console.error('Error fetching data:', error));
}

// Récupérer les données toutes les 5 secondes
setInterval(fetchData, 5000);

Création d'un Diaporama avec setTimeout

Créer un diaporama d'images avec des délais entre chaque changement d'image :

const images = ['image1.jpg', 'image2.jpg', 'image3.jpg'];
let currentIndex = 0;

function showNextImage() {
    const imgElement = document.getElementById('slideshowImage');
    imgElement.src = images[currentIndex];
    currentIndex = (currentIndex + 1) % images.length;
    setTimeout(showNextImage, 3000); // Changer d'image toutes les 3 secondes
}

document.addEventListener('DOMContentLoaded', function() {
    showNextImage();
});

En poursuivant votre exploration des méthodes setTimeout et setInterval, vous pouvez également consulter des ressources externes pour élargir votre compréhension. Par exemple, le guide de MDN Web Docs sur setTimeout et MDN Web Docs sur setInterval offrent une couverture exhaustive des usages et des meilleurs pratiques. Vous pouvez également suivre des cours en ligne sur des plateformes comme Udemy pour un apprentissage structuré.

Intégration de setTimeout et setInterval avec d'autres Fonctions

L'utilisation efficace de setTimeout et setInterval n'est qu'une partie de l'histoire du travail asynchrone en JavaScript. Par exemple, vous pouvez combiner ces fonctions avec des fonctions intéressantes pour le DOM en JavaScript pour ajouter ou modifier des éléments du DOM de manière répétée, ou encore utiliser des callbacks pour effectuer des opérations après la fin des minuteries.

Exécution Récurrente pour Mettre à Jour des

L’article 14.6 Planifier Script en JavaScript : setTimeout, setInterval est apparu en premier sur CodeSpace.

]]> https://wikiform.fr/codespace/planifier-script-en-javascript-settimeout-setinterval/feed/ 0 https://wikiform.fr/codespace/gerer-propagation-evenements-en-javascript/ https://wikiform.fr/codespace/gerer-propagation-evenements-en-javascript/#respond Thu, 29 Aug 2024 03:23:59 +0000 https://wikiform.fr/codespace/gerer-propagation-evenements-en-javascript/ Propager les Évènements en JavaScript est crucial pour développer des interfaces web interactives et performantes. Maîtriser les concepts de propagation des évènements et savoir les...

L’article 14.5 Gérer Propagation des Évènements en JavaScript est apparu en premier sur CodeSpace.

]]> Propager les Évènements en JavaScript est crucial pour développer des interfaces web interactives et performantes. Maîtriser les concepts de propagation des évènements et savoir les contrôler peut significativement améliorer l’expérience utilisateur. Apprenons ensemble comment cela fonctionne et comment l’implémenter au travers d’exemples concrets de code.

Introduction à la Propagation des Évènements en JavaScript

Profitez de l’offre spéciale !

Obtenez notre cours pour seulement 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Cours spécial à 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

En JavaScript, la propagation des évènements désigne le chemin suivi par un évènement depuis son déclenchement jusqu’à sa phase finale dans le DOM. Comprendre ce processus permet de mieux gérer la manipulation et l’interception des évènements afin de personnaliser le comportement de votre application. Pour une meilleure compréhension des concepts fondamentaux de JavaScript, consultez notre section sur Qu’est-ce que JavaScript : Explications et Définitions.

Les Phases de la Propagation des Évènements

La propagation des évènements en JavaScript se déroule en trois phases :

1. Capture : L’évènement traverse le DOM depuis la racine jusqu’à l’élément cible.
2. Target : L’évènement atteint l’élément cible.
3. Bubbling : L’évènement remonte de l’élément cible vers la racine du DOM.

Exemple Pratique de Propagation des Évènements

Considérons un exemple simple avec des éléments imbriqués ayant des gestionnaires d’évènements :

<div id="parent">
  <button id="child">Click Me</button>
</div>

<script>
document.getElementById('parent').addEventListener('click', function() {
  console.log('Parent clicked');
});

document.getElementById('child').addEventListener('click', function() {
  console.log('Child clicked');
});
</script>

Dans cet exemple, lorsque le bouton est cliqué, les messages « Child clicked » et « Parent clicked » s’affichent dans la console. Cela est dû au mécanisme de propagation, où l’évènement se propage du bouton (cible) jusqu’à l’élément parent. Le mécanisme de propagation des évènements est une fonctionnalité puissante qui peut être exploitée de différentes manières dans JavaScript.

Prévenir la Propagation en JavaScript

Parfois, il peut être nécessaire d’arrêter la propagation pour prévenir certains comportements indésirables. Utilisez les méthodes stopPropagation() ou stopImmediatePropagation() :

<div id="parent">
  <button id="child">Click Me</button>
</div>

<script>
document.getElementById('parent').addEventListener('click', function() {
  console.log('Parent clicked');
});

document.getElementById('child').addEventListener('click', function(event) {
  console.log('Child clicked');
  event.stopPropagation();  // Empêche la propagation vers l'élément parent
});
</script>

Avec l’utilisation de event.stopPropagation(), seul le message « Child clicked » s’affichera dans la console lors du clic sur le bouton, car la propagation vers le parent est arrêtée. Pour mieux comprendre comment gérer la propagation et bien d’autres fonctionnalités en JavaScript, explorez notre guide Utiliser les Écouteurs d’Évènements en JavaScript.

Gestion de la Capture des Évènements

Pour gérer les évènements lors de la phase de capture, il suffit de spécifier le troisième argument de addEventListener en tant que true :

<div id="parent">
  <button id="child">Click Me</button>
</div>

<script>
document.getElementById('parent').addEventListener('click', function() {
  console.log('Parent clicked');
}, true);  // Écoute de l'évènement pendant la phase de capture

document.getElementById('child').addEventListener('click', function(event) {
  console.log('Child clicked');
});
</script>

En définissant ce troisième argument à true, le gestionnaire d’évènements du parent se déclenchera pendant la phase de capture, avant celui de l’enfant. En savoir plus sur les différentes phases de la propagation en consultant notre guide détaillé sur l’Objet Window dans le BOM en JavaScript.

Utilisation Pratique : Éviter les Doublons de Clics

Supposons que vous ayez un formulaire avec un bouton de soumission, et vous voulez éviter des soumissions multiples accidentelles. Voici comment vous pouvez y parvenir :

<form id="myForm">
  <input type="text" name="textInput" />
  <button type="submit">Submit</button>
</form>

<script>
document.getElementById('myForm').addEventListener('submit', function(event) {
  event.preventDefault();  // Prévenir la soumission par défaut
  console.log('Form submitted');
  // Désactiver le bouton pour éviter des clics multiples
  event.target.querySelector('button[type="submit"]').disabled = true;
});
</script>

Dans ce code, le bouton de soumission est désactivé dès que le formulaire est soumis, évitant ainsi les soumissions multiples accidentelles. Pour d’autres astuces et considérations pratiques en JavaScript, consultez notre tutoriel sur Placer du Code JavaScript – Guide Pratique.

Gestion Globale des Évènements avec Délégation

La délégation d’évènements est une technique puissante pour améliorer la performance, surtout lorsque vous avez beaucoup d’éléments dynamiques. Plutôt que d’attacher des évènements à chaque élément individuellement, vous les attachez à un parent commun. Exemple :

<ul id="itemList">
  <li>Item 1</li>
  <li>Item 2</li>
  <li>Item 3</li>
</ul>

<script>
document.getElementById('itemList').addEventListener('click', function(event) {
  if (event.target.tagName === 'LI') {
    console.log('Item clicked:', event.target.textContent);
  }
});
</script>

Ici, en attachant un gestionnaire d’évènements au ul, tous les li en héritent. Cela est particulièrement utile pour les listes dynamiques. Pour en savoir plus sur ce concept, explorez notre section sur les évènements en JavaScript.

Conclusion sur la Propagation Évènements JavaScript

La gestion de la propagation des évènements en JavaScript est indispensable pour contrôler le flux des interactions utilisateur dans le DOM. Comprendre les phases de propagation et savoir comment les contrôler via des méthodes comme stopPropagation, ou addEventListener avec capture, permet de construire des applications web robustes et performantes. Continuez à explorer ces concepts avec des exemples pratiques et adaptez-les à vos projets pour une interactivité optimisée.

Pour plus d’informations sur le fonctionnement de JavaScript au-delà des évènements, consultez notre guide sur les Variables en JavaScript et apprenez comment Déclarer des Variables avec let, const et var.

L’article 14.5 Gérer Propagation des Évènements en JavaScript est apparu en premier sur CodeSpace.

]]> https://wikiform.fr/codespace/gerer-propagation-evenements-en-javascript/feed/ 0 https://wikiform.fr/codespace/ecouteurs-par-gestionnaire-evenements-en-javascript/ https://wikiform.fr/codespace/ecouteurs-par-gestionnaire-evenements-en-javascript/#respond Thu, 29 Aug 2024 03:20:17 +0000 https://wikiform.fr/codespace/ecouteurs-par-gestionnaire-evenements-en-javascript/ 14.4 Écouteurs par Gestionnaire d’Évènements en JavaScript sont essentiels pour créer des interactions dynamiques et réactives dans vos applications web. Savoir comment les mettre en...

L’article 14.4 Écouteurs par Gestionnaire d’Évènements en JavaScript est apparu en premier sur CodeSpace.

]]> 14.4 Écouteurs par Gestionnaire d’Évènements en JavaScript sont essentiels pour créer des interactions dynamiques et réactives dans vos applications web. Savoir comment les mettre en place et les utiliser avec efficacité peut considérablement améliorer l’expérience utilisateur. Explorons leur fonctionnement et leur utilisation à travers des exemples concrets de code.

Introduction aux Écouteurs par Gestionnaire d’Évènements en JavaScript

Profitez de l’offre spéciale !

Obtenez notre cours pour seulement 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Cours spécial à 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

En JavaScript, un écouteur d’évènement (event listener) est un moyen de surveiller les interactions utilisateur comme les clics, les survols de souris, les frappes clavier, etc. Lorsque l’évènement se produit, toutes les fonctions de rappel enregistrées (callbacks) sont automatiquement déclenchées, permettant de réagir aux actions de l’utilisateur de manière dynamique.

Ajouter des Écouteurs d’Évènements en JavaScript

Commençons par ajouter un écouteur d’évènement à un élément HTML. JavaScript propose des méthodes telles que addEventListener pour attacher des gestionnaires d’évènements. Voici un exemple simple :

// Sélectionner l'élément
const button = document.querySelector("button");

// Ajouter un écouteur pour l'évènement 'click'
button.addEventListener("click", function() {
    alert("Bouton cliqué!");
});

Gestionnaire Évènements Souris – Avantages et Utilisations

Les évènements de souris sont parmi les plus couramment utilisés comme click, mouseover, mouseout et mousemove. Ils permettent de rendre une page web plus interactive et réactive aux actions utilisateur. Voici comment les utiliser :

// Sélectionner l'élément
const div = document.querySelector("div");

// Ajouter un écouteur pour l'évènement 'mouseover'
div.addEventListener("mouseover", function() {
    div.style.backgroundColor = "lightblue";
});

// Ajouter un écouteur pour l'évènement 'mouseout'
div.addEventListener("mouseout", function() {
    div.style.backgroundColor = "";
});

Gestionnaire Évènements Clavier

Les évènements clavier comme keydown, keyup et keypress sont très utiles pour les interactions utilisateur dans les formulaires ou les raccourcis clavier. Ces évènements permettent une interaction plus fluide avec l’utilisateur finale.

// Sélectionner l'élément de saisie
const input = document.querySelector("input");

// Ajouter un écouteur pour l'évènement 'keydown'
input.addEventListener("keydown", function(event) {
    console.log("Touche appuyée: " + event.key);
});

Gestionnaire Évènements Formulaire – Validation en Temps Réel

Les écouteurs d’évènements sont essentiels pour la gestion des formulaires, en particulier pour la validation en temps réel. Voyons comment valider une entrée d’email sur l’évènement input :

// Sélectionner l'entrée et le message
const emailInput = document.querySelector("#email");
const message = document.querySelector("#message");

// Ajouter un écouteur pour l'évènement 'input'
emailInput.addEventListener("input", function() {
    const email = emailInput.value;
    
    if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
        message.textContent = "Adresse email valide";
        message.style.color = "green";
    } else {
        message.textContent = "Adresse email invalide";
        message.style.color = "red";
    }
});

Écouter des Évènements Personnalisés

JavaScript permet également de créer et d’écouter des évènements personnalisés pour des interactions plus spécifiques dans des applications complexes :

// Créer un nouvel évènement
const customEvent = new Event('monEvenement');

// Sélectionner l'élément
const elem = document.querySelector("div");

// Ajouter un écouteur pour l'évènement personnalisé
elem.addEventListener('monEvenement', function() {
    console.log("Mon évènement personnalisé a été déclenché");
});

// Déclencher l'évènement personnalisé
elem.dispatchEvent(customEvent);

Conclusion

Les écouteurs par gestionnaire d’évènements en JavaScript sont une technique puissante pour rendre vos applications web plus dynamiques et interactives. En surveillant les interactions utilisateur, vous pouvez facilement mettre à jour l’interface utilisateur, valider les entrées en temps réel et exécuter des actions spécifiques. Continuez à explorer JavaScript pour maîtriser davantage les évènements et autres fonctionnalités avancées. Pour plus de tutoriels sur JavaScript, consultez notre article sur les fonctionnalités intermédiaires et avancées de JavaScript. Si vous êtes débutant, découvrir les bases de JavaScript peut être un bon point de départ. Enfin, pour maîtriser les outils nécessaires, voyez notre ressource sur les meilleurs logiciels pour JavaScript.

L’article 14.4 Écouteurs par Gestionnaire d’Évènements en JavaScript est apparu en premier sur CodeSpace.

]]> https://wikiform.fr/codespace/ecouteurs-par-gestionnaire-evenements-en-javascript/feed/ 0 https://wikiform.fr/codespace/ecouteurs-par-proprietes-en-javascript-guide/ https://wikiform.fr/codespace/ecouteurs-par-proprietes-en-javascript-guide/#respond Thu, 29 Aug 2024 03:15:53 +0000 https://wikiform.fr/codespace/ecouteurs-par-proprietes-en-javascript-guide/ Les écouteurs par propriétés en JavaScript sont des outils essentiels pour créer des applications web interactives et dynamiques. Comprendre comment les utiliser et les mettre...

L’article 14.3 Écouteurs par Propriétés en JavaScript : Guide est apparu en premier sur CodeSpace.

]]> Les écouteurs par propriétés en JavaScript sont des outils essentiels pour créer des applications web interactives et dynamiques. Comprendre comment les utiliser et les mettre en place peut considérablement améliorer l’expérience de vos utilisateurs et rendre votre code plus réactif. Dans cet article, nous allons explorer les écouteurs par propriétés en JavaScript, leur fonctionnement et comment les implémenter dans vos projets grâce à des exemples pratiques.

Introduction aux Écouteurs par Propriétés en JavaScript

Profitez de l’offre spéciale !

Obtenez notre cours pour seulement 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Cours spécial à 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Les écouteurs par propriétés en JavaScript permettent de détecter et de réagir aux changements de valeurs des propriétés d’objets. Cela est particulièrement utile pour les applications réactives et les interfaces utilisateur dynamiques, où le changement d’une propriété peut déclencher des mises à jour ou des actions spécifiques.
Voyons maintenant comment les implémenter avec la méthode Object.defineProperty() et le proxy JavaScript.

Utilisation de Object.defineProperty()

La méthode Object.defineProperty() permet de définir une nouvelle propriété sur un objet ou de modifier une propriété existante. Voici comment vous pouvez l’utiliser pour ajouter un écouteur à une propriété :

let person = {
  name: 'John'
};

Object.defineProperty(person, 'name', {
  get() {
    return this._name;
  },
  set(value) {
    this._name = value;
    console.log(`La propriété name a été changée en : ${value}`);
  }
});

// Modifier la propriété pour voir l'effet
person.name = 'Doe';  // Console: La propriété name a été changée en : Doe

Utilisation des Proxies

Les proxies en JavaScript offrent une manière plus flexible et puissante de surveiller et d’intercepter les opérations sur des objets. Voici un exemple d’utilisation des proxies pour ajouter un écouteur à une propriété :

const handler = {
  set(target, property, value) {
    console.log(`La propriété ${property} a été changée en : ${value}`);
    target[property] = value;
    return true; // Indique que la valeur a été assignée avec succès
  }
};

const person = new Proxy({}, handler);

// Modifier la propriété pour voir l'effet
person.name = 'Smith';  // Console: La propriété name a été changée en : Smith

Créer des Écouteurs Complexes

En utilisant des proxies, vous pouvez créer des écouteurs plus complexes qui réagissent à des conditions spécifiques ou qui déclenchent plusieurs actions. Voici un exemple avancé :

const handler = {
  set(target, property, value) {
    if (property === 'age' && typeof value !== 'number') {
      throw new TypeError('La propriété age doit être un nombre');
    }
    console.log(`La propriété ${property} a été changée en : ${value}`);
    if (property === 'age' && value < 18) {
      console.log('Attention : l\'âge doit être supérieur ou égal à 18');
    }
    target[property] = value;
    return true;
  }
};
const person = new Proxy({}, handler);
try {
  person.age = 17;  // Console: La propriété age a été changée en : 17 et Attention : l'âge doit être supérieur ou égal à 18
} catch (err) {
  console.error(err.message);
}
try {
  person.age = 'not a number';  // Console: Uncaught TypeError: La propriété age doit être un nombre
} catch (err) {
  console.error(err.message);
}

Conclusion

Les écouteurs par propriétés en JavaScript sont des outils puissants pour rendre vos applications plus réactives et dynamiques. En utilisant les méthodes Object.defineProperty() et Proxy, vous pouvez facilement surveiller et réagir aux changements de propriétés. Ces techniques sont essentielles pour créer des interfaces utilisateur modernes et efficaces.
Pour aller plus loin et approfondir vos connaissances, consultez les ressources disponibles en ligne et expérimentez avec vos propres projets. Pour plus de tutoriels et de cours sur JavaScript, visitez notre page de formation JavaScript.

Pour vraiment comprendre les propriétés JavaScript, il est également utile d'apprendre des concepts connexes tels que qu'est-ce qu'une variable en JavaScript et comment déclarer des variables en JavaScript. Ces bases vous permettront de mieux maîtriser la manipulation des données dans vos applications.

Coder en JavaScript ne se limite pas seulement à la gestion des propriétés. Il est également important de savoir afficher des informations en JavaScript et d'apprendre la gestion des événements pour rendre vos applications plus interactives.

Pour ceux désireux d'aller plus loin, l'apprentissage des techniques de gestion des exceptions en JavaScript ainsi que l'usage des balises HTML appropriées optimiseront votre code.

Comprendre les propriétés JavaScript ouvre la porte à tant de possibilités dans le développement web. Pour ceux qui souhaitent explorer davantage, il est conseillé de se pencher sur l'utilisation du débogueur en JavaScript pour perfectionner leurs compétences.

L’article 14.3 Écouteurs par Propriétés en JavaScript : Guide est apparu en premier sur CodeSpace.

]]> https://wikiform.fr/codespace/ecouteurs-par-proprietes-en-javascript-guide/feed/ 0 https://wikiform.fr/codespace/utiliser-ecouteurs-evenements-en-javascript-onclick/ https://wikiform.fr/codespace/utiliser-ecouteurs-evenements-en-javascript-onclick/#respond Thu, 29 Aug 2024 03:12:35 +0000 https://wikiform.fr/codespace/utiliser-ecouteurs-evenements-en-javascript-onclick/ Utiliser les Écouteurs d’Évènements en JavaScript permet de rendre vos pages web plus dynamiques et interactives. Comprendre comment ajouter et gérer les écouteurs d’évènements vous...

L’article 14.2 Utiliser Écouteurs d’Évènements en JavaScript : onclick est apparu en premier sur CodeSpace.

]]> Utiliser les Écouteurs d’Évènements en JavaScript permet de rendre vos pages web plus dynamiques et interactives. Comprendre comment ajouter et gérer les écouteurs d’évènements vous aidera à réagir aux actions des utilisateurs efficacement. Apprenons comment ils fonctionnent et comment les implémenter avec des exemples de code concrets.

Introduction aux Écouteurs d’Évènements en JavaScript

Profitez de l’offre spéciale !

Obtenez notre cours pour seulement 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Cours spécial à 29.5€ au lieu de 59€ !

Commencer maintenant Fermer

Les écouteurs d’évènements JavaScript sont une fonction JavaScript qui attend un évènement spécifique, comme un clic, une pression de touche ou un mouvement de souris, et exécute une action lorsqu’il se produit. Les écouteurs d’évènements sont très puissants pour rendre une page web interactive et réactive.

Ajouter un Écouteur d’Évènement avec `addEventListener`

Pour ajouter un écouteur d’évènement à un élément HTML, on utilise la méthode `addEventListener`. Cette méthode permet d’attacher une fonction qui sera exécutée lorsque l’évènement spécifié se produit. Voici un exemple simple :

document.getElementById("myButton").addEventListener("click", function() {
  alert("Bouton cliqué!");
});

Réagir aux Évènements de la Souris

Les évènements de la souris, comme `click`, `mouseover`, et `mouseout`, peuvent être utilisés pour rendre une page web interactive. Voyons comment utiliser ces évènements :

const divElement = document.getElementById("hoverDiv");

divElement.addEventListener("mouseover", function() {
  divElement.style.backgroundColor = "lightblue";
});

divElement.addEventListener("mouseout", function() {
  divElement.style.backgroundColor = "white";
});

Utiliser les Écouteurs d’Évènements pour Validation de Formulaire

Les écouteurs d’évènements sont très utiles pour valider les formulaires en temps réel. Voici un exemple où nous vérifions si une adresse email est valide lorsque l’utilisateur tape :

document.getElementById("emailInput").addEventListener("input", function() {
  const email = document.getElementById("emailInput").value;
  const feedback = document.getElementById("emailFeedback");
  
  if (email.includes("@") && email.includes(".")) {
    feedback.textContent = "Email valide!";
    feedback.style.color = "green";
  } else {
    feedback.textContent = "Email non valide!";
    feedback.style.color = "red";
  }
});

Délégation d’Évènements pour Éléments Dynamique

Lorsque vous avez des éléments dynamiques ajoutés au DOM, il est préférable d’utiliser la délégation d’évènements. Cela signifie attacher un écouteur d’évènement à un élément parent pour gérer des évènements de ses éléments enfants :

document.getElementById("parentElement").addEventListener("click", function(event) {
  if (event.target && event.target.matches("li.item")) {
    alert("Un élément de la liste a été cliqué!");
  }
});

Gérer les Évènements Claviers

Les évènements liés au clavier, tels que `keydown` et `keyup`, peuvent être utilisés pour implémenter des raccourcis clavier ou des jeux. Voyons un exemple simple :

document.addEventListener("keydown", function(event) {
  if (event.key === "ArrowUp") {
    console.log("Flèche vers le haut pressée!");
  }
});

Conclusion

Utiliser les écouteurs d’évènements en JavaScript est essentiel pour rendre vos pages web plus interactives et réactives. En comprenant comment ajouter et gérer ces écouteurs, vous pouvez facilement capturer et répondre aux actions des utilisateurs. Continuez à explorer JavaScript pour découvrir plus de fonctionnalités et de techniques avancées. Pour plus de tutoriels sur JavaScript, consultez notre article sur les fondamentaux de JavaScript. Pour apprendre à manipuler le DOM avec JavaScript, lisez notre tutoriel détaillé.

Écouteurs JavaScript pour les Évènements sur Mobile

Les écouteurs d’évènements en JavaScript ne se limitent pas aux interactions avec une souris ou un clavier. Sur les devices mobiles, vous pouvez utiliser des écouteurs d’évènements pour des actions comme le touchstart, touchmove, touchend et touchcancel. Voici un exemple d’utilisation :

document.getElementById("mobileDiv").addEventListener("touchstart", function(event) {
    console.log("Écran touché!");
});

Pour plus d’informations sur la manipulation d’évènements en JavaScript sur mobile, découvrez notre guide sur les écouteurs d’évènements onclick en JavaScript.

Gérer les Évènements Asynchrones en JavaScript

Un autre aspect important des écouteurs JavaScript consiste à gérer les évènements asynchrones. Par exemple, attendre la fin de chargement d’une image ou la réponse d’une requête AJAX. Voici un exemple de gestion d’un évènement async :

document.getElementById("imageToLoad").addEventListener("load", function() {
    console.log("Image chargée avec succès!");
});

Optimiser la Performance des Écouteurs d’Évènements

Avec un grand nombre d’écouteurs d’évènements sur une page, il peut y avoir des impacts sur les performances. Il est recommandé d’utiliser la délégation d’évènements pour minimiser le nombre d’écouteurs attachés. La fonction removeEventListener est également utile pour éliminer des écouteurs lorsqu’ils ne sont plus nécessaires.

Pour des détails pratiques et des conseils, lisez notre article complet sur la gestion de la propagation des évènements en JavaScript.

Écouteurs d’Évènements dans les Projets Réels

Employer les écouteurs JavaScript est crucial lors de la réalisation de projets web. Par exemple, si vous développez une calculatrice en JavaScript, vous aurez besoin d’écouteurs pour capturer les entrées de l’utilisateur. Mais également dans d’autres applications comme les jeux, les applications de chat, ou les tableaux de bord interactifs.

const keys = document.querySelectorAll('.key');

keys.forEach(key => {
  key.addEventListener('click', function(event) {
    console.log('Touche cliquée:', event.target.textContent);
  });
});

Explorer plus en JavaScript

Pour continuer votre apprentissage en JavaScript, nous vous recommandons de consulter nos autres articles, comme qu’est-ce qu’une variable en JavaScript, pour des bases solides. Pour des projets plus complexes, explorez les boîtes de dialogue en JavaScript ou l’affichage d’informations en JavaScript.

Conclusion

En utilisant correctement les écouteurs d’évènements en JavaScript, vous pouvez créer des interfaces utilisateur hautement interactives et dynamiques. Cela rend vos pages web bien plus attrayantes et usables. Pour approfondir vos connaissances, n’hésitez pas à suivre notre formation disponible sur Learnify.

14.2 Utiliser Écouteurs d’Évènements en JavaScript : onclick est apparu en premier sur CodeSpace.

]]> https://wikiform.fr/codespace/utiliser-ecouteurs-evenements-en-javascript-onclick/feed/ 0