fonction : mettre en paramètre une propriété d'un objet

Version imprimable

Bonjour,
je voudrais mettre en paramètre d'une fonction la propriété d'un objet est il possible ?
J'ai essayé :
Code:

1 2 3 4 5 6 7 8 9 tempsSimples(parametre) { let resultat; if(this.verbe ==='essere'){ resultat = this.essere.parametre } else if (this.verbe ==="avoir") { resultat = this.avoir.parametre; } return resultat; }
Code:

tempsSimples(indicatif.present)

je voudrais obtenir en retour par ex. si j'ai la condition 'essere' : verbe.etre.indicatif.present
J'ai essayé aussi avec de creer deux variable puis une concatenation avec au milieu "." mais echec:D
merci pour votre aide

Bonjour,

Si "indicatif" est un nom de propriété, vous pourriez peut-être tenter quelque chose comme ça?
Code:

1 2 3 4 5 6 7 // classe machin tempsAPeinePlusSimples(mode, temps) { return this[this.verbe][mode][temps]; } // à appeler comme ceci: const test = maConjugaison.tempsAPeinePlusSimples("indicatif", "present");
Mais je suis peut-être à côté de la plaque? :aie:

bonsoir,
je pense que je me suis mal expliqué et mes termes ne sont pas exactes "indicatif" et "present" ne sont pas des propriétés mais les clefs de mon JSON(j'espere que je ne me trompe pas encore de termes:D)
Code:

1 2 3 4 5 6 7 8 9 10 let verbeEtre ={ "indicatif": { "present": [ "sono", "sei", "é", "siamo", "siete", "sono" ] etc.
puis let verbeAvoir =... , la meme chose mais la conjugaison change:D

mon constructeur de la classe :
Code:

1 2 3 constructor(verbe) { this.verbe = verbe; }
je crée mon objet : let verbe =new Maclasse(...),
Pour atteindre le présent :verbe.etre.indicatif.present[i]
Dans ma classe je voudrais créer une fonction avec une condition
Code:

1 2 3 4 5 6 7 8 9 tempsSimples(parametre) { let resultat; if(this.verbe ==='essere'){ resultat = this.essere.parametre } else if (this.verbe ==="avoir") { resultat = this.avoir.parametre; } return resultat; }
:
je voudrais qu'avec cette condition on bascule d'un verbe à l'autre (verbe.avoir ou verbe.etre) et que je puisse mettre comme argument de la fonction tempsSimples(indicatif.present) et à la fin cela fasse verbe.etre.indicatif.present
Merci et désolé pour mes explication trop longues et imprécises sur termes techniques.
Bon W.E.

Citation:

Envoyé par Matteo53

je pense que je me suis mal expliqué et mes termes ne sont pas exactes "indicatif" et "present" ne sont pas des propriétés mais les clefs de mon JSON(j'espere que je ne me trompe pas encore de termes:D)

En fait ce n'est pas un JSON : si on écrit let verbeEtre ={...} alors verbeEtre est un objet et cela doit se trouver dans un fichier .js.

Citation:

Envoyé par Matteo53

je voudrais qu'avec cette condition on bascule d'un verbe à l'autre (verbe.avoir ou verbe.etre) et que je puisse mettre comme argument de la fonction tempsSimples(indicatif.present) et à la fin cela fasse verbe.etre.indicatif.present

Si on utilise cette syntaxe : verbe.avoir / verbe.etre cela suppose que verbe soit un objet ayant avoir et etre comme propriété.

Mais si on a ceci :
Code:

1 2 3 4 5 6 7 8 9 10 let verbeEtre ={ "indicatif": { "present": [ "sono", "sei", "é", "siamo", "siete", "sono" ] etc.
Alors pour accéder à la conjugaison du verbe etre au present de l'indicatif il faudrait écrire : verbeEtre.indicatif.present et non verbe.etre.indicatif.present.
Citation:
Envoyé par Matteo53
Dans ma classe je voudrais créer une fonction avec une condition
Code:

1 2 3 4 5 6 7 8 9 tempsSimples(parametre) { let resultat; if(this.verbe ==='essere'){ resultat = this.essere.parametre } else if (this.verbe ==="avoir") { resultat = this.avoir.parametre; } return resultat; }
Si verbeEtre et verbeAvoir sont des propriétés de la classe alors on peut utiliser l'idée de houd.ini et modifier la fonction comme ceci :
Code:

1 2 3 4 5 6 7 8 9 tempsSimples(mode, temps) { let resultat; if(this.verbe ==='essere'){ resultat = this.verbeEtre[mode][temps] } else if (this.verbe ==="avoir") { resultat = this.verbeAvoir[mode][temps]; } return resultat; }
Et pour obtenir la conjugaison du verbe etre au present de l'indicatif on écrit : tempsSimples("indicatif", "present") et si on veut stocker le résultat dans (par exemple) la variable verbe_etre_indicatif_present on écrit : let verbe_etre_indicatif_present = tempsSimples("indicatif", "present").

C'est plus polyvalent de faire comme cela : on peut du coup utiliser la même fonction pour tous les modes et temps.

1 pièce(s) jointe(s)

Citation:

Envoyé par Beginner.

C'est plus polyvalent de faire comme cela : on peut du coup utiliser la même fonction pour tous les modes et temps.

On pourrait même faire quelque chose de plus général encore avec une fonction conjugue(verbe, mode, temps) :

Et on pourrait même se passer des class, des modules, de fetch... (on utilise des variables globales)

auxiliaires.html

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!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.0">
      <title>Verbi prima categoria</title>  
 
      <script src="data.js"></script>
      <script src="auxiliaires.js"></script>
    </head>
  <body>
 
 
  </body>
  </html>

data.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
let conjugaisons = {
  "etre": {
    "indicatif": {
      "present": ['sono', 'sei', 'é', 'siamo', 'siete', 'sono'],
      "imparfait": ['ero', 'eri', 'era', 'eravamo', 'eravate', 'erano'],
      "passeSimple": ['fui', 'fosti', 'fu', 'fummo', 'foste', 'furono'],
      "futurSimple": ['sarò', 'sarai', 'sarà', 'saremo', 'sarete', 'saranno']
    },
    "conditionnel": {
      "present": ['sarei', 'saresti', 'sarebbe', 'saremmo', 'sareste', 'sarebbero']
    },
    // ... etc
  },
 
  "avoir": {
    "indicatif": {
      "present": ['ho', 'hai', 'ha', 'abbiamo', 'avete', 'hanno'],
      "imparfait": ['avevo', 'avevi', 'aveva', 'avevamo', 'avevate', 'avevano'],
      "passeSimple": ['ebbi', 'avesti', 'ebbe', 'avemmo', 'aveste', 'ebbero'],
      "futurSimple": ['avrò', 'avrai', 'avrà', 'avremo', 'avrete', 'avranno']
    },
    "conditionnel": {
      "present": ['avrei', 'avresti', 'avrebbe', 'avremmo', 'avreste', 'avrebbero']
    },
    // ... etc
  }
}

auxiliaires.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// La fonction générale qui utilise l'objet 'conjugaisons'  (variable globale)
// contenu dans le fichiers data.js
function conjugue(verbe, mode, temps) {
    return conjugaisons[verbe][mode][temps]
}
 
 
// Exemples d'usage de la fonction :
 
// verbe etre au présent de l'indicatif : 
let verbe_etre_indicatif_present = conjugue("etre", "indicatif", "present")
console.log("verbe etre au present de l'indicatif :\n", verbe_etre_indicatif_present);
 
// verbe etre à l'imparfait de l'indicatif : 
let verbe_etre_indicatif_imparfait = conjugue("etre", "indicatif", "imparfait")
console.log("verbe etre à l'imparfait de l'indicatif :\n", verbe_etre_indicatif_imparfait);
 
 
// verbe avoir au présent de l'indicatif : 
let verbe_avoir_indicatif_present = conjugue("avoir", "indicatif", "present")
console.log("verbe avoir au present de l'indicatif :\n", verbe_avoir_indicatif_present);
 
// verbe avoir à l'imparfait de l'indicatif : 
let verbe_avoir_indicatif_imparfait = conjugue("avoir", "indicatif", "imparfait")
console.log("verbe avoir à l'imparfait de l'indicatif :\n", verbe_avoir_indicatif_imparfait);

On obtient ce résultat :

Pièce jointe 636650

01/04/2023, 15h51
Matteo53

ah oui merci pour vos explications détaillés. Concernant ma première question je n'avais pas pensé que je pouvais utiliser comme accesseur [] au lieu de . et mettre les paramètres à l'intérieur de []. J'ai essayé et cela marche..
Je voudrais aussi vous remercier pour le conseil de créer une variable globale pour simplifier le code.
Vraiment merci c'est des conseils précieux pour avancer et apprendre.
bon w.e.

Citation:

Envoyé par Matteo53

Je voudrais aussi vous remercier pour le conseil de créer une variable globale pour simplifier le code.

Oui dans ce cas cela simplifie le code mais en général il ne faut pas abuser des variables globales pour éviter la pollution...

Du coup si on veut utiliser beaucoup de variables globales il vaut mieux utiliser un seul objet global pour toute son application et alors on peut ajouter toutes les variables que l'on veut à cet objet.

Au lieu d'écrire ceci :
Code:

1 2 3 4 5 6 7 let conjugaisons = { "etre": {...}, "avoir": {...}, // ... etc } }
On pourrait faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 // 'apprendreItalien' est un objet global pour toute l'application window.apprendreItalien = {} // On ajoute l'objet 'conjugaisons' à l'objet global 'apprendreItalien' apprendreItalien.conjugaisons = { "etre": {...}, "avoir": {...}, // ... etc } }
Ensuite on modifie légèrement la fonction conjugue :
Code:

1 2 3 4 5 6 7 // La fonction générale qui utilise l'objet 'conjugaisons'... // l'objet 'conjugaisons' est une propriété de l'objet global 'apprendreItalien' // l'objet global 'apprendreItalien' est défini dans le fichier data.js function conjugue(verbe, mode, temps) { return apprendreItalien.conjugaisons[verbe][mode][temps] }
Au final on n'a qu'à seul objet global à savoir : apprendreItalien
L'objet conjugaisons n'est pas un objet global, c'est une propriété de l'objet global apprendreItalien.

On peut ajouter autant d'objets que l'on veut à l'objet global apprendreItalien et tous ces objets seront des propriétés de l'objet global apprendreItalien.

02/04/2023, 10h03
Matteo53
Bonjour,
C'est un vrais cours que je vais garder et utiliser. En continuant sur l'objet global j'ai encore une deux questions ?:D
Si on ne veut pas mettre toutes les propriétés dans un seul fichier .js et avoir plusieurs fichiers (pour mieux structurer le code) avec des propriétés du même l'objet :
Code:

1 2 // 'apprendreItalien' est un objet global pour toute l'application window.apprendreItalien = {}
Sauf erreur de ma part suffit de mettre dans mon html autant de balises <script> que de fichiers et il n'y a pas besoin d'import de l'objet ?
Puis je utiliser une propriété ou une fonction d'un objet dans plusieurs fichiers? pas besoin de faire un import de ceux ci comme les modules ?
Mes deux questions se rejoignent, comment interchanger l'objet, les propriétés et les fonctions entre fichiers .JS pour éviter la répétition du code?
La dernière question que je me pose : comment on fait le choix entre un objet global ou une classe ? ou bien c'est complémentaire ?
merci encore de transmettre vos connaissances.
Bonne journée

Citation:

Envoyé par Matteo53

Sauf erreur de ma part suffit de mettre dans mon html autant de balises <script> que de fichiers et il n'y a pas besoin d'import de l'objet ?

Oui il n'y a pas besoin d'importer les fichiers puisqu’ils sont chargés via les balises <script>.

Par contre il y a quand même une règle à suivre : on ne peut mettre les balises <script> dans n'importe quel ordre, par exemple on ne peut mettre la balise : <script src="auxiliaires.js"></script> avant la balise <script src="data.js"></script> car dans le fichier auxiliaires.js on utilise l'objet global apprendreItalien qui est défini dans le fichier data.js.

Il faut donc mettre les balises dans un ordre tel que l'on évite d'utiliser un objet avant qu'il soit défini...

Citation:

Envoyé par Matteo53

Puis je utiliser une propriété ou une fonction d'un objet dans plusieurs fichiers? pas besoin de faire un import de ceux ci comme les modules ?

Oui à condition que l'objet en question soit global.

Voici un exemple où je dispatche le code précédent dans plusieurs fichier .js (voir les commentaires pour les explications...):

auxiliaires.html

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!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.0">
      <title>Verbi prima categoria</title>        
 
      <script src="main.js"></script>      
      <script src="conjugaisons.js"></script>
      <script src="fonctions.js"></script>
      <script src="auxiliaires.js"></script>
    </head>
  <body>
 
 
  </body>
  </html>

main.js

Code:

1
2
// 'apprendreItalien' est un objet global pour toute l'application
window.apprendreItalien = {}

conjugaisons.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// On ajoute l'objet 'conjugaisons' à l'objet global 'apprendreItalien'
// l'objet global 'apprendreItalien' est défini dans le fichier main.js qui est chargé avant ce présent fichier (conjugaisons.js)
// on peut donc l'utiliser dans ce présent fichier  (conjugaisons.js)...
 
apprendreItalien.conjugaisons = {
  "etre": {
    "indicatif": {
      "present": ['sono', 'sei', 'é', 'siamo', 'siete', 'sono'],
      "imparfait": ['ero', 'eri', 'era', 'eravamo', 'eravate', 'erano'],
      "passeSimple": ['fui', 'fosti', 'fu', 'fummo', 'foste', 'furono'],
      "futurSimple": ['sarò', 'sarai', 'sarà', 'saremo', 'sarete', 'saranno']
    },
    "conditionnel": {
      "present": ['sarei', 'saresti', 'sarebbe', 'saremmo', 'sareste', 'sarebbero']
    },
    // ... etc
  },
 
  "avoir": {
    "indicatif": {
      "present": ['ho', 'hai', 'ha', 'abbiamo', 'avete', 'hanno'],
      "imparfait": ['avevo', 'avevi', 'aveva', 'avevamo', 'avevate', 'avevano'],
      "passeSimple": ['ebbi', 'avesti', 'ebbe', 'avemmo', 'aveste', 'ebbero'],
      "futurSimple": ['avrò', 'avrai', 'avrà', 'avremo', 'avrete', 'avranno']
    },
    "conditionnel": {
      "present": ['avrei', 'avresti', 'avrebbe', 'avremmo', 'avreste', 'avrebbero']
    },
    // ... etc
  }
}

fonctions.js

Code:

1
2
3
4
5
6
7
8
9
10
// La fonction générale qui utilise l'objet 'conjugaisons'...
// l'objet 'conjugaisons' est une propriété de l'objet global 'apprendreItalien'
// l'objet global 'apprendreItalien' est défini dans le fichier main.js qui est chargé avant ce présent fichier (fonctions.js)
// on peut donc l'utiliser dans ce présent fichier  (fonctions.js)...
 
// On ajoute la fonction 'conjugue' à l'objet 'apprendreItalien'
 
apprendreItalien.conjugue = function (verbe, mode, temps) {
    return apprendreItalien.conjugaisons[verbe][mode][temps]
}

auxiliaires.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Ici on peut utiliser la fonction  'conjugue' car elle définie juste avant dans le fichier fonctions.js...
// Exemples d'usage de la fonction 'conjugue':
 
// verbe etre au present de l'indicatif : 
let verbe_etre_indicatif_present = apprendreItalien.conjugue("etre", "indicatif", "present")
console.log("verbe etre au present de l'indicatif :\n", verbe_etre_indicatif_present);
 
// verbe etre à l'imparfait de l'indicatif : 
let verbe_etre_indicatif_imparfait = apprendreItalien.conjugue("etre", "indicatif", "imparfait")
console.log("verbe etre à l'imparfait de l'indicatif :\n", verbe_etre_indicatif_imparfait);
 
 
// verbe avoir au present de l'indicatif : 
let verbe_avoir_indicatif_present = apprendreItalien.conjugue("avoir", "indicatif", "present")
console.log("verbe avoir au present de l'indicatif :\n", verbe_avoir_indicatif_present);
 
// verbe avoir à l'imparfait de l'indicatif : 
let verbe_avoir_indicatif_imparfait = apprendreItalien.conjugue("avoir", "indicatif", "imparfait")
console.log("verbe avoir à l'imparfait de l'indicatif :\n", verbe_avoir_indicatif_imparfait);

Citation:

Envoyé par Matteo53

Mes deux questions se rejoignent, comment interchanger l'objet, les propriétés et les fonctions entre fichiers .JS pour éviter la répétition du code?

J'ai donné un exemple juste ci-dessus... On peut utiliser tous ce qui a été défini autant de fois que l'on veut dans plusieurs fichiers... Il faut juste faire attention à ne pas utiliser un objet, une variable, une class... avant sa définition...

03/04/2023, 00h19
Beginner.

Suite du message précédent...

Citation:

Envoyé par Matteo53

La dernière question que je me pose : comment on fait le choix entre un objet global ou une classe ? ou bien c'est complémentaire ?

L'un ne s'oppose pas à l'autre, si on souhaite utiliser une class on peut très bien le faire et on n'aura pas besoin d'ajouter cette class à l'objet global 'apprendreItalien' car les class sont accessibles comme les variables globales sans polluer l'espace global.

Je donnerais un exemple du code précédent avec une class...
03/04/2023, 14h01
Matteo53

Bonjour,
tout est claire, vous avez détaillé avec précision et clarté.
Je vous remercie de nous transmettre tout cela et de nous consacrer de votre temps.
Je vais faire des copier/coller et garder ce cours:D
Bonne journée

Salut,

Citation:

Envoyé par Beginner.

Je donnerais un exemple du code précédent avec une class...

Voici comme promis un exemple ci-dessous, j'ai repris et modifié la class Verbes :

auxiliaires.html

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!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.0">
      <title>Verbi prima categoria</title>        
 
      <script src="verbes.js"></script>            
      <script src="auxiliaires.js"></script>
    </head>
  <body>
 
 
  </body>
  </html>

verbes.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class Verbes {
 
    /** verbe utilisateur
     * @param {string} verbe 
     */
    constructor(verbe) {
        this.verbe = verbe;
        this.init()
    }
 
    init() {
        this.pronomsP = ["io", "tu", "lui/lei", "noi", "voi", "loro"];
        this.conjugaisons = {
            "etre": {
                "indicatif": {
                    "present": ['sono', 'sei', 'é', 'siamo', 'siete', 'sono'],
                    "imparfait": ['ero', 'eri', 'era', 'eravamo', 'eravate', 'erano'],
                    "passeSimple": ['fui', 'fosti', 'fu', 'fummo', 'foste', 'furono'],
                    "futurSimple": ['sarò', 'sarai', 'sarà', 'saremo', 'sarete', 'saranno']
                },
                "conditionnel": {
                    "present": ['sarei', 'saresti', 'sarebbe', 'saremmo', 'sareste', 'sarebbero']
                },
                // ... etc
            },
 
            "avoir": {
                "indicatif": {
                    "present": ['ho', 'hai', 'ha', 'abbiamo', 'avete', 'hanno'],
                    "imparfait": ['avevo', 'avevi', 'aveva', 'avevamo', 'avevate', 'avevano'],
                    "passeSimple": ['ebbi', 'avesti', 'ebbe', 'avemmo', 'aveste', 'ebbero'],
                    "futurSimple": ['avrò', 'avrai', 'avrà', 'avremo', 'avrete', 'avranno']
                },
                "conditionnel": {
                    "present": ['avrei', 'avresti', 'avrebbe', 'avremmo', 'avreste', 'avrebbero']
                },
                // ... etc
            }
        }
    }
 
    /**  
     * @param {string} mode
     * @param {string} temps
     * @returns {string[]}
     */
    conjugue = function(mode, temps) {
        return this.conjugaisons[this.verbe][mode][temps]
    }
 
}

auxiliaires.js

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Exemple d'usage de la class 'Verbes' :
// avec le verbe 'etre' en paramètre :
 
let verbe_etre = new Verbes("etre")
 
// verbe etre au présent de l'indicatif : 
let verbe_etre_indicatif_present = verbe_etre.conjugue("indicatif", "present")
console.log("verbe etre au present de l'indicatif :\n", verbe_etre_indicatif_present);
 
// verbe etre à l'imparfait de l'indicatif : 
let verbe_etre_indicatif_imparfait = verbe_etre.conjugue("indicatif", "imparfait")
console.log("verbe etre à l'imparfait de l'indicatif :\n", verbe_etre_indicatif_imparfait);
 
// Autre exemple d'usage de la class 'Verbes' :
// avec le verbe 'avoir' en paramètre :
 
let verbe_avoir = new Verbes("avoir")
 
// verbe avoir au présent de l'indicatif : 
let verbe_avoir_indicatif_present = verbe_avoir.conjugue("indicatif", "present")
console.log("verbe avoir au present de l'indicatif :\n", verbe_avoir_indicatif_present);
 
// verbe avoir à l'imparfait de l'indicatif : 
let verbe_avoir_indicatif_imparfait = verbe_avoir.conjugue("indicatif", "imparfait")
console.log("verbe avoir à l'imparfait de l'indicatif :\n", verbe_avoir_indicatif_imparfait);

03/04/2023, 18h16
NoSmoking

Bonjour,
cela ne me paraît pas être un bon exemple :mrgreen:, tu embarques les données de tous les objets potentiellement réalisés.

Ton new Verbes("avoir") possède les données de ton new Verbes("etre"), autant rester sur un namespace.
03/04/2023, 19h56
Beginner.

Salut,

Citation:

Envoyé par NoSmoking

Bonjour,
cela ne me paraît pas être un bon exemple :mrgreen:, tu embarques les données de tous les objets potentiellement réalisés.

Ton new Verbes("avoir") possède les données de ton new Verbes("etre"), autant rester sur un namespace.

Je sais bien et je m'étais dit la même chose que toi mais je n'ai pas voulu trop changer la class Verbes* d'origine pour ne pas risquer de perdre Matteo53, j'y suis allé doucement juste pour donner un exemple de class qu'on peut définir dans un fichier et utiliser dans un autre fichier, rien de plus pour l'instant...

Après si Matteo53 veut améliorer les autres points il pourra le faire à son rythme, du moins si il tient toujours à utiliser des class mais si il y renonce, il y a alors la solution du namespace ou même revenir aux modules, à lui de faire son choix...

Personnellement je me serais contenter de la fonction conjugue(verbe, mode, temps) (plutôt que de "créer" une instance de la class Verbes pour chaque verbe) sachant qu'en plus, en français, on n'a pas besoin d'avoir la liste de tous les verbes conjugués, on peut obtenir la conjugaison en codant les bons algorithmes... Mais là c'est de l'italien et je ne connais pas l'italien, il y a peut-être des règles particulières...

* Cf. le code source donné dans l'autre fil si il y ait toujours...

Bonjour,
Je ne sais pas ce que veut dire un namespace:D
J'ai commencé avec une classe et les modules mais je ferais par la suite la version sans classe pour travailler l'objet globale ou bien les deux comme vos exemples.. je vais petit à petit
Pour l'instant j'ai fini ma page auxiliaires
Je récupère le select d'un formulaire, l'utilisateur choisi le verbe être(essere) ou avoir(avere).
Puis je crée une instance selon le choix de l'utilisateur :
Code:

1 2 3 let formVerbeUtilis = document.getElementById("auxiliaireUtilis"); let getVerbeUtilis= formVerbeUtilis.value; let verbeUtilis = new Auxiliaires(getVerbeUtilis);
puis j'ai ma fonction dans la classe
Code:

1 2 3 4 5 6 7 8 9 tempsSimples(mode, temps, i) { let resultat; if(this.verbe ==='essere'){ resultat =this.etre[mode][temps][i]; } else if(this.verbe==='avere') { resultat = this.avoir[mode][temps][i]; } return resultat; }
Pour les auxiliaires pas le choix il faut la conjugaison des deux verbes (que j'ai mis dans un module).

Oui pour les verbes de première conjugaison comme ils sont réguliers pas besoin de les conjugué un par un .
j'ai une liste de verbe => l'utilisateur choisi =>je récupère le verbe ex. parlare(parler)
puis j'ai fait cela :
Code:

1 2 3 4 5 //recuperation du verbe et transformation en tableau const verbeByTab = Array.from(verbeUtilis); //garder la racine du verbe const lengthRacine = verbeByTab.length - 3; const racine = verbeByTab.slice(0, lengthRacine);
Puis j'ajoute la terminaison.
Un peu laborieux mais cela me permet d'apprendre un peu les methodes:D
Pour les verbes irréguliers ? Il faut conjuguer un par un pas le choix:D, j'en ferais juste quelques un, je voulais juste un peu pratiquer un peu c'est très passionnant.
Merci à vous pour tous ces conseils.

04/04/2023, 16h40
NoSmoking

Citation:

Envoyé par Matteo53

Je ne sais pas ce que veut dire un namespace:D

Article ancien mais l'esprit reste là : https://falola.developpez.com/tutori...ipt/namespace/
05/04/2023, 10h17
Matteo53

Bonjour,
merci beaucoup, grâce à vos conseils page auxiliaire est ok les temps simples 1conjugaison est ok. Je coince sur un algorithme de tableaux pour les temps composé puis je encore poser une question sur cela ou bien j'en ai posé deja trop....:D
bonne journée
05/04/2023, 10h24
SpaceFrog

Si le sujet est différent, ouvre peut être un nouveau post ... ;)