Discussion :

[Matteo53]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

 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
merci pour votre aide

[houd.ini]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[Matteo53]

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)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

mon constructeur de la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Beginner.]

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)

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.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

Dans ma classe je voudrais créer une fonction avec une condition

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 html :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

[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.

[Beginner.]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

On pourrait faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 ?
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Beginner.]

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...

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 html :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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

conjugaisons.js

Code JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

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...

[Beginner.]

Suite du message précédent...

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...

[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
Bonne journée

[Beginner.]

Salut,

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 html :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[NoSmoking]

Bonjour,
cela ne me paraît pas être un bon exemple , 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.

[Beginner.]

Salut,

Bonjour,
cela ne me paraît pas être un bon exemple , 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...

[Matteo53]

Bonjour,
Je ne sais pas ce que veut dire un namespace
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
Pour les verbes irréguliers ? Il faut conjuguer un par un pas le choix, 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.

[NoSmoking]

Je ne sais pas ce que veut dire un namespace

Article ancien mais l'esprit reste là : https://falola.developpez.com/tutori...ipt/namespace/

[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....
bonne journée

[SpaceFrog]

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