PC SOFT

FORUMS PROFESSIONNELS
WINDEVWEBDEV et WINDEV Mobile

Accueil → WINDEV Mobile 24 → Classe Json
Classe Json
Débuté par adrianoboller, 12 déc. 2014 15:34 - 9 réponses
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:34
JSON_Analyseur

// Classe Analyseur
// Analyse un code JSON
JSON_Analyseur est une Classe

GLOBAL PRIVÉ

// Expression régulière pour les caractères Unicode dans une chaîne Javascript
mg_sUnicodeest une chaîne = "(\\u([0-9a-fA-F]{4}))"

mg_pclLastExprest une JSON_Expression dynamique
mg_bufHASHest un Buffer

FIN

// Erreurs
CONSTANT

// Jeton invalide rencontré
JetonInvalide= 1

// Aucune source à analyser
SourceVide= 2

// L'expression de haut niveau n'est pas valide
TopExpressionNonValide= 3

// Fin de déclaration invalide
FinInvalide= 4

// Jeton inattendu pendant la déclaration
JetonInattendu= 5

// Nom de membre invalide
ObjetNomMembreInvalide= 6

// Aucun séparateur entre membre
ObjetMembreAucunSéparateur= 7

// Valeur de membre non déclarée
ObjetValeurMembreNulle= 8

// Séparateur d'objet invalide
ObjetSéparateurInvalide= 9

// Déclaration de membre nulle
ObjetMembreVide= 10

// Séparateur d'élément invalide
TableauElémentSéparateurInvalide= 11

// Déclaration d'élément nulle
TableauElémentVide= 12

// Fin inattendu de la source
FinInattendue= 13
FIN
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:35
Constructeur()
PROCEDURE PRIVÉE Constructeur()

Destructeur()
PROCEDURE Destructeur()
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:35
Method AnalyseObjet
// Résumé : Analyse une séquence JSON décrivant un objet
// Syntaxe :
// [ <Résultat> = ] AnalyseObjet (<pclEnumJetons> est JSON_JetonEnumérateur dynamique)
//
// Paramètres :
//pclEnumJetons (JSON_JetonEnumérateur dynamique) : Enumérateur de jetons
// Valeur de retour :
// JSON_ExpressionObjet dynamique : Expression 'Objet' générée à partir de l'analyse
//
Procedure GLOBALE PRIVÉE AnalyseObjet(pclEnumJetons est un JSON_JetonEnumérateur dynamique)

taMembres est un tableau associatif de JSON_Expression dynamique
pclJeton est un JSON_Jeton dynamique
sNom est une chaîne
nNécessiteJetonest un entier = -1

// Tant qu'on n'a pas atteint la fin de la déclaration d'un objet et que le jeton en cours n'est pas nul
TANTQUE pclEnumJetons.Suivant(pclJeton) _ET_ pclJeton.Type <> JSON_Jeton.ACCOLADE_DROITE

// Le jeton doit être un jeton de chaîne
SI pclJeton.Type <> JSON_Jeton.VALEUR_CHAINE ALORS
ExceptionDéclenche(ObjetNomMembreInvalide, "Déclaration invalide d'un membre d'objet. On attendait une chaîne pour le nom du membre")
FIN

// Extrait le nom du jeton
sNom = JSONVersChaîne(pclJeton.Données)

// Jeton suivant
SI PAS pclEnumJetons.Suivant(pclJeton) ALORS
ExceptionDéclenche(FinInattendue, "Fin inattendue lors de l'analyse d'un objet")
FIN

// Le jeton doit être un jeton de virgule
SI pclJeton.Type <> JSON_Jeton.CARACTERE_DEUX_POINTS ALORS
ExceptionDéclenche(ObjetMembreAucunSéparateur, "Déclaration invalide d'un membre d'objet. On attendait un séparateur entre le nom et la valeur du membre")
FIN

// Jeton suivant
SI PAS pclEnumJetons.Suivant(pclJeton) ALORS
ExceptionDéclenche(FinInattendue, "Fin inattendue lors de l'analyse d'un objet")
FIN

// Analyse le membre et l'affecte
taMembres[sNom] = AnalyseJetons(pclEnumJetons)

// Jeton suivant
SI PAS pclEnumJetons.Suivant(pclJeton) ALORS
ExceptionDéclenche(FinInattendue, "Fin inattendue lors de l'analyse d'un objet")
FIN

// Le jeton doit être un jeton de virgule ou d'accolade fermante
SI pclJeton.Type <> JSON_Jeton.CARACTERE_VIRGULE _ET_ pclJeton.Type <> JSON_Jeton.ACCOLADE_DROITE ALORS
ExceptionDéclenche(ObjetSéparateurInvalide, "Déclaration invalide d'un membre d'objet. On attendait un séparateur entre les membres")
FIN

// Détermine si un jeton suivant doit être analysé
nNécessiteJeton = (pclJeton.Type = JSON_Jeton.CARACTERE_VIRGULE)

// Fin de la déclaration
SI pclJeton.Type = JSON_Jeton.ACCOLADE_DROITE ALORS
SORTIR
FIN
FIN

// Vérifie le dernier jeton analysé (doit être un jeton d'accolade fermante)
SI pclJeton = Null _OU_ pclJeton.Type <> JSON_Jeton.ACCOLADE_DROITE ALORS
ExceptionDéclenche(FinInvalide, "Déclaration invalide d'un objet. On attendait une accolade fermante")
FIN

// Vérifie si un jeton était attendu
SI nNécessiteJeton <> -1 _ET_ nNécessiteJeton = Vrai ALORS
ExceptionDéclenche(ObjetMembreVide, ChaîneConstruit("Déclaration d'un membre vide (%1)", pclJeton.Position))
FIN

// Renvoie l'expression Objet générée
RENVOYER JSON_Expression.ExpressionObjet(taMembres)
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:36
Method AnalyseTableau
// Résumé : Analyse une séquence JSON décrivant un tableau de données
// Syntaxe :
// [ <Résultat> = ] AnalyseTableau (<pclEnumJetons> est JSON_JetonEnumérateur dynamique)
//
// Paramètres :
//pclEnumJetons (JSON_JetonEnumérateur dynamique) : Enumérateur de jetons
// Valeur de retour :
// JSON_ExpressionTableau dynamique : Expression 'Tableau' générée à partir de l'analyse
//
Procedure GLOBALE PRIVÉE AnalyseTableau(pclEnumJetons est un JSON_JetonEnumérateur dynamique)

tabValeurs est un tableau de JSON_Expression dynamique
pclJetonest un JSON_Jeton dynamique
nNécessiteJetonest un entier = -1

// Tant qu'on n'a pas atteint la fin de la déclaration d'un objet et que le jeton en cours n'est pas nul
TANTQUE pclEnumJetons.Suivant(pclJeton) _ET_ pclJeton.Type <> JSON_Jeton.CROCHET_DROITE

// Ajoute la valeur
Ajoute(tabValeurs, AnalyseJetons(pclEnumJetons))

// Jeton suivant
SI PAS pclEnumJetons.Suivant(pclJeton)
ExceptionDéclenche(FinInattendue, "Fin inattendue lors de l'analyse d'un tableau")
FIN

// Le jeton doit être un jeton de virgule ou de crochet fermant
SI pclJeton.Type <> JSON_Jeton.CARACTERE_VIRGULE _ET_ pclJeton.Type <> JSON_Jeton.CROCHET_DROITE ALORS
ExceptionDéclenche(ObjetSéparateurInvalide, "Déclaration invalide d'un élément d'un tableau. On attendait un séparateur entre les valeurs")
FIN

// Fin de la déclaration
SI pclJeton.Type = JSON_Jeton.CROCHET_DROITE ALORS
SORTIR
FIN
FIN

// Vérifie le dernier jeton analysé (doit être un jeton de crochet fermant)
SI pclJeton = Null _OU_ pclJeton.Type <> JSON_Jeton.CROCHET_DROITE ALORS
ExceptionDéclenche(FinInvalide, "Déclaration invalide d'un tableau. On attendait un crochet fermant")
FIN

// Vérifie si un jeton était attendu
SI nNécessiteJeton <> -1 _ET_ nNécessiteJeton = Vrai ALORS
ExceptionDéclenche(TableauElémentVide, ChaîneConstruit("Déclaration d'un élément vide (%1)", pclJeton.Position))
FIN

// Renvoie l'expression tableau générée
RENVOYER JSON_Expression.ExpressionTableau(tabValeurs)
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:36
Method JSONVersChaîne

// Résumé : Transforme une chaîne Javascript en chaîne ANSI
// Syntaxe :
// [ <Résultat> = ] JSONVersChaîne (<sChaîneJSON> est chaîne)
//
// Paramètres :
//sChaîneJSON (chaîne) : Chaîne Javascript à convertir
// Valeur de retour :
// chaîne : Chaîne convertie
//
Procedure PRIVÉE GLOBALE JSONVersChaîne(LOCAL sChaîneJSON est une chaîne)

sChaîne est une chaîne
tabUnicodeest un tableau de chaîne

// Supprime les guillemets
sChaîne = sChaîneJSON[[2 A Taille(sChaîneJSON) - 1]]

// Remplace les séquences Unicode (attention : le parcours se fait de la fin vers le début de la chaîne)
// tabUnicode[1] : séquence Unicode complète
// tabUnicode[2] : valeur de la séquence Unicode en hexadécimal
TANTQUE VérifieExpressionRégulière(sChaîne, ".*" + mg_sUnicode + ".*", tabUnicode) _ET_ tabUnicode..Occurrence = 2

// Remplace la séquence
sChaîne = Remplace(sChaîne, tabUnicode[1], CaractUnicode(Val(tabUnicode[2], "x")))
SupprimeTout(tabUnicode)
FIN

// Caractères d'échappement
sChaîne = Remplace(sChaîne, "\n", Caract(10))
sChaîne = Remplace(sChaîne, "\r", Caract(13))
sChaîne = Remplace(sChaîne, "\t", TAB)
sChaîne = Remplace(sChaîne, "\f", "")
sChaîne = Remplace(sChaîne, "\b", "")
sChaîne = Remplace(sChaîne, "\""", """")
sChaîne = Remplace(sChaîne, "\/", "/")
sChaîne = Remplace(sChaîne, "\\", "\")

// Remplacement des retours-chariots
sChaîne= Remplace(sChaîne, RC, Caract(10))
sChaîne= Remplace(sChaîne, Caract(10), RC)

RENVOYER sChaîne
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:37
Method Analyse
// Résumé : Analyse un source JSON
// Syntaxe :
//[ <Résultat> = ] Analyse (<sEntrée> est chaîne)
//
// Paramètres :
//sEntrée (chaîne) : Source JSON à analyser
// Valeur de retour :
// JSON_Expression dynamique : Expression générée à partir de l'analyse
//
Procedure GLOBALE Analyse(sEntrée est une chaîne)

// Calcule l'empreinte du source
bufHASH est un Buffer
bufHASH = HashChaîne(HA_MD5_128, sEntrée)

// Si on a déjà analysé cette source
SI mg_bufHASH <> bufHASH ALORS

clCodeur est un JSON_JetonCodeur(sEntrée)
pclEnumJetonsest un JSON_JetonEnumérateur dynamique
pclTopest une JSON_Expression dynamique

// Extrait les jetons
pclEnumJetons = clCodeur.Encode()
pclEnumJetons = pclEnumJetons.Exclure(JSON_Jeton.CARACTERE_BLANC)

// Vérifie si l'entrée contient des jetons
dbgAssertion(pclEnumJetons.Occurrence() <> 0, "Entrée vide")

// Analyse récursive
pclEnumJetons.Premier()
pclTop = AnalyseJetons(pclEnumJetons)

SI pclTop <> Null ALORS

// Vérifie la première expression
SI (pclTop.TypeNoeud <> JSON_Expression.TypeTableau _ET_ pclTop.TypeNoeud <> JSON_Expression.TypeObjet) ALORS
ExceptionDéclenche(TopExpressionNonValide, "Format de sérialisation JSON incorrect")
FIN
FIN

// Conserve la dernière entrée
mg_bufHASH = bufHASH
mg_pclLastExpr = pclTop
SINON

// Récupère la précédente expression top
pclTop = mg_pclLastExpr
FIN

RENVOYER pclTop
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:38
Method AnalyseJetons
// Résumé : Analyse les séquences JSON
// Syntaxe :
//[ <Résultat> = ] AnalyseJetons (<pclEnumJetons> est JSON_JetonEnumérateur dynamique)
//
// Paramètres :
//pclEnumJetons (JSON_JetonEnumérateur dynamique) : Enumérateur de jetons
// Valeur de retour :
// JSON_Expression dynamique : Expression générée à partir de l'analyse
//
Procedure GLOBALE AnalyseJetons(pclEnumJetons est un JSON_JetonEnumérateur dynamique)

pclJeton est un JSON_Jeton dynamique <- pclEnumJetons.ElémentCourant
pclExpressionest une JSON_Expression dynamique

SI pclJeton <> Null ALORS

SELON pclJeton.Type

// Début d'un objet
CAS JSON_Jeton.ACCOLADE_GAUCHE
pclExpression = AnalyseObjet(pclEnumJetons)

// Début d'un tableau
CAS JSON_Jeton.CROCHET_GAUCHE
pclExpression = AnalyseTableau(pclEnumJetons)

// Booléen (Faux)
CAS JSON_Jeton.BOOLEEN_FAUX
pclExpression = JSON_Expression.ExpressionBooléenne(Faux)

// Booléen (Vrai)
CAS JSON_Jeton.BOOLEEN_VRAI
pclExpression = JSON_Expression.ExpressionBooléenne(Vrai)

// Constante NULL
CAS JSON_Jeton.VALEUR_NULLE
pclExpression = JSON_Expression.ExpressionNulle()

// Chaîne
CAS JSON_Jeton.VALEUR_CHAINE
pclExpression = JSON_Expression.ExpressionChaîne(JSONVersChaîne(pclJeton.Données))

// Numérique
CAS JSON_Jeton.VALEUR_NUMERIQUE
pclExpression = JSON_Expression.ExpressionNumérique((pclJeton.Données))

// Cas invalides
// Jeton.CARACTERE_EOF, Jeton.CARACTERE_BLANC, Jeton.CROCHET_DROITE, Jeton.ACCOLADE_DROITE, Jeton.CARACTERE_DEUX_POINTS, Jeton.CARACTERE_VIRGULE :
AUTRES CAS
ExceptionDéclenche(JetonInattendu, ChaîneConstruit("Jeton inattendu : %1 (%2)", pclJeton.Type, pclJeton.Position))

FIN
FIN

RENVOYER pclExpression
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:40
Declaration IJSONPropriété
// Interface IJSONPropriété
// Cette classe permet, pour chaque objet qui la dérive, d'attribuer des alias aux membres ou de déclarer un membre pour une allocation dynamique
//
// Exemple :
//
// cMaClasse est une classe
//hérite de IJSONPropriété
//
// m_sMembre est une chaîne
//m_pclObjet est un objet dynamique
// FIN
//
// PROCEDURE Constructeur()
//
// // Crée un alias JSON pour le membre
// JSONAlias["m_sMembre"] = "member"
//
// // Le membre <m_pclObjet> devra être alloué par l'objet lui-même et non par la désérialisation
// JSONAllocation["m_pclObjet"] = Vrai
//
// PROCEDURE PROTEGEE VIRTUELLE JSONAlloue(sNomVariable est une chaine, Variable, sCodeJSON est une chaine <utile>)
//
// // Alloue le membre
// SI sNomVariable = "m_sMembre" ALORS
// Variable = allouer un cMaClasseFille
// FIN
//
//
IJSONPropriété est une Classe

PRIVÉ LOCAL

// Alias des membres
m_taJSONAliasest un tableau associatif de chaînes

// Membres ignorés pour la sérialisation
m_taJSONIgnoreest un tableau associatif de booléens

// Allocation des membres
m_taJSONAllocationest un tableau associatif de booléens

// Membres non déclarés
m_taAutresMembresest un tableau associatif de JSON_Expression dynamique

// Flag indiquant si la méthode de post allocation doit être exécutée
m_bPostAllocationest un booléen

FIN
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 12 décembre 2014 - 15:43
//Retrieving the JsonAlias property
Procedure JSONAlias()

RENVOYER m_taJSONAlias
Membre enregistré
2 958 messages
Popularité : +89 (91 votes)
Posté le 08 juin 2016 - 01:35
Exemplo de Serialize

http://help.windev.com/en-US/…

// Structure to transform into JSON
ST_Product is structure
// <Serialize> allows you to have a different name in JSON
sName is string <Serialize ="ProductName">
nID is int
nQty is int
mValue is currency <Serialize ="Amount">
END
ST_Person is structure
sLastName is string <Serialize ="LastName">
sFirstName is string <Serialize ="FirstName">
dDOB is Date
arrProducts is array of ST_Product
END
arrPersons is array of ST_Person

// Fill the data
nPersonSubscript is int
nProductSubscript is int
nPersonSubscript = ArrayAdd(arrPersons)
arrPersons[nPersonSubscript].sLastName = "Doe"
arrPersons[nPersonSubscript].sFirstName = "John"
arrPersons[nPersonSubscript].dDOB = "19880516"

nProductSubscript = ArrayAdd(arrPersons[mPersonSubscript].arrProducts)
arrPersons[nPersonSubscript].arrProducts[nProductSubscript].mValue = 89.9
arrPersons[nPersonSubscript].arrProducts[nProductSubscript].nID = 12345724
arrPersons[nPersonSubscript].arrProducts[nProductSubscript].nQty = 5
arrPersons[nPersonSubscript].arrProducts[nProductSubscript].sName = "Red jacket"

// Retrieve the JSON code
bufJson is Buffer
Serialize(arrPersons.bufJson, psdJSON
//[ {
// "LastName":"Doe",
// "FirstName":"John",
// "dDOB":"1988-05-16",
// "arrProducts":[ {
// "ProductName":"Red jacket",
// "nID":12345724,
// "nQty":5,
// "Amount":89.9
// } ]
// } ]

// Send the JSON to a site by POST
HTTPCreateForm("JSONForm")
HTTPAddParameter("JSONForm", "JSONPERSON", bufJson)
HTTPSendForm("JSONForm", ...
"http://MySite/MySite_WEB/US/PAGE_Persons.awp", httpPost)




Exemplo de Deserialize

http://help.windev.com/en-US/…

// This example explains how to use the Serialize/Deserialize functions
// with an Array variable.
// These functions can use all types of WLanguage variables.


MyArray is array of strings
bufResult is Buffer

// Adds elements into the array
Add(MyArray, "WINDEV")
Add(MyArray, "WEBDEV")
Add(MyArray, "WINDEV MOBILE")

// Serialize the array in the buffer in JSON
// => Save the array and its entire content in a JSON string
Serialize(MyArray, bufResult, psdJSON)

// Deserialize the JSON buffer
// => Rebuild the WLanguage array from the JSON string
MyRebuiltArray is array of strings
Deserialize(MyRebuiltArray, bufResult, psdJSON)





Exemplo de Structure

http://help.windev.com/en-US/…

// Declare a structure
ProductRef is structure
SCode is int
PdtCode is fixed string on 10
END

// Declare a structure variable
ProductRef is structure
SCode is int
PdtCode is fixed string on 10
END

Armchair is ProductRef

// Handle a member of a structure variable
ProductRef is structure
SCode is int
PdtCode is fixed string on 10
END

Armchair is ProductRef
Armchair:SCode = 7
Armchair:PdtCode = "Furniture"


--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 9949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/