Discussion :

[Alexdezark]

Bonjour à tous,

Si l'intitulé de mon message est plutot étrange c'est que je ne sais moi-même pas très bien comment poser cette question.

Est-ce volontairement que le terme "prototype" est utilisé pour désigner le Framework ou la possibilité d'etendre les fonctions d'un objet javascript ?

Pourquoi faut-il passer par prototype pour utiliser la fonction "in_Array" par exemple ?

y a-t-il un lien sur le forum pour comprendre un peu mieux l'utilisation de prototype (pas le Framework) ?

Si vous m'aidez déja un peu à dégrossir ces premières questions, j'en aurai sans doutes d'autres

Bon début de journée à tous

[Alexdezark]

Bon après recherche dans le Forum j'ai trouvé ceci :

http://www.developpez.net/forums/d52...ation-syntaxe/

le replace général de PHP:
destructif
Code :

replaceAll= function(str,old,rep){
while(str.indexOf(old)>-1){str=str.replace(old,rep)}
return str;
}


non destructif
Code :

String.prototype.replaceAll= function(old,rep){
var str = this;
while(str.indexOf(old)>-1){str=str.replace(old,rep)}
return str;
}

1°) Pourquoi destructif ou non destructif ?

2°) le mot prototype est-il juste une convention et pourait-il être remplacé par n'importe quel autre mot ?

[Bovino]

• destructif / non destructif :

L'objet d'origine est remplacé et donc n'existe plus dans un code destructif, alors que dans un code non destructif, un nouvel objet est créé et l'ancien est toujours accessible.

• prototype :

prototype est une instruction du langage javascript qui permet d'ajouter des propriétés et méthodes à des objets, tu ne peux donc pas remplacer son nom. L'utilité par rapport à une fonction 'classique' est que tous les objets de la même classe héritent de ces propriétés et méthodes, dans ton exemple, toutes les chaînes acceptent la méthode replaceAll automatiquement.

[le_chomeur]

de plus dans les préconisations il est conseillé de créer son objet et de lui affecter ses méthodes / propriété via prototype plutôt que de les implémentés directement au seins de la déclaration de l'objet , exemple :

Code :

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

1
2
3
4
var toto=function(moi){
this.monNom = (moi)?moi:"inconnu";
this.QuiSuisJe = function(){alert(this.monNom)};
}

il vaut mieux faire :

Code :

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

1
2
3
4
5
var toto=function(moi){
this.monNom = (moi)?moi:"inconnu";
}
 
toto.prototype.QuiSuisJe = function(){alert(this.monNom)};

[Alexdezark]

Merci Bovino j'y vois déja un peu plus clair pour prototype.

Mais pour destructif ou non destructif, l'objet dans mon exemple étant String, qu'est ce qui serait détruit ?

la méthode replaceAll n'existant pas dans javascript elle ne pourrait pas remplacer l'ancienne.

Quant à détruire l'objet String et ses propriétés...

[Bovino]

La destruction se fait sur la chaîne pour laquelle tu appelles la méthode replaceAll, par exemple, avec cette méthode, tu peux ensuite faire :

Code :

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

1
2
var ma_chaine = "Une chaine quelconque";
ma_chaine.replaceAll('e','é');

qui remplacera tous tes e par des é, mais la chaine initiale n'existe plus dans le cas d'un code destructif.

[Alexdezark]

destructif : est-ce à dire qu'une fonction javascript peut modifier la valeur d'une variable hors de la fonction ?

Je demande ça car je crois bien qu'en PHP il faut passer cette variable en reference pour qu'elle soit modifiée hors de la fonction.

[Bovino]

Une fonction javascript n'a accès qu'aux variables de son contexte et ne peux donc modifier que celles-ci :

• Variables de la fonction.
• Variables des éventuelles fonctions qui appelantes (si ta fonction est appelée dans une autre fonction).
• Variables globales.

[Alexdezark]

donc à moins d'écrire :

Code :

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

1
2
 
maChaine=ma_chaine.replaceAll('e','é');

la chaine d'origine ne sera pas modifiée ?
que l'on utilise prototype ou pas ?

et si l'on ne souhaite pas modifier la chaine :

Code :

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

1
2
 
maChaineBis=ma_chaine.replaceAll('e','é');

que l'on utilise prototype ou pas ?

[Bovino]

Attention, ce n'est pas l'instruction prototype qui rend un code destructif ou non, c'est la façon dont le code fonctionne !

[Alexdezark]

Je comprends plus tout à fait

Dans ce cas quelle différence y aurait-il à écrire

Code :

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

1
2
3
4
5
6
 
String.prototype.replaceAll= function(old,rep){
var str = this;
while(str.indexOf(old)>-1){str=str.replace(old,rep)}
return str;
}

Ou

Code :

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

1
2
3
4
5
6
 
var replaceAll= function(old,rep){
var str = this;
while(str.indexOf(old)>-1){str=str.replace(old,rep)}
return str;
}

lorsque j'appelle

Code :

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

1
2
 
maStringBis=maString.replaceAll("é","e");

[Bovino]

Que ta deuxième solution renvoie :

maString.replaceAll is not a function

[Alexdezark]

Peux-tu être un peu plus précis s'il te plaît et me dire pourquoi ma deuxième solution renvera cette erreur ?

J'aimerai vraiment comprendre pour pouvoir utiliser prototype à bon escient

[le_chomeur]

pour te simplifier la compréhension de prototype :

prototype te sert a ajouter des méthodes aux objets javascript ni plus ni moins

re regarde l'exemple que j'ai donné plus haut ....

[Alexdezark]

Dans ton exemple toto est-il un objet ou une fonction ?

[le_chomeur]

exemple concret :

Code :

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
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Document sans nom</title>
<script type="text/javascript">
var toto= function(moi){
	this.monNom = (moi)?moi:"inconnu";
	this.QuiSuisJe = function(){alert("je suis : " + this.monNom)};
}
//De quel type est toto onjet ou function ?
alert(typeof(toto));
//Hé oui toto est pour l'instant une fonction plus exactement un constructeur !<br />
///Preuve en image :
var test = new toto("le_chomeur");
test.QuiSuisJe();
//Et maintenant ?
alert(typeof(test));
//Test est un objet :) une instance de toto :)
 
//La même chose avec prototype
var tata= function(moi){
	this.monNom = (moi)?moi:"inconnu";
}
tata.prototype.QuiSuisJe = function(){alert("je suis : " + this.monNom)};
alert(typeof(tata));
//...
 
</script>
</head>
 
<body>
</body>
</html>

le mot clé permettant de créer un objet en javascript est new

[Alexdezark]

Je crois que je commence à comprendre.

La syntaxe que tu utilises crée un objet dont les méthodes sont définie par cette syntaxe.

ensuite

Code :

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

1
2
 
toto.prototype.QuiSuisJe = function(){alert(this.monNom)};

ajoute la méthode QuiSuisJe() à cette objet sans le modifier.

Est-ce exact ?

[Alexdezark]

ha j'ai été un peu lent

ne tiens pas compte de ce post je vais commencer par lire ta réponse

[Alexdezark]

OK je crois que j'ai compris.

j'ai rajouté quelques ligne à ton code

Code :

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
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Document sans nom</title>
<script type="text/javascript">
var toto= function(moi){
	this.monNom = (moi)?moi:"inconnu";
	this.QuiSuisJe = function(){alert("je suis : " + this.monNom)};
}
//De quel type est toto onjet ou function ?
alert(typeof(toto));
//Hé oui toto est pour l'instant une fonction plus exactement un constructeur !<br />
///Preuve en image :
var test = new toto("le_chomeur");
test.QuiSuisJe();
//Et maintenant ?
alert(typeof(test));
//Test est un objet :) une instance de toto :)
 
//La même chose avec prototype
var tata= function(moi){
	this.monNom = (moi)?moi:"inconnu";
}
tata.prototype.QuiSuisJe = function(){alert("je suis : " + this.monNom)};
 
test2=new tata("alex");
test2.QuiSuisJe();
 
alert(typeof(tata));
 
alert(typeof(test2));
 
//...
 
</script>
</head>
 
<body>
</body>
</html>

et j'en déduis que prototype permet de rajouter des méthodes à la classe tata sans avoir besoin d'intervenir dans la classe elle-même.

peut-on dire que c'est presque un heritage (ou plutot une sous-classe ) ?

Et pour revenir à mon autre question : on peut dire que tout cela n'a rien à voir avec prtotype (le Framework) qui pourrait s'appeler complètement autrement ?

[le_chomeur]

Et pour revenir à mon autre question : on peut dire que tout cela n'a rien à voir avec prtotype (le Framework) qui pourrait s'appeler complètement autrement ?

O U I