Js DOM lien en POO

Fermé
totoc2428 Messages postés 1 Date d'inscription mardi 24 mai 2022 Statut Membre Dernière intervention 24 mai 2022 - Modifié le 25 mai 2022 à 01:02
 DoctorHow - 25 mai 2022 à 14:07
Bonjour,
Je veux créé des objet réutilisable en javascript avec la PPO. Je rencontre des problèmes avec l'intégration du dom dans les class visiblement.
class Button_test {
    constructor(ParentPar, ItemNumberPar) { //ParentPar ==  dans le dom //Item  == nb de fois d'apparition (le bouton apparait plusieurs fois)
        this.parent = ParentPar;
        this.itemNumber = ItemNumberPar;
        this.id = this.parent + 'buttontype' + this.itemNumber
        document.getElementById(this.parent).insertAdjacentHTML('beforeend', '<button type="buttontype" id="' + this.id + '"></button>');//On insère le bouton dans la balise html parent
        document.getElementById(this.id).onclick = this.Button_test_Onclick() //On éxecute la fonction lors du clique.

    }
    Button_test_Onclick(){ //Cette fonction s'exécute dès l'ouverture d'une nouvelle class (new Button_test('Body',1) ;) sans aucune raison le button est onblur
        document.getElementById(this.id).style.color = 'blue';
    }
}


EDIT: Ajout des balises de code.

La console ne me renvoyant aucune erreur je sollicite votre aide.
Merci d'avance

2 réponses

jordane45 Messages postés 38142 Date d'inscription mercredi 22 octobre 2003 Statut Modérateur Dernière intervention 20 avril 2024 4 649
25 mai 2022 à 01:10
Bonjour,

Ton souci concerne le déclenchement de ton onclick au chargement de ta class ?
Enlève les parenthèses..
document.getElementById(this.id).onclick = this.Button_test_Onclick

0
Salut,
surtout vous ne comprenez pas vraiment l'objet et son utilité j'ai l'impression.

 Button_test_Onclick(){ /*Cette fonction s'exécute dès l'ouverture d'une nouvelle class (new Button_test('Body',1) ;) sans aucune raison le button est onblur*/

/** Non pas du tout pour qu'une méthode(function interne à la classe) soit utilisée lors de la création d'une INSTANCE DE CLASSE et non ouverture qui ne veut rien dire, à la limite création j'aurais compris mais rien ne s'ouvre) il faut qu'elle soit située dans le constructeur de cette manière*/

class MaClasse{
 constructor(){
 this.attribut1="hello";
 this.attribut2=" world";
 this.initialisation();/** ce qui  se passe lorsque la fonction est instanciée est placée dans le constructeur...qui construit l'objet, le reste doit être appelé quand on vuet l'utiliser*/
 }
 initialisation(){
   console.log(" un objet à été créée ")
  }
  toString(){
  return (this.attribut1+" , "+this.attribut2)
  }
}

//-- et avec de l'héritage on peut facilement utiliser le polymorphisme, redéfinition etc...

class MaClasseEnfant extends MaClasse{
 constructor(){
 super()
 }
 initialisation(){
 console.log(this.toString())
 }
}


new MaClasse()

new MaClasseEnfant()



A noté qu'il a d'autres manières de créer des objets et instances d'objets en JavaScript. Comme avec la notation JSON et l'utilisation de constructeur par héritage des types/objets primaires(que je n'expliquerais car un peu obsolète et inutilement complexe par rapport aux autres méthodes).


function MonBouton(parent, id){
let tmp= {
//--attributs(les valeurs internes de l'objet)
parent:parent,  id:id, html : this.creer(),
//-- méthodes(les fonctions internes)
creer: function(){let tmp=document.createElement('button')
tmp.id=this.id
return tmp;
},
changerCouleurTexte: function(couleur){
 this.html.style.color=couleur;
}

}

return tmp
}

var unBouton = MonBouton( document.getElementByTagNames('body')[0], 'test')

//--pour ajouter le bouton dans la page:

unBouton.parent.appendChild(unBouton.html)

/** ou mieux faire directement une méthode qui "append" dans l'objet MonBouton pour l'appeler lors de l'initialisation, c'est à dire comme pour la variable/attribut interne MonBouton.html

*/


Les deux façons ont quelques différences(avec class vous avez un objet avec toutes les propriétés d'un objet, avec la notation littérale JSON beaucoup plus simple et rapide à écrire vous avez un objet JSON qui ne contient que ce que vous y mettez.
L'un à l'avantage d'être sécurisé mais l'inconvénient de devoir être configuré pour être utilisé (porté des variables et tris des attributs qui n'ont pas à être utilisés si on veut les lister) et l'autre peut être utilisé directement, il faudra configurer les attributs et méthodes qui doivent être publiques ou privées(utilisable que dans le contexte de l'objet et non de l'extérieur).
Donc les 2 façons ont leur intérêt selon les besoins même si au final on peut faire la même chose, la notation JSON plus rapide et directe (il n'y a que ce qu'on y met contrairement avec un constructeur qui utilise l'objet Class et hérite donc de tout ce que contient Class/Function).

Pour moi class est à utiliser dans un contexte formel plus cnceptuel. Si c'est pour quelques manipulations du DOM et un objet prêt à l'emploi la notation JSON plus rapide à écrire et claire suffit amplement et à l'avantage d'être plus léger car ne comprends pas toutes les méthodes et attributs hérités de l'objet "Object" (lui même héritant de l'objet Function je crois)
https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Object

/!\ Attention ceci est particulier à JavaScript et ne se trouve pas dans la plupart des autres langages. C'est possible car JS est non typé bien qu'on parle de typage dynamique(unevariable n'a pas un type définit et peut changer ainsi on peut mélanger toutes sortes de types de valeurs ce qui n'est pas sécuriésé et force à d'incessantes vérifications pour ne pas mettre des valeurs incohérentes dans les variable).


Mieux que mes explications la notice d'utilisation d'un des principaux acteurs de JS:

https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Classes

et la JavaScriptObjectNotation(JSON):

https://developer.mozilla.org/fr/docs/Learn/JavaScript/Objects/JSON
0