Les bases de javascript. Introduction au langage javascript. Les boucles, les fonctions, scope local et global. Accès et modification des éléments du Dom (Document object model)
Objectif général : Prendre en main l’une des bibliothèques JavaScript les plus utilisés pour créer des interfaces utilisateurs
Objectifs spécifiques :
Découper l’interface utilisateur avec les composants;
Configurer les composants avec « props »;
Gérer l’état local d’un composant avec « state »;
Afficher une listes de composants avec map();
Afficher un composant en fonction de l’état de l’application;
Interagir avec un utilisateur grâce à la gestion des événements;
Interagir avec un utilisateur par le biais des formulaires;
Communiquer avec un serveur HTTP avec AJAX;
Afficher des vues en fonction de l’URL avec le routage;
Mettre en forme un composant;
Objectif général :
Prendre en main l’une des bibliothèques JavaScript les plus utilisés pour créer des interfaces utilisateurs
Objectifs spécifiques :
Découper l’interface utilisateur avec les composants
Passer des informations (données ou instructions) d’un composant à son composant fils avec « props »
Gérer l’état local d’un composant avec « state »
Afficher une listes de composants avec map()
Afficher un composant en fonction de l’état de l’application
Interagir avec un utilisateur grâce à la gestion des événements
Interagir avec un utilisateur par le biais des formulaires
Communiquer avec un serveur HTTP avec AJAX
Afficher des vues en fonction de l’URL avec le routage
Mettre en forme un composant
Ce cours présente comment définir de nouveaux objets en définissant des classes. Un objet est une instance d'une classe qui définit les variables d'instances (attributs) et méthodes (fonctionnalités) que les objets créés à partir de la classe auront.
Objectif général : Savoir créer des pages Web interactives sans trop solliciter le serveur et le réseau pour offrir une meilleure expérience utilisateur
Objectifs opérationnels
- Stocker des données à l’aide des variables
- Traiter des données à l’aide des opérateurs.
- Communiquer avec l’internaute à l’aide des E/S de base
- Contrôler le flux d’exécution des instructions.
- Réutiliser et organiser le code en créant des fonctions
- Créer l’interactivité grâce à la gestion des évènements
- Traiter plus facilement plusieurs données connexes grâce aux tableaux et aux objets
- Gérer les propriétés de la fenêtre avec l’objet window
- Manipuler le contenu de la page Web grâce à l’objet document
- Contrôler la saisie d’un formulaire avec l’objet form
Objectif général : Prendre en main l’un des frameworks PHP les plus utilisés
Objectifs spécifiques
Faire correspondre une URL donnée à un traitement précis grâce au routage
Regrouper des traitements connexes grâce aux contrôleurs
Récupérer les données d’une requête http grâce à Request
Retourner des contenus aux formats texte, HTML, JSON, etc. grâce à Response
Intégrer des données dans des templates grâce à Blade
Interagir avec l’utilisateur grâce aux formulaires
Créer, mettre à jour et suivre les évolutions d’un schéma de base de données grâce aux migrations
Faciliter la communication avec une base de données grâce à Eloquent
Objectif général : Prendre en main l’une des bibliothèques JavaScript les plus utilisés pour créer des interfaces utilisateurs
Objectifs spécifiques :
Découper l’interface utilisateur avec les composants;
Configurer les composants avec « props »;
Gérer l’état local d’un composant avec « state »;
Afficher une listes de composants avec map();
Afficher un composant en fonction de l’état de l’application;
Interagir avec un utilisateur grâce à la gestion des événements;
Interagir avec un utilisateur par le biais des formulaires;
Communiquer avec un serveur HTTP avec AJAX;
Afficher des vues en fonction de l’URL avec le routage;
Mettre en forme un composant;
Objectif général :
Prendre en main l’une des bibliothèques JavaScript les plus utilisés pour créer des interfaces utilisateurs
Objectifs spécifiques :
Découper l’interface utilisateur avec les composants
Passer des informations (données ou instructions) d’un composant à son composant fils avec « props »
Gérer l’état local d’un composant avec « state »
Afficher une listes de composants avec map()
Afficher un composant en fonction de l’état de l’application
Interagir avec un utilisateur grâce à la gestion des événements
Interagir avec un utilisateur par le biais des formulaires
Communiquer avec un serveur HTTP avec AJAX
Afficher des vues en fonction de l’URL avec le routage
Mettre en forme un composant
Ce cours présente comment définir de nouveaux objets en définissant des classes. Un objet est une instance d'une classe qui définit les variables d'instances (attributs) et méthodes (fonctionnalités) que les objets créés à partir de la classe auront.
Objectif général : Savoir créer des pages Web interactives sans trop solliciter le serveur et le réseau pour offrir une meilleure expérience utilisateur
Objectifs opérationnels
- Stocker des données à l’aide des variables
- Traiter des données à l’aide des opérateurs.
- Communiquer avec l’internaute à l’aide des E/S de base
- Contrôler le flux d’exécution des instructions.
- Réutiliser et organiser le code en créant des fonctions
- Créer l’interactivité grâce à la gestion des évènements
- Traiter plus facilement plusieurs données connexes grâce aux tableaux et aux objets
- Gérer les propriétés de la fenêtre avec l’objet window
- Manipuler le contenu de la page Web grâce à l’objet document
- Contrôler la saisie d’un formulaire avec l’objet form
Objectif général : Prendre en main l’un des frameworks PHP les plus utilisés
Objectifs spécifiques
Faire correspondre une URL donnée à un traitement précis grâce au routage
Regrouper des traitements connexes grâce aux contrôleurs
Récupérer les données d’une requête http grâce à Request
Retourner des contenus aux formats texte, HTML, JSON, etc. grâce à Response
Intégrer des données dans des templates grâce à Blade
Interagir avec l’utilisateur grâce aux formulaires
Créer, mettre à jour et suivre les évolutions d’un schéma de base de données grâce aux migrations
Faciliter la communication avec une base de données grâce à Eloquent
Voici le chapitre sur les classes et les objets en C++.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
ASP.NET est un ensemble de technologies de programmation Web créé par Microsoft. Ce langage est utilisé pour créer des sites Webs dynamiques, des applications web ou des web services XML.
Le développement Web avec ASP.NET est plus facile: les applications Web sont développées comme des applications Windows en utilisant le modèle ASP.net ==> il s'agit d'une insertion du code (codebehind) C# ou VB.net dans des pages HTML (ajouter du JavaScript) est envoyé au client. On dit On dit que le C# et/ou VB.NET sont utilisés pour modifier le HTML
L'objectif de cette introduction est de :
- Comprendre le fonctionnement du Framework .Net
- Comprendre les principes de base de ASP.NET
- Faire la différence entre Page web Classiques et pages ASPX crées avec ASP.NET
This document provides an overview of JSP/Servlet architecture. It describes how a web request is handled from the browser to the web server and JSP/Servlet container. It then discusses key components like servlets, JSPs, the request and response objects. It provides examples of basic servlet and JSP code to output text and access request parameters. It also covers servlet configuration, mappings, and the use of forwards and redirects.
Exemple d'application qui montre comment utiliser les bonnes pratiques de JEE pour développer un site web de commerce électronique en utilisant les outils :
- Eclipse comme environnement de développement
- Maven comme outil d’intégration
- JUnit comme Framework des tsts unitaire
- Spring IOC pour l'inversion de contrôle
- Spring MVC pour la couche web
- Spring Security pour la sécurité
- JPA, Hibernate
- Web Service SOAP
- Web Service REST
- Service RMI
Support Dot Net avec C#. Ce cours traite les points suivants :
- Architecture .Net
- Les bases de C#
- Objet et Classe
- Héritage
- Encapsulation
- Polymorphisme
- Les exceptions
- Les entrées sorties
- Les interfaces graphiques
- Le multi Threading
- Programmation réseaux (Sockets et DataGram)
- Accès aux bases de données
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Une révision des principaux concepts du langage JavaScript : variables, fonctions, types, fermetures (closures), objets et prototypes, format JSON. De nombreux exemples téléchargeables sur GitHub.
Voici le chapitre sur les classes et les objets en C++.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
ASP.NET est un ensemble de technologies de programmation Web créé par Microsoft. Ce langage est utilisé pour créer des sites Webs dynamiques, des applications web ou des web services XML.
Le développement Web avec ASP.NET est plus facile: les applications Web sont développées comme des applications Windows en utilisant le modèle ASP.net ==> il s'agit d'une insertion du code (codebehind) C# ou VB.net dans des pages HTML (ajouter du JavaScript) est envoyé au client. On dit On dit que le C# et/ou VB.NET sont utilisés pour modifier le HTML
L'objectif de cette introduction est de :
- Comprendre le fonctionnement du Framework .Net
- Comprendre les principes de base de ASP.NET
- Faire la différence entre Page web Classiques et pages ASPX crées avec ASP.NET
This document provides an overview of JSP/Servlet architecture. It describes how a web request is handled from the browser to the web server and JSP/Servlet container. It then discusses key components like servlets, JSPs, the request and response objects. It provides examples of basic servlet and JSP code to output text and access request parameters. It also covers servlet configuration, mappings, and the use of forwards and redirects.
Exemple d'application qui montre comment utiliser les bonnes pratiques de JEE pour développer un site web de commerce électronique en utilisant les outils :
- Eclipse comme environnement de développement
- Maven comme outil d’intégration
- JUnit comme Framework des tsts unitaire
- Spring IOC pour l'inversion de contrôle
- Spring MVC pour la couche web
- Spring Security pour la sécurité
- JPA, Hibernate
- Web Service SOAP
- Web Service REST
- Service RMI
Support Dot Net avec C#. Ce cours traite les points suivants :
- Architecture .Net
- Les bases de C#
- Objet et Classe
- Héritage
- Encapsulation
- Polymorphisme
- Les exceptions
- Les entrées sorties
- Les interfaces graphiques
- Le multi Threading
- Programmation réseaux (Sockets et DataGram)
- Accès aux bases de données
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Une révision des principaux concepts du langage JavaScript : variables, fonctions, types, fermetures (closures), objets et prototypes, format JSON. De nombreux exemples téléchargeables sur GitHub.
JavaScript est désormais omniprésent et rend possible l'écriture d'applications complexes et riches. Mais il est souvent mal connu des développeurs orientés objets classiques comme ceux pratiquant le C#, le Java ou le PHP. Cette session passera donc en revue les bases du langage JavaScript, ses spécificités comme les portées, les closures, le this différent de ce que vous pouvez connaître. Bref, vous verrez qu'il y a des pièges à éviter et qu'il ne faut pas négliger JavaScript. Il est très puissant mais potentiellement différent de ce vous connaissez déjà. Venez apprendre à le respecter avant de le maitriser!
Decouvrez les particularités de JavaScript qui vous aideront à débogguer sans craindre ce langage aujourd'hui indispensable.
- la portée des variables et comment ne pas polluer l'espace global
- comprendre le mot clé this
- les particularités des fonctions
- introduction aux namespaces
Loin de la théorie vous aurez des explications pratiques et des démos de code ainsi que les bonnes pratiques.
Ce document a été conçu et utilisé sur plusieurs sessions de formation professionnelles pour développeurs logiciels.
Il présente la syntaxe du langage javascript à usage d'un public de développeurs maîtrisant déjà un langage de développement (langage C, Java, C Sharp, PHP...).
Niveau : débutant.
Séance numéro : 1/10.
Temps nécessaire à la séance : environ 1h.
Cette séance fait partie d'une série de 10 séances présentant le langage javascript (niveau débutant à confirmé).
Le niveau débutant de la série se réalise en 2 jours.
La niveau confirmé se réalise en 3 jours.
Ce programme est conforme aux titres du ministère du travail :
- Développeur Logiciel
- Concepteur Développeur Informatique
Il permet de valider les modules correspondants de ces titres RNCP (compétences développement de pages web).
La méthode utilisée mélange les approches interrogatives et actives :
- à partir d'exemples de code, faire raisonner les stagiaires par raisonnement hypothético-déductif ("que fait ce code?")
- à partir de code "à trous", faire découvrir et appliquer des éléments de syntaxe (travaux pratiques "construisons ensemble")
- à partir des problèmes rencontrés, faire rechercher des solutions possibles aux problèmes soulevés par le code "énigme" ("quelles solutions?")
- à partir de code "énigme", faire vérifier l'assimilation des connaissances ("vrai ou faux?")
Inclus :
- code à trou
- grille d'évaluation
Ce document powerpoint est également disponible en marque blanche. Nous contacter via notre compte twitter @forgelogicielle.
Javascript pour les développeurs Java : quels sont les pièges à éviter ?FlorianBoulay
Présentation donnée lors de Devoxx France 2013 dans le cadre d'un quickie.
Détails sur le site de Devoxx France : http://www.devoxx.com/display/FR13/JavaScript+pour+les+developpeurs+Java+++quels+sont+les+pieges+a+eviter
Voici le résumé de cette session :
Javascript a été inspiré par différents langages. Java lui a donné sa syntaxe, ses objets et ses méthodes.
Les syntaxes de Javascript et Java sont très proches, les développeurs Java pensent de la même manière lorsqu'ils codent dans ces 2 langages. Cependant Javascript possèdent de nombreuses subtilités qui peuvent se transformer en bugs si elles ne sont pas connues.
A travers ce quickie, je vais lister les prinicipaux pièges dans lesquels les développeurs Java ont tendance à tomber et comment les éviter. Voici une liste non exhaustive des points qui seront abordés :
* Les différents opérateurs permettant de tester l'égalité : == et ===
* La portée des variables
* L'enfer des variables globales ou comment isoler les variables pour qu'elles ne soient pas globales
* Les conversions de chaînes de caractères en nombre
* Les objets natifs Javascript ne devant pas être utilisés comme en Java
* L'objet this et ses différentes utilisations
Et d'autres encore !
Cette conférence présente le framework Johnny-Five qui permet de programmer des cartes embarquées à l'aide d'un module Node.js. Après un tour rapide du JavaScript et de son fonctionnement, en particulier la programmation fonctionnelle et l'exécution pilotée par les évènements, la présentation décrit Node.js et aborde rapidement son fonctionnement. La troisième partie présente Johnny-Five et plusieurs exemples simples de contrôle d'une LED et de l'utilisation des entrées/sorties numériques et analogiques.
L'idée est de faire un point sur JavaScript, ses origines et son actualité, vu de la perspective d'un développeur Microsoft. Cette présentation est essentiellement destinée aux développeurs .NET qui auraient le sentiment d'avoir un peu lâché JavaScript, et qui voudraient se remettre dans le bain.
Nouveautés JavaScript dans le monde Microsoftdavrous
Présentation delivrée le 19 mars 2015 lors du JavaScript Open Day: http://www.meetup.com/Javascript-Open-Day/events/220087351/
Au programme: les nouveautés du moteur du projet Spartan comme Web Audio ou ECMAScript 6
Les logiciels libres : une opportunite pour votre entreprise?Asher256
L'utilisation des logiciels libres se généralise dans le milieu professionnel, notamment avec l'intégration croissante de logiciels de gestion, de comptabilité et administratifs. Vous découvrirez les principaux points abordés lors de la conférence.
La conférence intitulée « Les logiciels libres, une opportunité pour votre entreprise ? » visait à explorer le potentiel des logiciels libres dans le milieu des affaires.
Dans cette présentation, j'ai principalement mis en avant les avantages des logiciels libres pour les entreprises, tout en abordant certains éléments de manière plus spectaculaire.
L'objectif n'était pas de présenter exhaustivement tous les avantages et désavantages, mais plutôt :
- De simplifier le sujet pour un public découvrant les logiciels libres, potentiellement composé de futurs entrepreneurs.
- De favoriser une session de questions/réponses, durant laquelle nous avons discuté plus objectivement et en détail des avantages et désavantages. Cette session a duré environ une heure.
- De présenter les logiciels libres sous un jour favorable pour inciter les participants à les explorer davantage.
Pour approfondir vos connaissances sur les logiciels libres dans les entreprises, je vous recommande de consulter :
- Un dossier complet sur les logiciels libres dans les entreprises (un document PDF de plus de 80 pages).
Vous pouvez également lire ces articles pour en savoir plus :
- Quels usages des logiciels libres dans les entreprises ?
- L'entreprise doit-elle adopter les logiciels libres ?
- Logiciels libres et entreprise.
La discussion est maintenant ouverte. Quelle est votre perspective sur l'utilisation des logiciels libres dans les entreprises ? Quels sont, selon vous, leurs avantages et leurs inconvénients ? Y a-t-il des écueils à éviter ?
Le gros titres des slides:
Les Logiciels Libres : Une Opportunité Pour Les Entreprises ?
Les logiciels propriétaires ? ● (aussi appelées logiciels privateurs) ● Propriétaire = Un logiciel qui n’est pas ”libre”. ● En général (il y a des variantes) : – Il est interdit de le partager – Droit seulement de l’utiliser – Code source fermé – En général payant
Les Logiciels Libres : Une Opportunité Pour Les Entreprises ?
Les logiciels propriétaires ? ● (aussi appelées logiciels privateurs) ● Propriétaire = Un logiciel qui n’est pas ”libre”. ● En général (il y a des variantes) : – Il est interdit de le partager – Droit seulement de l’utiliser – Code source fermé – En général payant
Les Licences Open Source ● Plus de droits: BSD, X, MIT ● Libres, avec conditions : GPL, LGPL ● Autres licences : Art Libre, Creative Common…
Le logiciel libre, selon la FSF (4 libertés de la GPL) ● Exécuter sans restriction ● Étudier son fonctionnement ● Redistribuer des copies (même payantes) ● Améliorer le programme et publier les améliorations
Comment s’ont développés les logiciels libres ? ● Bénévoles – Organisés (GNU, Apache) – Isolés ● Entreprises – QT – OpenERP ● Divers profiles : – Traducteur – Développeur –
Stratégies pour accroître la visibilité et l'engagement de votre blogAsher256
Dans la présentation proposée, vous explorerez les fondamentaux et les stratégies essentielles pour augmenter la visibilité de votre blog. Voici une élaboration détaillée sur les différents aspects qui seront abordés:
Nous débuterons par des techniques de promotion essentielles. Cela inclut l'utilisation des réseaux sociaux, le networking avec d'autres blogueurs, et la participation à des forums et des groupes en ligne pertinents. L'objectif est de créer une présence initiale qui capte l'attention.
Ensuite, nous discuterons de méthodes pour augmenter le trafic vers votre site. Cela comprend le marketing de contenu, lequel implique la création d'articles intéressants, pertinents et utiles qui répondent aux questions de votre audience cible. Nous aborderons également l'importance de l'email marketing et des newsletters pour attirer régulièrement des visiteurs.
Fidéliser votre audience est important pour assurer le succès à long terme de votre blog. Nous explorerons des techniques telles que l'offre de contenu exclusif, la mise en place de programmes de fidélité, et la régularité des publications. Engager activement vos lecteurs via les commentaires et les réseaux sociaux sera également discuté.
Un des aspects les plus techniques mais essentiels est le référencement naturel, ou SEO (Search Engine Optimization). Vous apprendrez comment optimiser vos articles de blog et votre site pour améliorer votre classement dans les résultats des moteurs de recherche comme Google et Yahoo. Cela inclut l'optimisation des mots-clés, la création de liens retour (backlinks), l'amélioration de la vitesse de chargement du site, et plus encore.
Requetes ecommerce - les différences US vs Europe.pptxPhilippe YONNET
Beaucoup de fonctionnalités présentes sur les requêtes ecommerce sur les SERPs de Google aux USA, n'existent pas encore sur Google FR. La faute au RGPD, au DMA, mais cela peut arriver sous une autre forme en France, avec un impact potentiel non négligeable sur l'e-commerce
Les dernières core update, l'arrivée de l'IA dans l'algorithme, les HCU, les product revienws upates ont sérieusement mis à mal l'efficacité des vieilles méthodes SEO. Il faut passer à autre chose...
Actu du SEO - Matin Népérien Lille - Agence NeperPhilippe YONNET
L'actu du SEO présentée lors du Matin Népérien de Lille le 4 janvier 2024.
On a parlé DMA, AI Act, Cookies Tiers, des Core Update de Mars, AI Overviews, Bots Google et Crawl, et bien sûr ... des Google Leaks
La télévision fait partie intégrante de notre quotidien. Avec l'évolution de la technologie, notre manière de consommer le contenu télévisuel a changé de manière significative. L'une des innovations les plus remarquables dans ce domaine est l'IPTV. Mais qu'est-ce que c'est exactement ? Et pourquoi l'ABO IPTV PREMIUM est-il si révolutionnaire ? Découvrons ensemble.
ABO IPTV PREMIUM peut également être utilisé sur des ordinateurs portables, des PC de bureau et même des consoles de jeux.
Regardez vos émissions préférées en déplacement grâce aux applications mobiles disponibles pour iOS et Android.
Que vous ayez une Smart TV Samsung, LG, ou autre, ABO IPTV PREMIUM est compatible avec la plupart des téléviseurs intelligents.
4. • Dynamiser une page HTML
- Interactions avec l’internaute
- Animations
- Aide à la navigation)
Apports du JavaScript
5. Petit historique du langage
• Développé par Brendan Eich (1995)
• standardisé par l'ECMA International sous le
nom d’ECMAScript
• Dernière version standardisée du JavaScript est
basée sur l'ECMAScript 5, sorti en 2009.
• ECMAScript 6
7. Le javascript dans une page HTML
<!DOCTYPE html>
<html>
<head>
<title>Hello World!</title>
</head>
<body>
<script type="text/javascript" src="hello.js"></script>
<script type="text/javascript" >
// Un peu de code JavaScript...
8. Afficher une boîte de dialogue
<!DOCTYPE html>
<html>
<head>
<title>Hello World!</title>
</head>
<body>
9. La syntaxe du JavaScript
Les instructions
Ou
instruction_1;
instruction_2;
instruction_3;
Instruction_1;Instruction_2
Instruction_3
function toggle(elemID) {
var elem = document.getElementById(elemID);
if (elem.style.display == 'block') {
elem.style.display = 'none';
Espace et indentation
10. Les variables
// Déclaration de variables
var myVariable;
// Affectation de valeur
myVariable = 2;
// Chaine de caractère
var text1 = "Mon premier texte"; // Avec des guillemets
var text2 = 'Mon deuxième texte'; // Avec des apostrophes
// boolean
11. Type des variables
var x; // Now x is undefined
var x = 5; // Now x is a Number
var x = "John"; // Now x is a String
var cars = ["Saab", "Volvo", "BMW"];
var person = {firstName:"John", lastName:"Doe", age:50,
eyeColor:"blue"};
/* Connaitre le type d’une variable */
alert(typeof text1); // Affiche : « string »
typeof "John" // Returns string
typeof 3.14 // Returns number
typeof false // Returns boolean
typeof [1,2,3,4] // Returns object
typeof {name:'John', age:34} // Returns object
13. Concacténation
var hi = 'Bonjour', name = 'toi', result;
result = hi + name;
alert(result); // Affiche : « Bonjourtoi »
// Simplification
var text = 'Bonjour ';
text += 'toi';
alert(text); // Affiche « Bonjour toi ».
var userName = prompt('Entrez votre prénom :');
alert(userName); // Affiche le prénom entré par l’utilisateur
Interaction avec l’utilisateur
14. Concaténation - suite
var text = 'Voici un nombre : ', number = 42, result;
result = text + number;
alert(result); // Affiche : « Voici un nombre : 42 »
var first, second, result;
first = prompt('Entrez le premier chiffre :');
second = prompt('Entrez le second chiffre :’);
result = first + second;
result2 = parseInt(first) + parseInt(second);
alert(result);
Conversion de type
16. Les conditions
var number = 4, text = '4', result;
alert(number == text;); // Affiche « true » alors que « number » est un nombre et « text »
une chaîne de caractères
17. Les opérateurs de comparaison
var number1 = 2, number2 = 2, number3 = 4,
result;
result = number1 == number2; // On spécifie
deux variables avec l'opérateur de comparaison
entre elles
alert(result); // Affiche « true », la condition est
donc vérifiée car les deux variables contiennent
bien la même valeur
Opérateur Signification
== égal à
!= différent de
=== contenu et type égal à
!== contenu ou type différent de
> supérieur à
>= supérieur ou égal à
< inférieur à
<= inférieur ou égal à
Exemples
18. Les opérateurs logiques
var result = true && true;
alert(result); // Affiche : « true »
result = true && false;
alert(result); // Affiche : « false »
result = false && false;
alert(result); // Affiche : « false »
Exemples avec ET
Opérateur Type de logique Utilisation
&& ET valeur1 && valeur2
|| OU valeur1 || valeur2
! NON !valeur
var result = true || true;
alert(result); // Affiche : « true »
result = true || false;
alert(result); // Affiche : « true »
var result = false;
result = !result;
alert(result); // Affiche « true » car on voulait l'inverse de «
false »
Exemples avec NONExemples avec OU
19. Combiner les opérateurs
var condition1, condition2, result;
condition1 = 2 > 8; // false
condition2 = 8 > 2; // true
result = condition1 && condition2;
alert(result); // Affiche « false »
var result = 2 > 8 && 8 > 2;
alert(result); // Affiche « false »
21. La structure if
if (true) {
alert("Ce message s'est bien affiché.");
}
if (false) {
alert("Pas la peine d'insister, ce message ne s'affichera pas.");
}if (2 < 8 && 8 >= 4) { // Cette condition renvoie « true », le code est donc exécuté
alert('La condition est bien vérifiée.');
}
if (2 > 8 || 8 <= 4) { // Cette condition renvoie « false », le code n'est donc pas exécuté
Exemples
22. La structure if….else
if (confirm('Pour accéder à ce site vous devez avoir 18 ans ou plus, cliquez sur "OK" si
c'est le cas.')) {
alert('Vous allez être redirigé vers le site.');
}
else {
alert("Désolé, vous n'avez pas accès à ce site.");
}
var floor = parseInt(prompt("Entrez l'étage où l'ascenseur doit se rendre (de -2 à 30) :"));
if (floor == 0) {
alert('Vous vous trouvez déjà au rez-de-chaussée.');
} else if (-2 <= floor && floor <= 30) {
L’instruction « else if »
23. La structure switch
var drawer = parseInt(prompt('Choisissez le tiroir à ouvrir (1 à 4) :'));
switch (drawer) {
case 1:
case 1:
alert('Contient divers outils pour dessiner : du papier, des crayons, etc.');
break;
case 2:
alert('Contient du matériel informatique : des câbles, des composants, etc.');
break;
24. Les ternaires
var startMessage = 'Votre catégorie : ',
endMessage,
adult = confirm('Êtes-vous majeur ?');
if (adult) { // La variable « adult » contient un booléen, on peut donc directement la
soumettre à la structure if sans opérateur conditionnel
endMessage = '18+';
} else {
endMessage = '-18';
}
alert(startMessage + endMessage);
var startMessage = 'Votre catégorie : ',
endMessage,
adult = confirm('Êtes-vous majeur ?');
25. Conditions sur les variables
var conditionTest = 'Fonctionnera ? Fonctionnera pas ?';
if (conditionTest) {
alert('Fonctionne !');
} else {
alert('Ne fonctionne pas !');
}var conditionTest1 = '', conditionTest2 = 'Une chaîne de caractères';
alert(conditionTest1 || conditionTest2);
L’opérateur OU
Tester l'existence de contenu d'une variable
26. Incrémentation et décrémentation
var number = 0;
number++;
alert(number); // Affiche : « 1 »
number--;
alert(number); // Affiche : « 0 »var number = 0;
var output = ++number;
alert(number); // Affiche : « 1 »
alert(output); // Affiche : « 1 »
Ordre des opérateurs
28. La boucle « while »
while (condition) {
instruction_1;
instruction_2;
instruction_3;
}
var number = 1;
while (number < 10) {
number++;
}
Exemples
29. La boucle « while »
var nicks = '', nick;
while (true) {
nick = prompt('Entrez un prénom :');
if (nick) {
nicks += nick + ' '; // Ajoute le nouveau prénom ainsi qu'une espace juste après
} else if (nick == ‘continue’) {
continue; // On passe à l’itération suivante
} else {
Exemples avec liste de « prénom »
30. La boucle « do…while »
do {
instruction_1;
instruction_2;
instruction_3;
} while (condition);
var number = 1;
while (number < 10) {
number++;
}
Exemples
31. La boucle « for »
for (initialisation; condition; incrémentation) {
instruction_1;
instruction_2;
instruction_3;
}for (var iter = 0; iter < 5; iter++) {
alert('Itération n°' + iter);
}
Exemples
for (var nicks = '', nick; true;) {
nick = prompt('Entrez un prénom :');
continue;
if (nick) {
nicks += nick + ' ';
} else {
32. Les fonctions
• Mener une action précise
• Factoriser et simplifier le code
function myFunction(arguments) {
// Le code que la fonction va devoir exécuter
Structure d’une fonction
33. Les fonctions
function showMsg() {
alert('Et une première fonction, une !');
}
showMsg(); // On exécute ici le code contenu dans la fonction
Intérêt d’une fonction
var result;
result = parseInt(prompt('Donnez le nombre à multiplier par 2 :'));
alert(result * 2);
alert('Vous en êtes à la moitié !');
34. Intérêt des fonctions
function byTwo() {
var result = parseInt(prompt('Donnez le nombre à multiplier par 2 :'));
alert(result * 2);
}
byTwo();
alert('Vous en êtes à la moitié !');
byTwo();
35. La portée des variables
var ohai = 'Hello world !';
function sayHello() {
alert(ohai);
}
sayHello();function sayHello() {
var ohai = 'Hello world !';
}
Variables locales
Variables globales
36. La portée des variables - suite
var message = 'Ici la variable globale !';
function showMsg() {
var message = 'Ici la variable locale !';
alert(message);
}
showMsg();
alert(message);
Variables globales et locales du même nom
38. Les arguments
function myFunction(arg) { // Notre argument est la variable « arg »
// Une fois que l'argument a été passé à la fonction, vous allez le retrouver dans la
variable « arg »
alert('Votre argument : ' + arg);
}
myFunction('En voilà un beau test !');
function moar(first, second) {
// On peut maintenant utiliser les variables « first » et « second » comme on le souhaite
:
alert('Votre premier argument : ' + first);
alert('Votre deuxième argument : ' + second);
}
Exemples
39. Les arguments facultatifs
function prompt2(text, allowCancel) {
if (typeof allowCancel === 'undefined') {
allowCancel = false;
}
alert(text);
}
// On exécute la fonction seulement avec le premier argument, pas besoin du deuxième
prompt2('Entrez quelque chose :');
function prompt2(allowCancel, text) {
position des arguments facultatifs
40. Les valeurs de retour
function sayHello() {
return 'Bonjour !'; // L'instruction « return » suivie d'une valeur
alert('Attention ! Le texte arrive !');
}
alert(sayHello()); // Ici on affiche la valeur retournée par la fonction sayHello()
41. Les fonctions anonymes
function (arguments) {
// Le code de votre fonction anonyme
}
var sayHello = function() {
alert('Bonjour !');
};
sayHello(); // Affiche : « Bonjour ! »
cas pratiques
42. Structures vs instructions
function structure() {
// Du code…
}
var instruction = 1234;
var instruction = function() {
// Du code…
};
Instructions
Structures
43. Isoler le code avec fonctions anonymes
// Code externe
(function() {
// Code isolé
})
(arguments);
// Code externe
function test() {
// Du code…
}
test();
(function test() {
// Code.
revient à :
déclaration fonction + exécution
44. Isoler le code avec fonctions anonymes
var test = 'noir'; // On crée une variable « test » contenant le mot « noir »
(function() { // Début de la zone isolée
// On crée une variable du même nom avec le contenu « blanc » dans la zone isolée
var test = ‘blanc';
alert('Dans la zone isolée, la couleur est : ' + test);
})(); // Fin de la zone isolée. Les variables créées dans cette zone sont détruites.
Exemple :
45. Isoler le code avec fonctions anonymes
var sayHello = (function() {
return 'Yop !';
})();
alert(sayHello); // Affiche : « Yop ! »
Valeur de retour zone isolée
46. Comprendre le scope
var l=1;
function demandezunnombre() {
x= prompt("donnez un nombre > 13 svp :) ");
}
do {
demandezunnombre();
}while((x=="") || (parseInt(x) < 13));
alert(
"Merci, vous avez bien rentré le numéro : "+l +" valdez et allez faire vous calcules :)"
);
Erreur à ne pas faire
47. A retenir - fonctions
• Les variables déclarées avec var au sein d'une fonction ne
sont accessibles que dans cette fonction.
• Eviter le plus possible d’utiliser des variables globales.
• Une fonction peut recevoir un nombre défini ou indéfini de
paramètres. Elle peut aussi retourner une valeur ou ne rien
retourner du tout.
• Des fonctions qui ne portent pas de nom sont des fonctions
anonymes et servent à isoler une partie du code.
49. Exercice carre
function carre()
{
var n=parseInt(prompt("donner un nombre entier : "));
var s="";
for(var i=0;i<n;i++)
{ var d="";
for (j=0;j<n;j++)
{
var k="*"
d+=k;
}
var l=d
s+=l+"n";
}
return s;
}
var R = carre();
alert(R);
50. Exercice triangle rectangle
function triangle(){
var n=parseInt(prompt("Entrez un nombre entier : "));
var r="";
for(var i=0;i<n;i++)
{ var d="";
for (j=0;j<i;j++)
{
var v="*"
d+=v;
}
var w=d
r+=w+"*n";
}
return r;
}
var R = triangle();
alert(R);
51. Exercice triangle isocèle
function losange(){
do{
var n=parseInt(prompt("Entrez un nombre impair : "));
}while(n%2==0);
var r="";
for(i=1;i<=n;i=i+2){
var d="";
for (j=1;j<=i;j++){
var v="*";d+=v;
}
var a="";
for(var k=1;k<=(n-i)/2;k++){
var b=" "
a+=b
}
var h=« *"; var c=a; var w=d;
r+=c+w+c+"n";
}
return r;
}
var R = losange();
alert(R);
52. Exercice triangle isocèle
function losange(){
do{
var n=parseInt(prompt("Entrez un nombre impair : "));
}while(n%2==0);
var r="";
for(i=1;i<=n;i=i+2){
var d="";
for (j=1;j<=i;j++){
var v="*";
d+=v;
}
var a="";
for(var k=1;k<=(n-i)/2;k++){
var b=" "
a+=b
}
var h="*"
var c=a;
var w=d;
r+=c+w+c+"n";
}
53. Les objets natifs
var myString = 'Ceci est une chaîne de caractères’;
// On affiche le nombre de caractères, au moyen de la propriété « length »
alert(myString.length);
// On récupère la chaîne en majuscules, avec la méthode toUpperCase()
alert(myString.toUpperCase());
• un constructeur
• des propriétés
• des méthodes
Les élément d’un objet
54. Autres objets natifs
Number : l'objet qui gère les nombres
Boolean : l'objet qui gère les booléens
String : l'objet qui gère les chaînes de caractères
Array : l'objet qui gère les tableaux
56. Opérations sur les tableaux
var myArray = ['Sébastien', 'Laurence', 'Ludovic', 'Pauline', 'Guillaume'];
alert(myArray[1]); // Affiche : « Laurence »
myArray[1] = 'Clarisse';
alert(myArray[1]); // Affiche : « Clarisse »
myArray.push('Ludovic'); // Ajoute « Ludovic » à la fin du tableau
myArray.push('Pauline', 'Guillaume'); // Ajoute « Pauline » et « Guillaume » à la fin du
tableau
myArray.unshift(‘Ludovic’);
myArray.unshift(‘Ludovic’, ‘Pauline’);
Ajout d’item
myArray.pop(); // Retire le dernier élément
myArray.shift(); // Retire le premier élément
Supression d’item
57. Transformation chaine / tableau
var cousinsString = 'Pauline Guillaume Clarisse',
cousinsArray = cousinsString.split(' ');
alert(cousinsString);
alert(cousinsArray);
var cousinsString_2 = cousinsArray.join('-');
alert(cousinsString_2);
Tableau vers chaine
Chaine vers tableau
58. Parcourir un tableau
var myArray = ['Sébastien', 'Laurence', 'Ludovic', 'Pauline', ‘Guillaume'];
for (var i = 0; i < myArray.length; i++) {
alert(myArray[i]);
}
for (var i = 0, c = myArray.length; i < c; i++) {
alert(myArray[i]);
Optimisation
Parcourir avec for
59. Les objets littéraux
var family = {
self: 'Sébastien',
sister: 'Laurence',
brother: 'Ludovic',
cousin_1: 'Pauline',
cousin_2: 'Guillaume'
};
Identifiant self sister brother cousin_1 cousin_2
Donnée Sébastien Laurence Ludovic Pauline Guillaume
Tableau des prénoms
60. Syntaxe des objets
var myArray = [];
var myObject = {};
var family = {
self: 'Sébastien',
sister: 'Laurence',
brother: 'Ludovic',
cousin_1: 'Pauline',
cousin_2: 'Guillaume'
};
Accès aux items
family.sister;
family[‘sister'];
61. Opérations sur les objets
family['uncle'] = 'Didier'; // « Didier » est ajouté et est accessible via l'identifiant « uncle »
family.uncle = 'Didier'; // Même opération mais d'une autre manière
Parcourir les objets
for (var id in family) {
// On stocke l'identifiant dans « id » pour parcourir l'objet « family »
alert(family[id]);
Ajout d’un item
62. Utilisation des objets
function getCoords() {
/* Script incomplet, juste pour l'exemple */
return { x: 12, y: 21 };
}
var coords = getCoords();
alert(coords.x); // 12
alert(coords.y); // 21
Valeur de retour
63. Exercices
- Ecrire un programme qui saisit un entier au clavier et qui recherche si cet entier
appartient au tableau (réponse de type oui/non).
- Ecrire un programme qui saisit deux indices et échange les valeurs contenues dans le
tableau à ces deux indices. Le programme affichera le contenu du tableau avant et
après cette transformation
- Reprendre la partie saisie du programme précédent pour écrire un nouveau programme
qui re- cherche et affiche le plus grand élément du tableau.
64. Débogage de code javascript
va myVar = 'test; // Le mot-clé « var » est mal orthographié et il manque une apostrophe
Bug syntaxique
// On veut afficher la valeur 6 avec les nombres 3 et 2
var myVar = 3 + 2;
// Mais on obtient 5 au lieu de 6 car on a fait une addition au lieu d'une multiplication
Bug algorithmique
65. Débogage de code javascript
va myVar = 'test; // Le mot-clé « var » est mal orthographié et il manque une apostrophe
Bug syntaxique
// On veut afficher la valeur 6 avec les nombres 3 et 2
var myVar = 3 + 2;
// Mais on obtient 5 au lieu de 6 car on a fait une addition au lieu d'une multiplication
Bug algorithmique
67. Debogage erreur syntaxique
// Ici nous créons une fonction JavaScript, avec quelques erreurs de syntaxe.
functin test() {
alert('Hello !');
script avec erreur syntaxique
<script src="votre-fichier.js"></script>
68. Afficher variable dans la console
// On crée un objet basique.
var helloObject = {
english: 'Hello',
french: 'Bonjour',
spanish: 'Hola'
};
// Et on l'affiche.
console.log(helloObject);
// Tant qu'à faire, on affiche aussi un tableau.
69. Tester un code dans la console
// On déclare une variable contenant un texte quelconque.
var myVar = 'Hello';
// Toutes les secondes, on affiche le contenu de cette variable dans la console.
setInterval();
setInterval(function() { console.log(myVar);}, 1000);
70. Utiliser les points d’arrêt
// La fonction « a » affiche la valeur qu'elle reçoit de « b ».
function a(value) {
console.log(value);
}
// La fonction « b » incrémente la valeur reçue par « c » puis la passe en paramètre à « a
».
function b(value) {
a(value + 1);
}
// La fonction « c » incrémente la valeur reçue par la boucle for puis la passe en paramètre
74. Exercice point
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these
tags -->
<title>Accueil</title>
</head>
<body>
<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="bootstrap-3.3.6-dist/js/jquery-2.1.4.js"></script>
75. Exercice point
<div id="myDiv" style="position:absolute;width:100px;height:100px;left:100px;background-color:red;"></div>
<script>
$(document).keydown(function(e){
switch (e.which){
case 37: // fleche gauche
$('div').stop().animate({left:'-=30'}); break;
case 38: // fleche haut
$('div').stop().animate({top:'-=30'}); break;
case 39: // fleche droite
$('div').stop().animate({left:'+=30'}); break;
case 40: // fleche bas
$('div').stop().animate({top:'+=30'}); break;
}
});
</script>
</body>
</html>
76. Exercice point
case 39:
//-Move right
x=x+3;
pixel.style.left = x+'px';
break;
case 38:
//-Move up
y=y-3;
pixel.style.top = y+'px';
break;
case 40:
//-Move down
y=y+3;
pixel.style.top = y+'px';
break;
default:
break;
}
};
</script>
77. Exercice point
var x=150,y=150;
pixel = document.createElement('DIV')
pixel.style.width = '10px'
pixel.style.height = '10px'
pixel.style.backgroundColor = '#000'
pixel.style.position = 'absolute'
pixel.style.left = x+'px'
pixel.style.top = y+'px'
document.body.appendChild(pixel)
window.onkeydown = function(e) {
var key = e.keyCode || e.which;
switch (key) {
case 37:
//-Move left
x=x-3;
pixel.style.left = x+'px';
break;
81. Objet document
<div id="myDiv">
<p>Un peu de texte <a>et un lien</a></p>
</div>
<script>
var div = document.getElementById('myDiv');
alert(div);
var divs = document.getElementsByTagName('div');
for (var i = 0, c = divs.length ; i < c ; i++) {
alert('Element n° ' + (i + 1) + ' : ' + divs[i]);
}
</script>
84. Editer les éléments HTML
<body>
<a id="myLink" href="http://www.un_lien_quelconque.com">Un lien modifié
dynamiquement</a>
<script>
var link = document.getElementById('myLink');
var href = link.getAttribute('href'); // On récupère l'attribut « href »
console.log(href);
link.setAttribute('href', 'http://www.speedwapp.com'); // On édite l'attribut « href »
85. Modifier la classe
<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<title>Le titre de la page</title>
<style>
.blue {
background: blue;
color: white;
}
</style>
</head>
86. Modifier la classe
var div = document.querySelector('div');
// Ajoute une nouvelle classe
div.classList.add('new-class');
// Retire une classe
div.classList.remove('new-class');
// Retire une classe si elle est présente ou bien l'ajoute si elle est absente
div.classList.toggle('toggled-class');
// Indique si une classe est présente ou non
87. Modifier le contenu d’une balise
<body>
<div id="myDiv">
<p>Un peu de texte <a>et un lien</a></p>
</div>
<script>
var div = document.getElementById('myDiv');
alert(div.innerHTML);
document.getElementById('myDiv').innerHTML = '<blockquote>Je mets une citation à la
place du paragraphe</blockquote>’;
88. Contenu textuel d’une balise
<body>
<div id="myDiv">
<p>Un peu de texte <a>et un lien</a></p>
</div>
<script>
var div = document.getElementById('myDiv');
alert(div.innerText);
var txt = '';
if (div.textContent) { // « textContent » existe ? Alors on s'en sert !
txt = div.textContent;
Notes de l'éditeur
Le JavaScript ,langage dit client-side ->les scripts sont exécutés par le navigateur chez l'internaute (le client).
Cela diffère des langages de scripts dits server-side exécutés par le serveur Web: PHP.
langage interprété par le navigateur
Culture (IE8 interpréteur JavaScript s'appelle Chakra (l'interpréteur des versions antérieures à IE9 s'appelle JScript), celui de Mozilla Firefox se nomme SpiderMonkey et celui de Google Chrome est V8.)
Langage orienté objet -> contient des éléments, appelés objets, et que ces différents objets possèdent des caractéristiques et comportements spécifiques.
Le langage fournit des objets de base comme des images, des dates, des chaînes de caractères…
possible de créer soi-même des objets pour se faciliter la vie et obtenir un code source plus clair (donc plus facile à lire) et une manière de programmer beaucoup plus intuitive (et donc plus logique).
-> utilisé majoritairement au sein des pages Web
-> utilisation en guise de serveur ou d'application commence à se répandre.
Le JavaScript est régulièrement utilisé pour réaliser des extensions pour différents programmes (Chrome et Firefox)
Possible d’utiliser le JavaScript en dehors du navigateur avec projet Node.js.
Le JavaScript peut aussi être utilisé pour réaliser des applications: l'interface de Firefox, Speedwapp, …
s'inclut directement dans la page Web (ou dans un fichier externe)
ex:
• Afficher/masquer du texte ;
• Faire défiler des images ;
• Créer un diaporama avec un aperçu « en grand » des images ;
• Créer des infobulles.
appelé au début LiveScript (décembre 1995) -> embarqué dans le navigateur Netscape 2.
Le langage est alors un succès, si bien que Microsoft développe une version semblable, appelée JScript, qu'il embarque dans Internet Explorer 3, en 1996.
Renommé JavaScript en hommage au langage Java qui était de plus en plus populaire.
European Computer Manufacturers Association
Préférez fichier externe plutôt que d'inclure le code JavaScript directement dans la page -> mis en cache par le navigateur ; accélère l’affichage de la page
<script> : contient le code JavaScript
alert() est une instruction simple, appelée fonction, qui permet d'afficher une boîte de dialogue contenant un message.
Syntaxe simple -> instruction séparé par point virgule (optionnel si l'instruction qui suit se trouve sur la ligne suivante)
Plusieurs instructions sur une même ligne, le point-virgule est fortement recommandé.
Non sensible aux espaces
Indenter (Les instructions sont hiérarchisées en plusieurs niveaux) pour rendre plus lisible.
variable -> espace de stockage sur votre ordinateur permettant d'enregistrer tout type de données
(chaîne de caractères, valeur numérique, structures complexes)
déclarer une variable -> lui réserver un espace de stockage en mémoire
(mot-clé var est présent pour indiquer que vous déclarez une variable)
déclarer et assigner des variables sur une seule et même ligne
langage sensible à la casse
typage dynamique
Prompt -> renvoie ce que l'utilisateur a écrit sous forme d'une chaîne de caractères
tapé deux fois le chiffre 1, le résultat sera 11
parseInt -> Convertir une chaîne de caractères en nombre (type number)
• Une variable est un moyen pour stocker une valeur.
• On utilise le mot clé var pour déclarer une variable, et on utilise = pour affecter une valeur à la variable.
• Les variables sont typées dynamiquement, ce qui veut dire que l'on n'a pas besoin de spécifier le type de contenu que la variable va contenir.
• Grâce à différents opérateurs, on peut faire des opérations entre les variables.
• L'opérateur + permet de concaténer des chaînes de caractères, c'est-à-dire de les mettre bout à bout.
• La fonction prompt() permet d'interagir avec l'utilisateur.
conditions -> contrôler comportement du code suivant état du programme
une condition est une sorte de « test » (ex : une variable contient bien une valeur)
huit opérateurs vont permettre de comparer diverses valeurs entre elles.
les opérateurs de comparaison acceptent chacun deux valeurs en entrée et renvoient un booléen tandis que les opérateurs logiques acceptent plusieurs booléens en entrée et renvoient un booléen
les structures conditionnelles influent sur l'exécution de votre code
Les accolades permettent de définir la portion de code qui sera exécutée si la condition se vérifie.
les structures conditionnelles influent sur l'exécution de votre code
Les accolades permettent de définir la portion de code qui sera exécutée si la condition se vérifie.
La structure else if pour dire « sinon si »
• Une première condition est à tester ;
• Une deuxième condition est présente et sera testée si la première échoue ;
• Et si aucune condition ne se vérifie, la structure else fait alors son travail.
pas très pratique pour faire du cas par cas ; un switch permet de faire une action en fonction d'une valeur mais aussi en fonction du type de la valeur (comme l'opérateur ===)
permet de ne pas réécrire à chaque fois la condition
mauvaise réputation d'être assez peu lisibles
évaluer à false - > 0, une chaîne de caractères vide, undefined
le reste est true
L'incrémentation est importante au sein des boucles.
Incrémenter ou décrémenter signifie ajouter ou soustraire une unité à une variable
boucle -> gérer les répétition -> ne pas écrire plusieurs fois les mêmes instructions
variable, condition de sortie, pas d’avancement
À chaque fois que la boucle se répète on parle d'itération
Pour faire fonctionner une boucle, il est nécessaire de définir une condition. Tant que celle-ci est vraie (true), la boucle se répète. Dès que la condition est fausse (false), la boucle s'arrête.
while -> Répéter tant que la condition est vérifiée
S'arranger, à un moment, pour que la condition ne soit plus vraie, sinon la boucle se répéterait à l’infini
Ex dernière fois : demander un nombre jusqu’à l’avoir
boucle est toujours exécutée au moins une fois
Attention à la syntaxe de la boucle do while : il y a un point-virgule après la parenthèse fermante du while.
for (Très pratique pour compter ainsi que pour répéter la boucle un nombre défini de fois.
) -> trois blocs séparés par un point-virgule (initialisation, condition, et incrémentation)
Dans l’exemple -> afficher 5 fois une boîte de dialogue à l'aide de alert(), qui affichera le numéro de chaque itération
donc si on compte de 0 à 4, il y a bien 5 tours : 0, 1, 2, 3 et 4.
Boucle for sans incrémentation
En JavaScript -> déconseillé de déclarer des variables au sein d'une boucle (entre les accolades)
-> pas besoin de déclarer une même variable à chaque passage dans la boucle
-> déclarer les variables directement dans le bloc d’initialisation
manipulation des tableaux ainsi que des objets
une fonction a pour but de mener à bien une action précise, reconnaissable par un nom explicite.
analogie -> moteur d'une voiture
tournez la clé pour démarrer le moteur et celui-ci fait déplacer tout son mécanisme pour renvoyer sa force motrice vers les roues.
C'est pareil avec une fonction : vous l'appelez en lui passant éventuellement quelques paramètres, elle va ensuite exécuter le code qu'elle contient puis va renvoyer un résultat en sortie
alert(), prompt(), confirm(), etc. est permise car elles existent déjà de façon native -> fonction ou variable native intégré au langage.
déclaration de fonction (function name)
appeler une fonction » signifie « exécuter »). Sans ça, le code qu'elle contient ne s'exécutera jamais.
noms de fonctions -> limités aux caractères alphanumériques et aux deux caractères : _ et $.
l'intérêt d'une fonction réside notamment dans le fait de ne pas avoir à réécrire plusieurs fois le même code
Nous pouvons envisager d'utiliser une boucle mais si nous voulons afficher un texte entre les deux opérations comme ceci alors la boucle devient inutilisable
variables globales -> accessibles partout dans votre code, y compris à l'intérieur des fonctions
variables locales -> toute variable déclarée dans une fonction n'est utilisable que dans cette même fonction
lorsqu'une variable n'est accessible que dans une partie de votre code, on dit qu'elle se trouve au sein d'un « scope ». Retenez bien ce terme
Pendant exécution fonction -> la variable locale prend le dessus sur la variable globale de même nom
sortie de fonction -> variable locale détruite
déconseillé de créer des variables globales et locales de même nom, cela est souvent source de confusion.
globale à proscrire car elles peuvent rapidement vous perdre dans votre code (et engendrer des problèmes si vous souhaitez partager votre code)
les variables var1 et var2 ne sont utilisées que pour la fonction calculate()
ces variables n'iront pas interférer avec d'autres fonctions qui peuvent utiliser des variables de même nom
les arguments sont des informations envoyées à une fonction
passer des valeurs en paramètres d'une fonction -> ces valeurs deviennent les arguments d'une fonction
fonction myFunction() -> code enregistré en mémoire mais ne s'exécute pas tant qu'on ne l'appelle pas
- appel à myFunction() mais en lui passant un argument, la fonction va donc attendre de recevoir tous les arguments avant de s'exécuter ;
• La fonction prompt() s'exécute puis renvoie la valeur entrée par l'utilisateur, ce n'est qu'une fois cette valeur renvoyée que la fonction myFunction() va pouvoir s'exécuter car tous les arguments auront enfin été reçus ;
• Enfin, myFunction() s'exécute !
return : cette instruction met fin à la fonction, puis retourne la valeur
tout ce qui suit « return » ne s’affiche pas (on ne peut pas faire plusieurs renvois de valeurs)
anonymes car elles ne possèdent pas de nom
assigner notre fonction à une variable
sayHello n’est pas devenue une fonction mais référence la fonction
; obligatoire car instruction
instruction assignant une structure à une variable
les fonctions, les conditions, les boucles, etc. sont des structures
tout le reste (assignation de variable, exécution de fonction, etc.) sont des instructions.
éviter qu'une partie de votre code n'affecte tout le reste (portée des variables s'applique )
fonction anonyme + 2 parenthèses (une première paire encadrant la fonction et une deuxième paire suivant la première)
doubles parenthèses -> exécuter imédiatement la fonction
fonction anonyme -> Si non assignée à variable, on doit utiliser ces doubles parenthèses pour l’exécuter
1er parenthèses -> récupère référence vers fonction et 2ème parenthèse (exécution)
fonctions immédiatement exécutées se nomment des Immediately-Invoked Function Expression, abrégées IIFE
point virgule -> la fonction (qui est une structure) est exécutée, ce qui fait que l'on obtient une instruction
fonction demander un nombre
Isole tout le code dans une fonction anonymes
def triangle(n):
i = 1
while i <= n:
print(i * '*')
i = i + 1
triangle(2)
triangle(3)
triangle(5)
Ecrivez un programme qui affiche la table de multiplication des nombres de 1 à 10, sous la forme suivante :
_ | 1 2 3 4 5 6 7 8 9 10
----------------------------------
1 | 1 2
2 | 2 4
3 | 3 6
4 | 4 8
5 | 5 10
6 | 6 12
7 | 7 14
8 | 8 16
9 | 9 18
10|10 20
Lister les valeurs d’un tableau
http://www.grappa.univ-lille3.fr/~coulom/Python/listes_prog_pendu.html
https://openclassrooms.com/forum/sujet/exercice-pour-les-vrais-debutants-en-programmation-37431 Suite de conway pour étude sur tableau
fonction demander un nombre
Isole tout le code dans une fonction anonymes
def triangle(n):
i = 1
while i <= n:
print(i * '*')
i = i + 1
triangle(2)
triangle(3)
triangle(5)
Ecrivez un programme qui affiche la table de multiplication des nombres de 1 à 10, sous la forme suivante :
_ | 1 2 3 4 5 6 7 8 9 10
----------------------------------
1 | 1 2
2 | 2 4
3 | 3 6
4 | 4 8
5 | 5 10
6 | 6 12
7 | 7 14
8 | 8 16
9 | 9 18
10|10 20
Lister les valeurs d’un tableau
http://www.grappa.univ-lille3.fr/~coulom/Python/listes_prog_pendu.html
https://openclassrooms.com/forum/sujet/exercice-pour-les-vrais-debutants-en-programmation-37431 Suite de conway pour étude sur tableau
fonction demander un nombre
Isole tout le code dans une fonction anonymes
def triangle(n):
i = 1
while i <= n:
print(i * '*')
i = i + 1
triangle(2)
triangle(3)
triangle(5)
Ecrivez un programme qui affiche la table de multiplication des nombres de 1 à 10, sous la forme suivante :
_ | 1 2 3 4 5 6 7 8 9 10
----------------------------------
1 | 1 2
2 | 2 4
3 | 3 6
4 | 4 8
5 | 5 10
6 | 6 12
7 | 7 14
8 | 8 16
9 | 9 18
10|10 20
Lister les valeurs d’un tableau
http://www.grappa.univ-lille3.fr/~coulom/Python/listes_prog_pendu.html
https://openclassrooms.com/forum/sujet/exercice-pour-les-vrais-debutants-en-programmation-37431 Suite de conway pour étude sur tableau
fonction demander un nombre
Isole tout le code dans une fonction anonymes
def triangle(n):
i = 1
while i <= n:
print(i * '*')
i = i + 1
triangle(2)
triangle(3)
triangle(5)
Ecrivez un programme qui affiche la table de multiplication des nombres de 1 à 10, sous la forme suivante :
_ | 1 2 3 4 5 6 7 8 9 10
----------------------------------
1 | 1 2
2 | 2 4
3 | 3 6
4 | 4 8
5 | 5 10
6 | 6 12
7 | 7 14
8 | 8 16
9 | 9 18
10|10 20
Lister les valeurs d’un tableau
http://www.grappa.univ-lille3.fr/~coulom/Python/listes_prog_pendu.html
https://openclassrooms.com/forum/sujet/exercice-pour-les-vrais-debutants-en-programmation-37431 Suite de conway pour étude sur tableau
fonction demander un nombre
Isole tout le code dans une fonction anonymes
def triangle(n):
i = 1
while i <= n:
print(i * '*')
i = i + 1
triangle(2)
triangle(3)
triangle(5)
Ecrivez un programme qui affiche la table de multiplication des nombres de 1 à 10, sous la forme suivante :
_ | 1 2 3 4 5 6 7 8 9 10
----------------------------------
1 | 1 2
2 | 2 4
3 | 3 6
4 | 4 8
5 | 5 10
6 | 6 12
7 | 7 14
8 | 8 16
9 | 9 18
10|10 20
Lister les valeurs d’un tableau
http://www.grappa.univ-lille3.fr/~coulom/Python/listes_prog_pendu.html
https://openclassrooms.com/forum/sujet/exercice-pour-les-vrais-debutants-en-programmation-37431 Suite de conway pour étude sur tableau
JavaScript est un langage orienté objet -> dispose d’objets
objets natifs (un nombre, une chaîne de caractères ou même un booléen)
ex : myString contient un objet, et cet objet représente une chaîne de caractères.
C'est la raison pour laquelle on dit que le JavaScript n'est pas un langage typé, car les variables contiennent toujours la même chose : un objet. Mais cet objet peut être de nature différente (un nombre, un booléen…)
constructeur -> exécuter quand on créer un nouvel objet (définitions de variables, nombre de caractères d'une chaîne dans length). géré pour les objets natifs.
propriétés -> variable au sein de l’objet (informations nécessaires au fonctionnement de l’objet -> caractéristique et état)
méthodes -> fonctions contenues dans l’objet (role -> réaliser des opérations sur le contenu de l'objet)
ex : chaine de caractère -> méthode qui met la chaîne de caractères en majuscules
tableau -> une variable qui contient plusieurs valeurs, appelées items.
Chaque item est accessible au moyen d'un indice (commence par 0)
tableau -> une variable qui contient plusieurs valeurs, appelées items.
Chaque item est accessible au moyen d'un indice (commence par 0)
indice -> position d’une valeur (l’item 1 porte l'indice 0, et donc l’item 5 porte l'indice 4).
Le contenu du tableau se définit entre crochets, et chaque valeur est séparée par une virgule
new -> instance un nouvel objet Array
split() va couper la chaîne de caractères à chaque espace -> portions ainsi découpées sont placées dans un tableau
alert(array) -> transforme en une chaîne de caractères grâce à toString() (éléments séparés par virgules)
L'inverse de split() -> tableau vers chaîne de caractères est (join)
À chaque itération, on va avancer d'un item dans le tableau
Le nombre d'items est différent des indices. S'il y a cinq items, comme ici, les indices vont de 0 à 4
inutile de recaluler myArray.length à chaque itération
objet litttéral -> sorte de tableau dont les indices sont remplacés par des identifiants
tableau des prénoms, l'item appelé sister pourrait retourner la valeur « Laurence ».
objet litttéral -> sorte de tableau dont les indices sont remplacés par des identifiants
tableau des prénoms, l'item appelé sister pourrait retourner la valeur « Laurence ».
ajouter un item en spécifiant un identifiant qui n'est pas encore présent
fournir une « variable clé » qui reçoit un identifiant
for in (pas sur les tableaux avec index) car
les fonctions, avec return, ne savent retourner qu'une seule variable. Si on veut retourner plusieurs variables, objets
http://deptinfo.cnam.fr/Enseignement/CycleA/APA/nfa031/docs/corriges-tableaux-1.pdf
Dans cet exercice, on va travailler avec un tableau d’entiers initialisé : int[] tab = {12, 15, 13, 10, 8, 9, 13, 14};
Question 1
Ecrire un programme qui saisit un entier au clavier et qui recherche si cet entier appartient au tableau (réponse de type oui/non).
class Exo6_6_1{
public static void main(String[] args){
int[] tab = {12, 15, 13, 10, 8, 9, 13, 14};
int n;
boolean estLa = false;
Terminal.ecrireString("Entrez le nombre a chercher: "); n = Terminal.lireInt();
for (int i = 0; i<tab.length; i++){ if (tab[i] == n){
estLa = true; }
}
if (estLa){
Terminal.ecrireStringln("Le nombre est dans le tableau"); }else{
Terminal.ecrireStringln("Le nombre n’est pas dans le tableau"); }
} }
- Bug généralement rencontrée en Javascript
Utilisation de la console de développement
Fautes de syntaxe -> signaler par l'interpréteur JavaScript dans la console (facile à résoudre)
Erreurs dans votre algorithme (exécution du code, 0 intelligence)
débogage (consiste à supprimer les bugs qui existent dans votre code)
Vérifier valeurs variables, calculs avec alert() et console.log()
bug algorithmique -> chercher par vous-mêmes où vous avez bien pu vous tromper. méthode simple -> analyser le code pour trouver à quel endroit s'est produit l'erreur.
Si calcul affiche mauvaise valeur -> vérifier ce calcul (si calcul pas en cause alors voir variables utilisés) et remonter de plus en plus vers le haut.
Ouverture avec F12 ou Cmd+Alt+I
- afficher un grand nombre de valeurs
consulter le code HTML généré par du code
analyser des requêtes HTTP (entre autres) effectuées par le navigateur
mesurer les performances de votre code
Dans le cadre du débogage d'erreurs, il est très important de bien externaliser notre code JavaScript car l'affichage des erreurs peut être erroné avec Chrome lorsque le code JS est directement intégré au sein du code HTML.
Indication des erreurs en rouge. SyntaxError mentionne une erreur syntaxique
précision sur l’erreur (différente suivant navigateur). ex, Firefox « SyntaxError: missing ; before statement ». À droite, nom du fichier concerné ainsi que la ligne de code (cliquer pour aller à la ligne qui pose problème)
l'interpréteur JavaScript s'arrête sur la première erreur rencontrée
rectifier l'erreur actuellement indiquée, vous verrez l'erreur suivante sur Chrome : « Uncaught SyntaxError: Unexpected end of input ». Firefox, lui, est un peu plus clair sur ce point : « SyntaxError: missing } after function body ».
remonté des fichiers manquants
console.log() -> afficher valeur d'une variable sans bloquer l'exécution de votre code, contrairement à la fonction alert()
Là où la fonction alert() aurait affiché « [object Object] », console.log() affiche le contenu de l'objet, ce qui est nettement plus pratique
méthodes faites pour déboguer le code et n'ont rien à faire dans votre code fini
ligne qui commence par un chevron bleu > possible d'y écrire directement du code
Une fois le code exécuté, vous allez voir le contenu de la variable apparaître toutes les secondes dans la console. Essayez maintenant d'écrire myVar = ‘Bonjour';
la console ne peut agir que sur les variables qui sont globales !
breakpoints -> bug qui ne se produit que pendant une fraction de seconde (pose généralement problème pour cerner la source du problème)
Suite d'appels de fonctions se nomme une « Pile d’exécution (Call Stack)
Les points d'arrêts servent à étudier la pile d'exécution de notre code.
Aller dans l'onglet « Sources » pour Chrome et « Débogueur » pour Firefox
Raccourci Ctrl + O (ou Cmd + O sous OS X) pour choisir fichier ou poser point d’arrêt (uniquement lignes avec instructions)
cliquez sur numéro de ligne 3 -> icône montrant point d'arrêt sur la ligne
recharger pour ré-exécuter -> mis en pause au point d’arrêt + surlignage en bleu de la ligne
(consulter les variables dans scope actuel)
fonction a() s'apprête à afficher est 2
Continuer avec play
différents étapes (fonctions) ou est passé l’interpréter avant d’arriver au point d’arrêt
fonction la plus récente -> première
voir variables scope pour chaque étape (ex: au clic sur c , value = 0)
conseil pour débugguer : nommer fonction anonyme pour vous répérer
window -> fenêtre du navigateur
window -> fenêtre du navigateur
window -> fenêtre du navigateur
window -> fenêtre du navigateur
comment naviguer entre les différents nœuds qui composent une page HTML
édition du contenu d'une page en ajoutant, modifiant et supprimant des nœuds.
DOM (Document Object Model) -> interface de programmation pour XML et HTML.
interface (API (pour Application Programming Interface), est un ensemble d'outils qui permettent de faire communiquer entre eux plusieurs programmes ou, dans le cas présent, différents langages)
vocabulaire : élément html -> balise html
window -> fenêtre du navigateur (à partir de cet objet que le JavaScript est exécuté)
fonction (alert) -> méthode de window (implicite)
fonctions globales = isNaN(), parseInt() ou encore parseFloat()
variables globales et variable non déclarée avec var -> propriété de l'objet window
conseil -> (toujours utilisé var pour éviter confusion)
IIFE = immediate invoked fonction expression
document -> document est un sous-objet de window (page web)
-> permet accéder aux éléments HTML et les modifier
une page web -> vue comme arbre
notion : enfants, parent, noeud (node), #text (noeud texte)
Accès aux éléments HTML via le DOM avec 3 méthodes: getElementById()
collection d'éléments -> getElementsByTagName() et getElementsByName()
div est un objet de type HTMLDivElement
getElementsByName pour formulaire HTML5 (<input>) , déprécié pour autre (ex: <map>)
querySelector (1er élément) et querySelectorAll(tous les éléments) -> non supportées par les vieux navigateurs (à partir de IE8)
-> simplifier sélection d'éléments dans le DOM (paramètre sélecteur CSS)
Node > sous objet « Element », …
Node (propriétés et de méthodes) utilisées depuis un de ses sous-objets
Element -> composés d'attributs (href de <a>) et contenu (#text ou élément HTML)
Element fournit getAttribute (valeur exacte écrit dans HTML) et setAttribute()
accès aux attributs via propriété (ex : link.href) -> valeur calculé
form propriété value -> valeur d'un champ
class et for (réservé)
-> utiliser className
-> attribut for d’un label -> utiliser htmlFor
plusieurs classes -> couper chaîne avec split()
après IE10 -> classList
innerHTML -> code HTML enfant sous forme de texte
solliciter le moins possible innerHtml (pas dans boucle) -> pb performance
innerText (version non standardisé IE) contentText (version standardisé)
solliciter le moins possible innerHtml (pas dans boucle) -> pb performance
Tester le navigateur (if div.textContent)
http://caniuse.com (méthode supporté par navigateur)