Discussion :

[jak0]

Bonjour à vous tous,

Je me tourne vers vous pour vos idées ou pistes concernant un comportement très bizarre en AJAX.
(C'est important de le préciser, j'utilise la librairie Prototype).
Depuis une simple page HTML, je fais une requête AJAX vers un script PHP. Ce PHP interroge une base de données et me retourne un certain nombre d'informations. Jusque là, c'est tout à fait classique.
Seulement voilà, ma requête SQL retourne un nombre moyen de lignes (de 10 à 20) mais avec 87 colonnes chacune.
Quand je limite (dans le SQL) à 12 lignes, pas de problème, je reçois bien la réponse AJAX. Quand je passe) à 13 lignes, hop plus de réponse et une exception lancée dans l'objet Ajax...
C'est systématiquement au delà de 12 que ça plante. J'ai essayé en mode texte (des appels directement vers le script PHP et tout fonctionne).

Est-ce que quelqu'un aurait une idée svp ?
Merci d'avance

[jak0]

J'ai réussi à mettre en place un mode débug et à comparer les différentes longueurs de chaînes renvoyées par mon PHP.

Code :

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

1
2
$json_data = json_encode ($my_data);
print (strlen ($json_data));

A moins de 10 000, ça passe, à plus ça plante. Donc je pense que la réponse est là, mais comment contourner ? oO

[burndev]

bonsoir,

J'ai de mon coté fait des tests avec json_encode(). Pour ma part dans les résultats obtenu avec une extraction brute dans un array() mon fait flipper.

Je pense qu'il serait préférable que tu te tape a la paluche pour formaté json.
et ce pour respecté le standard.

Code :

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

1
2
3
4
5
{"nom extraction":[
{"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"}
,{"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"}
,{"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"}
]}

renvois une entête text/plain coté traitement serveur
coté client je ne connais pas prototype mais avec ton objet xmlhttprequest traite en responseText.

quelque soit la quantité de données existante le problème vient de ton formatage json.

bon courage

[jak0]

OK merci, je vais essayer l'encodage mano...
Je repost dans quelques heures

[jak0]

Effectivement en envoyant du text/plain et en récupérant le ResponsText, ça fonctionne.
Par contre, je ne comprend toujours pas pourquoi ça bloque en JSON

[DoubleU]

J'avais eu le même problème alors que je retournais une réponse xml, et j'avais utilisé le même genre de work around, c'est à dire récupérer le responseText pour regénérer le xml, plutot que passer par le responseXML.

[burndev]

tu renvois text/plain coté serveur formaté json est une chose
coté client tu récupère au format text mais ton traitement json tu le fait comment?

as tu regarder ceci, pour json avec proprotype.

montre moi un peu de code que je puisse comprendre

[jak0]

J'ai pas encore utilisé les paramètres de sécurité dispo dans cette page, mais je vais me pencher dessus.

Voilà ce que j'ai implémenté

Côté JavaScript, j'utilise ces deux objets :

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
function isset (variable) {
  return (typeof variable != 'undefined' && variable != null);
};
var JkAjaxRequester = Class.create();
JkAjaxRequester.request = function (arguments) {
  try {
    if (!isset (arguments)) throw ('JkAjaxRequester.request: arguments is null');
    if (!isset (arguments.requester)) throw ('JkAjaxRequester.request: No Respons Object');
    if (!isset (arguments.ajax_url)) throw ('JkAjaxRequester.request: No Ajax Id');
    JkAjaxRequester.ajaxBlinker (true);
    return new Ajax.Request (arguments.ajax_url, {
      method: 'post', 
      parameters: (isset (arguments.params) ? arguments.params : {}),
      requester: arguments.requester,
      timeout: false,
      onSuccess: function () {
        if (!isset (arguments [0].responseJSON)) {
          if (isset (arguments [0].responseText)) arguments [0].responseJSON = arguments [0].responseText.evalJSON (true);
        }
        if (!isset (arguments [0].responseJSON)) throw ('No answer from the server');
        JkAjaxRequester.responsFunction (
          new JkAjaxResponder ({
            flag: arguments [0].responseJSON.status.flag,
            code: arguments [0].responseJSON.status.code,
            message: arguments [0].responseJSON.status.message,
            returns: arguments [0].responseJSON,
            requester: arguments [0].request.options.requester
          })
        );
      },
      onFailure: function () {
        throw (arguments [0].status + ' ' + arguments [0].statusText);
      },
      onException: function () {
        JkAjaxRequester.responsFunction (
          new JkAjaxResponder ({
            flag: false,
            code: 1,
            message: "Error#1: Echec de la requête",
            exception: arguments [1],
            requester: arguments [0].options.requester
          })
        );
      }
    });
  } catch (exception) {  
    JkAjaxRequester.responsFunction (
      new JkAjaxResponder ({
        flag: false,
        code: 2,
        message: "Error#2: Echec de la requête",
        exception: exception,
        requester: arguments.requester
      })
    );
    return null;
  }
};
JkAjaxRequester.responsFunction = function (responder) {
  JkAjaxRequester.ajaxBlinker (false);
  if (isset (responder.requester.responsFunction)) responder.requester.responsFunction (responder);
};
JkAjaxRequester.ajax_timeout = null;
JkAjaxRequester.ajax_requests = 0;
JkAjaxRequester.ajaxBlinker = function (bool) {
  JkAjaxRequester.ajax_requests = JkAjaxRequester.ajax_requests + (bool ? 1 : -1);
  if (JkAjaxRequester.ajax_requests == 0 || (JkAjaxRequester.ajax_requests == 1 && bool)) {
    if (bool) {
      JkAjaxRequester.ajax_timeout = setTimeout ("document.body.className = 'loading';", 200);
    } else {
      clearTimeout (JkAjaxRequester.ajax_timeout); 
      document.body.className = '';
    }
  }
};
 
var JkAjaxResponder = Class.create ({
  initialize: function (arguments) {
    if (!isset (arguments)) throw ('JkAjaxResponder.initialize: arguments is null');
    this.flag = isset (arguments.flag) && arguments.flag == true;
    this.code = isset (arguments.code) ? arguments.code : -1;
    this.message = isset (arguments.message) ? arguments.message : "";
    this.exception = isset (arguments.exception) ? arguments.exception : null;
    this.returns = isset (arguments.returns) ? arguments.returns : null;
    this.requester = isset (arguments.requester) ? arguments.requester : null;
  },
  toString: function () {
    str = 'Object (JkAjaxResponder) : {';
      str += isset (this.flag) ? 'flag:'+this.flag+';' : '';
      str += isset (this.code) ? 'code:'+this.code+';' : '';
      str += isset (this.message) ? 'message:'+this.message+';' : '';
      str += isset (this.exception) ? 'exception:'+this.exception+';' : '';
      str += isset (this.returns) ? 'returns:'+this.returns+';' : '';
      str += isset (this.requester) ? 'requester:'+this.requester.toString()+';' : '';
    str += '}';
    return str;
  }
});

Côté PHP, en résumé, c'est ça :

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
$RESPONSE_TEXT = isset ($_GET) && isset ($_GET ['text']);
$RESPONSE_JSON_LIMIT = 5000;
 
// [...]
 
$json_data = json_encode ($json_array);
if (strlen ($json_data) > $RESPONSE_JSON_LIMIT) $RESPONSE_TEXT = true;
 
if ($RESPONSE_TEXT) {
  header ('Content-type: text/plain');
  header ('Content-length: ' . strlen ($json_data));
  print  ("$json_data");
} else {
  header ('Content-type: application/x-json');
  header ('Content-length: ' . strlen ($json_data));
  header ("X-JSON: $json_data");
}

[burndev]

salut,
comme je te le disais au début, prototype reste le point noir pour moi.

est ce que l'encodage des datas(utf-8, ou autre) ne te ferais pas défaut quelque part. Car part rapport au premier post tu stipule bien qu'un certain nombre de lignes sont ok.

as tu essayé une extraction a partir de la ligne 13 a la fin(uniquement pour vérification).

[jak0]

A priori c'est pas une question de la ligne 13, mais bien de longueur de la réponse.
En changeant la façon dont je passe les réponses (tableaux, objets, etc), le nombre de ligne que je peux récupérer change mais pas la longueur de la réponse correspondante.