OpenLLM-France/wikimedia huggingface dataset:
# Mathc initiation/Fichiers h : c77dg

Sommaire .. ou ... Les intégrales

## Application cos(x)**m sin(x)**n

Nous allons voir ici quelques applications des identités trigonométriques vue précédemment. Revenez sur ces pages après avoir étudier les intégrales.
* Étude de : <........> cos(x)**m sin(x)**n (m impaire)
* Étude de : <........> cos(x)**m sin(x)**n (n impaire)
* Étude de : <........> cos(x)**m sin(x)**n (m paire n paire)
* Étude de : <........> tan(x)**m sec(x)**n (n paire)
* Étude de : <........> tan(x)**m sec(x)**n (m impaire)
* Étude de : <........> tan(x)**m sec(x)**n (m paire n impaire)
# Mathc initiation/Fichiers h : c77dh

Sommaire .. ou ... Les intégrales

## Application sqrt(a**2-x**2)

Nous allons voir ici quelques applications des identités trigonométriques vue précédemment. Revenez sur ces pages après avoir étudier les intégrales.
* Avec sqrt(a**2 - x**2) ... posons x = a sin(Ø)
* Avec sqrt(a**2 + x**2) ... posons x = a tan(Ø)
* Avec sqrt(x**2 - a**2) ... posons x = a sec(Ø)
# Mathc initiation/Fichiers h : c78a1

Sommaire
Installer ce fichier dans votre répertoire de travail.
Dans ce fichier il y a la déclaration des fichiers h.
# Mathc initiation/Fichiers h : c77dc

Sommaire

## Les formes sin(acos(x))

La trigonométrie est une branche des mathématiques qui traite des relations entre distances et angles dans les triangles et des fonctions trigonométriques telles que sinus, cosinus, tangente.. wikipedia
N'oubliez pas les fichiers *.h voir le Sommaire :
* fe.h < ------------------ > c1e.c
** sin(acos(x)) = sqrt(1-x**2)
* fd.h < ------------------ > c1d.c
** cos(asin(x)) = sqrt(1-x**2)
* fk.h < ------------------ > c1k.c
** sin(atan(x)) = x/sqrt(x**2+1)
* fl.h < ------------------ > c1l.c
** cos(atan(x)) = 1/sqrt(x**2+1)
* ff.h < ------------------ > c1f.c
** sec(atan(x)) = sqrt(1+x**2)
* fg.h < ------------------ > c1g.c
** tan(asec(x)) = sqrt(x**2-1)
* fh.h < ------------------ > c1h.c
** cot(acsc(x)) = sqrt(x**2-1)
* fi.h < ------------------ > c1i.c
** csc(acot(x)) = sqrt(1+x**2)
# Mathc initiation/Fichiers h : c77de

Sommaire

## Les formes sin(x)**2+cos(x)**2

La trigonométrie est une branche des mathématiques qui traite des relations entre distances et angles dans les triangles et des fonctions trigonométriques telles que sinus, cosinus, tangente.. wikipedia
N'oubliez pas les fichiers *.h voir le Sommaire :
* fa.h < ------------------- > c1a.c
** sec(x)**2 - tan(x)**2 = 1
** csc(x)**2 - cot(x)**2 = 1
# Mathc initiation/Fichiers h : c77di

Sommaire .. ou ... Les intégrales

## Application sin(x)**2

Nous allons voir ici quelques applications des identités trigonométriques vue précédemment. Revenez sur ces pages après avoir étudier les intégrales.
* Étude de : <........> sin(x)**n
* Étude de : <........> cos(x)**n
* Étude de : <........> sec(x)**n
* Étude de : <........> csc(x)**n
* Étude de : <........> tan(x)**n
* Étude de : <........> cot(x)**n
# Photographie/Fabricants/Panasonic/Panasonic Lumix DMC-LX2
## Caractéristiques

* Type d'appareil :
* Construction du boîtier :
* Capteur : CCD 10,2 Mpixels avec filtrage des couleurs primaires et coupure de l'infrarouge
* Définition maxi : 4.224 x 2.376
* Formats de fichiers : RAW, JPEG, Motion JPEG Quicktime
* Mémoire interne :
* Cartes-mémoires : SD, SDHC, MMC
* Objectif : Leica Vario-Elmarit, 9 éléments en 8 groupes, 3 surfaces asphériques
* Équivalent 24x36 :
* Champ en position Modèle:Macro :
* Stabilisateur :
* Zoom numérique : x 4
* Diaphragme : 2,8 à 8
* Viseur optique : non
* Écran : LCD 207.000 pixels
* Modes : automatique, P, A, S, M, portrait, peau adoucie, paysage, sports, portrait de nuit, paysage nocturne, autoportrait, nourriture, réunions, bougie, feux d'artifice, ciel étoilé, plage, photo aérienne, neige, haute sensibilité, bébés 1 et 2, vidéo 848 x 480 pixels à 30 images/s
* Mise au point : autofocus 1 point, 3 points ou 9 points, fonctionnement continu ou non, illuminateur
* Obturateur :
* Retardateur : 2 ou 10 s
* Commande de l'exposition : mesure multizones, centrale pondérée, spot
* Correction d'exposition : de -2 à +2 EV par pas de 1/3 EV
* Sensibilité du capteur : automatique, 100, 200, 400, 800, 1600 ISO et mode haute sensibilité 3200 ISO
* Mémorisation de la mesure :
* Balance des blancs : automatique, lumière du jour, ciel nuageux, ombre, halogènes, flash, correction de – 1.500 à + 1.500 K par pas de 150 K (sauf pour le mode automatique en NB)
* Prise de flash extérieur : non
* Flash intégré : automatique, réduction d'yeux rouges, éteint, forcé, portée de 0,6 à 4,9 m (W) et de 0,3 à 2,2 m (T), correction possible de -2 à +2 EV par pas de 1/3 EV
* Connexions :
* Compatibilité DPOF :
* Alimentation : batterie Li-ion 3,7 V 1.150 mAh
* Dimensions :
* Poids :
* Prix :
* Accessoires : logiciels LUMIX Simple Viewer, PhotofunStudio, Silkpix Developer Studio, ArcSoft Camera Suite (ArcSoft PhotoImpression, ArcSoft PanoramaMaker), Adobe Reader, Quick Time, USB Driver
# Calcul écrit/Exercices

* Opérations arithmétiques élémentaires
** Faire une addition à la main
** Faire une soustraction à la main
** Faire une multiplication à la main
** Faire une division à la main
* Calculer une racine
** Calcul de la racine carrée d'un nombre
** Calcul de la racine cubique d'un nombre
** Calcul de la racine quatrième d'un nombre
** Calcul de la racine n-ième d'un nombre
* Opérations sur les polynômes
* Exercices
* Opérations arithmétiques élémentaires
** Faire une addition à la main
** Faire une soustraction à la main
** Faire une multiplication à la main
** Faire une division à la main
* Calculer une racine
** Calcul de la racine carrée d'un nombre
** Calcul de la racine cubique d'un nombre
** Calcul de la racine quatrième d'un nombre
** Calcul de la racine n-ième d'un nombre
* Opérations sur les polynômes
* Exercices
[ Modifier le sommaire ]
Soit $f$ la fonction définie par $f(x)={\frac {2x^{2}-3x+4}{3x^{2}-2x+2}}$.
* Démontrer que $f$ est définie sur $\mathbb {R}$.
* Démontrer que la courbe représentative de $f$ admet une asymptote horizontale en $-\infty$ et en $+\infty$.
* Étudier la position de la courbe par rapport à son asymptote.
# Calcul écrit/Sommaire

* Opérations arithmétiques élémentaires
** Faire une addition à la main
** Faire une soustraction à la main
** Faire une multiplication à la main
** Faire une division à la main
* Calculer une racine
** Calcul de la racine carrée d'un nombre
** Calcul de la racine cubique d'un nombre
** Calcul de la racine quatrième d'un nombre
** Calcul de la racine n-ième d'un nombre
* Opérations sur les polynômes
* Exercices
# Calcul écrit/Faire une multiplication à la main

* Opérations arithmétiques élémentaires
** Faire une addition à la main
** Faire une soustraction à la main
** Faire une multiplication à la main
** Faire une division à la main
* Calculer une racine
** Calcul de la racine carrée d'un nombre
** Calcul de la racine cubique d'un nombre
** Calcul de la racine quatrième d'un nombre
** Calcul de la racine n-ième d'un nombre
* Opérations sur les polynômes
* Exercices
* Opérations arithmétiques élémentaires
** Faire une addition à la main
** Faire une soustraction à la main
** Faire une multiplication à la main
** Faire une division à la main
* Calculer une racine
** Calcul de la racine carrée d'un nombre
** Calcul de la racine cubique d'un nombre
** Calcul de la racine quatrième d'un nombre
** Calcul de la racine n-ième d'un nombre
* Opérations sur les polynômes
* Exercices
[ Modifier le sommaire ]

## Méthode Russe

Exemple : calculons 123*234. De tête, cela est bien entendu impossible. En décomposant un des facteurs en puissances de 10, cela est très laborieux. Voici une méthode simple à mettre en œuvre, une fois comprise :

### On cache les valeurs à gauche et on multiplie

Ça fait 3*4 = 12. On marque 2 et on retient 1.

### On tire le cache vers la droite

On fait la somme des produits en croix : 2*4 + 3*3, auquel on rajoute la retenue : cela fait 8 + 9 + 1 = 18, on marque 8 et on retient 1.

### On re-tire le cache vers la droite

On fait la somme des produits en croix : 1*4 + 2*3 + 3*2, auquel on rajoute la retenue : cela fait 4 + 6 + 6 + 1 = 17, on marque 7 et on retient 1.

### On cache les valeurs à droite

On fait encore la somme des produits en croix : 1*3 + 2*2, auquel on ajoute encore la retenue : cela fait 3 + 4 + 1 = 8, on marque 8.

### On tire le cache vers la droite

Et là on rajoute 2*1 = 2, soit 123*234 = 28782.

### Conclusion

Cette méthode permet de faire des multiplications sans calculatrice. Cela marche avec des valeurs plus grandes ou plus petites. Pour faire 2451*26, on pose :
Et on applique la méthode, en complétant avec des zéros le nombre ayant le moins de chiffres :
# Néerlandais/Pour adultes/Progressons pas à pas

* Le néerlandais
* Découvrons: Pour commencer...
* La phonologie du néerlandais (Prononcer, lire et écrire)
* Le guide de conversation
* Apprenons: Progressons pas à pas
* La grammaire
* Travaillons: Le néerlandais des affaires
* Cultivons: Le néerlandais vivant!
| Leçon | Dialogue | Quiz | Thème | Grammaire | Prononc./Ortho. |
| Leçon 1: Se saluer | 1+1audio | 1 | Dag! | Pronoms pers. | Les voyelles, doublement |
| Leçon 2: Se présenter | 2+1audio | | Naam, voornaam | Présent | Accent tonique |
| Leçon 3: Être et avoir | 1 | 1 | Zijn hebben | Participes | Les consonnes |
| Leçon 4: Quelle heure est-il? | 3 | | Hoe laat is het? | Les conjonctions, l'article | |
| Leçon 5: La météo | 2+1audio | | Het weer | verbes à particules séparables | "-ie-, -ij-, -ei" |
| Leçon 6: La maison | 1 | | Het huis | L'adjectif | Les diphtongues |
| Leçon 7: Les hobbys | 1+audio | | Hobby's | L'inversion; le pluriel | "d" intervocalique |
| Leçon 8: L'automne | 1 | | De herfst | Le passé en -de(n) | |
| Leçon 9: La modalité | 1 | | Weg moeten | Remplacement (verbes modaux) l'adverbe prépositionnel |
Néerlandais - navigation
Progressons pas à pas : Les leçons :
| Introduction | Leçon 1 | Leçon 2 | Leçon 3 | Leçon 4 | Leçon 5 | Leçon 6 | Leçon 7 | Leçon 8 | Leçon 9 |
| | Se saluer | Se présenter | Être et avoir | Quelle heure est-il? | La météo | La maison | Les hobbys | L'automne | La modalité |
| Guide de conversation ||||||||||
| Salutations | Se présenter | La politesse | Demander son chemin | Les nombres | Les couleurs | Les pays | Le temps | Depuis | Les mois |
| Dans le secondaire ||||||||||
| Se présenter | La nourriture | La ville | La maison | Les hobbys | Les animaux | Les transports | La météo | Les vacances | Les repas |
| Les fruits | L'école | Les mathématiques | Le téléphone | L'agence immobilière | Les vêtements | Le restaurant | L'itinéraire | Le corps humain | Les villes belges |
| Le paysage | La famille | Indiquer l'heure | Vouloir | Parler | Pouvoir et savoir | Devoir | Il y a |
| Grammaire ||||||||||
| "Er" et le remplacement pronominal | Le pronom personnel | Le pronom possessif | Le pronom démonstratif | Le pronom interrogatif | Le pronom relatif | Le pronom indéfini | Le pronom réciproque |
| Le nom | Le diminutif | Le puriel | L'adjectif | L'adverbe | L'adverbe prépositionnel | Le complément prépositionnel | Le numéral |
| Le verbe | L'infinitif | Les verbes à particules séparables |
| Avancé ||||||||||
| La maison | Légumes | Les repas | Le vocabulaire grammatical |
| Phonologie ||||||||||
| Syllabes |
# Mathc initiation/c35a4

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dxdzdy
# Mathc initiation/c35a8

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dzdydx
# Mathc initiation/c35a5

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dydxdz
# Mathc initiation/c35a3

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dxdydz
# Mathc initiation/c35a6

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dydzdx
# Mathc initiation/c35a7

Sommaire
Installer ce fichier dans votre répertoire de travail.
Les fonctions pour calculer les intégrales de la forme dzdxdy
# Programmation C-C++/Rupture de séquence

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Les structures de contrôle ||
| | La structure if |
| | La boucle for |
| | Le while |
| | Le do |
| | Branchement conditionnel |
| | Le saut |
| | Rupture de séquence |
| Livre original de C. Casteyde ||

## Les commandes de rupture de séquence

En plus du goto vu précédemment, il existe d'autres commandes de rupture de séquence (c'est-à-dire de changement de la suite des instructions à exécuter). Ces commandes sont les suivantes :
ou
ou
return permet de quitter immédiatement la fonction en cours. Comme on l'a déjà vu, la commande return peut prendre en paramètre la valeur de retour de la fonction.
break permet de passer à l'instruction suivant l'instruction while, do, for ou switch la plus imbriquée (c'est-à-dire celle dans laquelle on se trouve).
continue saute directement à la dernière ligne de l'instruction while, do ou for la plus imbriquée. Cette ligne est l'accolade fermante. C'est à ce niveau que les tests de continuation sont faits pour for et do, ou que le saut au début du while est effectué (suivi immédiatement du test). On reste donc dans la structure dans laquelle on se trouvait au moment de l'exécution de continue, contrairement à ce qui se passe avec le break.
# Programmation C-C++/Priorités des opérateurs

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/cpp/cours/online/book1.html qui le fournit sous licence GFDL.
Cours de C/C++ :
| Le langage ||
| | Première approche |
| | Les structures de contrôle |
| | Types avancés |
| | Pointeurs et références |
| | Le préprocesseur |
| | Modularité et compilation |
| | Écrire du code illisible |
| | C++ : La couche objet |
| | C++ : Les exceptions |
| | Identification des types |
| | Les espaces de nommage |
| | Les templates |
| La bibliothèque standard ||
| | Notions de base |
| | Les types complémentaires |
| | Les flux d'entrée / sortie |
| | Les locales |
| | Les conteneurs |
| | Les algorithmes |
| Conclusion ||
| Priorités des opérateurs ||
| Draft Papers ||
| Bibliographie ||
| Livre original de C. Casteyde Modifier le modèle ||
Cette annexe donne la priorité des opérateurs du langage C++, dans l'ordre décroissant. Cette priorité intervient dans l'analyse de toute expression et dans la détermination de son sens. Cependant, l'analyse des expressions peut être modifiée en changeant les priorités à l'aide de parenthèses.
# Programmation C-C++/Structures de contrôle

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Les structures de contrôle ||
| | La structure if |
| | La boucle for |
| | Le while |
| | Le do |
| | Branchement conditionnel |
| | Le saut |
| | Rupture de séquence |
| Livre original de C. Casteyde ||
Nous allons aborder dans ce chapitre un autre aspect du langage indispensable à la programmation, à savoir : les structures de contrôle. Ces structures permettent, comme leur nom l'indique, de contrôler l'exécution du programme en fonction de critères particuliers. Le C et le C++ disposent de toutes les structures de contrôle classiques des langages de programmation comme les tests, les boucles, les sauts, etc. Toutes ces structures sont décrites dans les sections suivantes.
# Programmation C-C++/Types avancés

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/cpp/cours/online/book1.html qui le fournit sous licence GFDL.
Cours de C/C++ :
| Le langage ||
| | Première approche |
| | Les structures de contrôle |
| | Types avancés |
| | Pointeurs et références |
| | Le préprocesseur |
| | Modularité et compilation |
| | Écrire du code illisible |
| | C++ : La couche objet |
| | C++ : Les exceptions |
| | Identification des types |
| | Les espaces de nommage |
| | Les templates |
| La bibliothèque standard ||
| | Notions de base |
| | Les types complémentaires |
| | Les flux d'entrée / sortie |
| | Les locales |
| | Les conteneurs |
| | Les algorithmes |
| Conclusion ||
| Priorités des opérateurs ||
| Draft Papers ||
| Bibliographie ||
| Livre original de C. Casteyde Modifier le modèle ||

## Les pointeurs et références

Les pointeurs sont des variables très utilisées en C et en C++. Ils doivent être considérés comme des variables, il n'y a rien de sorcier derrière les pointeurs. Cependant, les pointeurs ont un domaine d'application très vaste.
Les références sont des identificateurs synonymes d'autres identificateurs, qui permettent de manipuler certaines notions introduites avec les pointeurs plus souplement. Elles n'existent qu'en C++.

## Parlons d'abord de Pointeurs

Voici un exemple de pointeur : int * pp; signifie que pp est une variable qui contient un pointeur vers un entier, ou encore contient l'adresse d'un nombre entier. On peut se poser la question, pour préciser le type pointé, ici int (entier), simplement par ce que le système fait des calculs d'adresse et doit connaître le déplacement à faire pour trouver l’élément suivant.
Regardons la différence entre les codes suivants :
Ici nb1 reçoit l'adresse du tableau nbReel, qu on peut aussi écrire nb1 = &nbReel[0]
nb1 + 1 est l’adresse du suivant. C'est-à-dire de nbReel[1], pour se fixer les idées, supposons que le tableau nbReel est implémenté en mémoire à l'adresse 1200, qui est donc l'adresse de nbReel[0], alors l'adresse de nbReel[1] est 1208 (ou encore nb1+1 est 1208), on ajoute 8, parce que la taille d'un nombre "double" est 8 octets (bytes). maintenant supposons que l'adresse de nbEnt[0] (même chose que nbEnt) soit 2200 alors adresse de nbEnt[1] est 2204, car la taille d'un entier est 4 octets. C'est-à-dire nb2 + 1 est 2204.
De plus maintenant que le pointeur nb1 contient l'adresse de début de zone nbReel, on peut accéder à n'importe quel élément du tableau NbReel avec le pointeur nb1, par exemple : *nb1 représente l'objet pointe par nb1, c'est-à-dire valeur 10.5.
Et *(nb1+1) représente l'objet pointe par nb1 +1, c'est-à-dire valeur suivante : 17.5. Attention à la parenthèse ! *nb1 + 1 : veut dire on ajoute 1 à l'objet pointe par nb1 (on ajoute 1 au nombre réel 10.5 : ce qui donne 11.5).
# Mathc matrices/a22

Application

## Produit scalaire sur R$^n$ généré par A

Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
* dot_au.h ........... Déclaration des fichiers h
Dans ce produit scalaire la matrice A est une matrice aléatoire inversible.
La QR décomposition ce passe bien.
Avec une matrice A orthonormal (c00k.c), on peut calculer les valeurs propres. (A * A_T = Id)
Avec une matrice A aléatoire cela ce passe mal.
Présentation des fonction intermédiaire :
* Le produit scalaire : dot_Au_R(A,u,v);
* La norme : norm_Au_R(A,u);
* La norme : ||n_u|| = 1
* La distance : dist_Au_R(A,u,v)
* Le projeté de u sur v : proj_Au_mR(A,u,v,projuv);
* Propriété ................. : <v,u-projuv> = -0.000000
* Algorithme de Gram-Schmidt : orth_Au_mR(A,U,Orth);
* Algorithme de Gram-Schmidt : Normalize_Au_mR(A,Orth);
* QR Unxn ............................... : QR_Au_mR(A,U,Q,R);
* QR Unxm (n>m) ................... : QR_Au_mR(A,U,Q,R);
* A, une matrice orthonormale : eigs_value_Au_mR(A,U,EigsValue1);
# Mathc matrices/a219

Application
En étudiant le circuit dans le sens des aiguilles d'une montre, nous pouvons écrire :
Le code en langage C :
La solution est donné par la résolution du système :
# Mathc matrices/a221

Application
En étudiant le circuit dans le sens des aiguilles d'une montre, nous pouvons écrire :
Le code en langage C :
La solution est donné par la résolution du système :
# Programmation JavaScript/Syntaxe

* Introduction
    Programmer en deux minutes
*   * Page wiki
*   * Compteur en temps réel
*   * Site dans un document
* Outils de développement
* Syntaxe
** Ligne d'instruction
** Ordre d'évaluation
** Bloc d'instructions
** Identificateurs
** Expression littérale
** Commentaire
** Mots réservés
** Variables
** Opérateurs
** Structures de contrôle
** Exceptions et erreurs
** Fonctions utilisateur
** Évènement
* Objets prédéfinis
** window
** document
** navigator
** Array
** Boolean
** Date
** Error
** Function
** Math
** Number
** Object
** String
** Element
** RegExp
* Fonctions prédéfinies
* Programmation avancée
** Opérateurs de bits
** Fermeture
** Programmation objet
** Notation JSON
** AJAX
** Stockage
** Générateurs
** Interface DOM
** Objets Microsoft
* Frameworks
** Dojo
    Hello World
    Widgets
    Ressources
** jQuery
** Node.js
** React.js
* Tests
** Ava
** Jest
** Cypress
* Débogage
* Erreurs connues
* Références
* Introduction
    Programmer en deux minutes
*   * Page wiki
*   * Compteur en temps réel
*   * Site dans un document
* Outils de développement
* Syntaxe
** Ligne d'instruction
** Ordre d'évaluation
** Bloc d'instructions
** Identificateurs
** Expression littérale
** Commentaire
** Mots réservés
** Variables
** Opérateurs
** Structures de contrôle
** Exceptions et erreurs
** Fonctions utilisateur
** Évènement
* Objets prédéfinis
** window
** document
** navigator
** Array
** Boolean
** Date
** Error
** Function
** Math
** Number
** Object
** String
** Element
** RegExp
* Fonctions prédéfinies
* Programmation avancée
** Opérateurs de bits
** Fermeture
** Programmation objet
** Notation JSON
** AJAX
** Stockage
** Générateurs
** Interface DOM
** Objets Microsoft
* Frameworks
** Dojo
    Hello World
    Widgets
    Ressources
** jQuery
** Node.js
** React.js
* Tests
** Ava
** Jest
** Cypress
* Débogage
* Erreurs connues
* Références
[ Modifier le sommaire ]
Les deux grandes structures du langage sont les instructions et les structures de contrôle, qui toutes deux contiennent des expressions.
La syntaxe du JavaScript est largement inspirée des langages C et Java. Il faut ajouter à cela le fait que la plupart des opérateurs utilisent les mêmes noms ou symboles que dans ces langages.
L'avantage de cette similarité de forme est qu'elle permet de s'appuyer sur ce que l'on connaît déjà dans ces langages très répandus pour coder ou pour lire en JavaScript, ou réciproquement.
L'inconvénient est que cette similarité de forme dissimule des différences nombreuses, subtiles ou fondamentales, et des fonctionnalités inexistantes dans les langages classiques auxquels on est tenté de comparer le JavaScript. Et inversement, on peut vouloir appliquer en JavaScript des mots et des syntaxes propres à ces langages qui lui ressemblent, et être déçu de leur absence.
# Programmation Java Swing/Actions

* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
[ Modifier le sommaire ]
Une action permet de préconfigurer plusieurs propriétés. Quand un composant (JRadiobutton, JButton, JMenuItem, ...) est lié à une action, ses propriétés suivent l'évolution de celles de l'action. Notamment, cela permet de désactiver/activer une action, de configurer un listener d'action (ActionListener) une seule fois. Cela est pratique quand une même action est disponible à la fois dans un menu et par un bouton, par exemple.
Exemple pour une action de menu, ou de bouton :