json — n_pbt_json #

← Référence des composants · Sommaire du guide

Construire un JSON type par type — texte, nombre, booléen, tableau, objet imbriqué — avec l'échappement fait pour vous, puis en relire un le long d'un chemin : of_load, of_get_string, of_type, of_count. Un seul objet bâtit vos requêtes et lit vos réponses. Tout en PowerScript pur : aucune page, aucun moteur, PowerBuilder 10 compris.

▶ Le voir en vrai — Application de démonstration, tuile JSON : les résultats, le code qui les produit et cette page, côte à côte.

En bref #

n_pbt_json est autoinstantiate : on le déclare en variable locale, sans create ni destroy. C'est le même objet qui sert, en interne, à bâtir les charges utiles envoyées au moteur — désormais offert à votre code, côté construction et lecture.

Démarrage rapide #

Bâtir une charge utile, puis relire une réponse — tout tient dans une variable locale :

// Local variables
n_pbt_json  lnv_json
string      ls_customer
double      ld_total

// Write : each member is typed and escaped for you - a path may have levels
lnv_json.of_set_string(/*path*/ "customer", /*value*/ "Ada")
lnv_json.of_set_number(/*path*/ "total", /*value*/ 690.50)
lnv_json.of_set_boolean(/*path*/ "paid", /*value*/ true)

// lnv_json.of_text() -> {"customer":"Ada","total":690.5,"paid":true}

// Read : load a response, reach values by path
lnv_json.of_load(/*json*/ '{"order":{"customer":"Ada","total":690.50}}')
IF lnv_json.of_is_valid() THEN
	ls_customer = lnv_json.of_get_string(/*path*/ "order/customer")   // Ada
	ld_total    = lnv_json.of_get_number(/*path*/ "order/total")     // 690.5
END IF

Un chemin est la suite des clés depuis la racine, jointes par / ; l'index d'un tableau est sa position, comptée à partir de 1, comme toute position de la bibliothèque : order/lines/1 est la première ligne, order/lines/0 ne désigne rien — une écriture le refuse par -5. Un niveau s'écrit comme l'écrit JSON Pointer (RFC 6901) : ~1 est un / de la clé et ~0 un ~ (paths/~1users lit la clé /users ; of_escape_key convertit une clé), un niveau vide est la clé "" (a//b), et un chemin peut commencer par / — la forme complète du pointeur, seule façon de nommer la clé "" de la racine (/). Si un objet écrit la même clé deux fois, c'est sa PREMIÈRE occurrence qui est lue et écrite — un navigateur, lui, retient la dernière.

Construire une charge utile #

Lire un document #

// Local variables
n_pbt_json  lnv_json
string      ls_tags[]
string      ls_compact
long        ll_count

// Read every element of an array at once, then store the document on one line
lnv_json.of_load(/*json*/ '{"customer":{"name":"Ada","tags":["vip","b2b"]}}')
ll_count = lnv_json.of_get_array(/*path*/ "customer/tags", /*values*/ ls_tags)   // 2 : vip, b2b

// The document on one line, without a space : the smallest text to store
ls_compact = lnv_json.of_pretty(/*indent*/ 0)

Modifier un document #

Le côté écriture change le document chargé sur place, puis of_text en rend le résultat (compact) — ce qu'on réécrit. Les setters remplacent la valeur au chemin, ou ajoutent la dernière clé quand elle manque à un objet parent. Chacun rend 0, -4 quand un niveau du chemin est un scalaire, ou un tableau sans cet index, -5 sur un chemin vide ou un index 0 sur un tableau. Un tableau rencontré en chemin se traverse par un index qui EXISTE (items/1/qty ajoute qty au premier élément) ; seule une clé d'objet est jamais créée. Une valeur null (nombre, booléen, JSON brut vide) s'écrit null. Une boucle d'écritures, d'ajouts de clés ou de retraits dans un gros document (2 000 lignes) reste rapide : chaque appel ne relit que ce qu'il touche.

// Local variables
n_pbt_json  lnv_json

// Load, edit in place, then read back the ONE document with of_text
lnv_json.of_load(/*json*/ '{"name":"Ada","active":false}')
lnv_json.of_set_string(/*path*/ "name", /*value*/ "Grace")   // replace
lnv_json.of_set_boolean(/*path*/ "active", /*value*/ true)
lnv_json.of_set_number(/*path*/ "count", /*value*/ 3)        // added : the key was absent

// lnv_json.of_text() -> {"name":"Grace","active":true,"count":3}

Dates #

Une date s'écrit et se lit en ISO 8601 — ce qu'écrivent les API, les navigateurs et Python —, quel que soit le format de date du poste : une date "2026-10-10", une date-heure "2026-10-10T14:30:00" (sa fraction de seconde suit quand elle n'est pas nulle), une heure "14:30:00". Une valeur nulle écrit null.

// Local variables
n_pbt_json  lnv_json
date        ld_due
datetime    ldt_created

// Write : ISO 8601, whatever the date format of the machine
lnv_json.of_set_date(/*path*/ "due", /*value*/ Date(2026, 10, 31))
lnv_json.of_set_datetime(/*path*/ "created", /*value*/ DateTime(Date(2026, 10, 10), Time(14, 30, 0)))

// Read what an API writes : the Z is read, the hour stays the one written
lnv_json.of_load(/*json*/ '{"due":"2026-10-31","created":"2026-10-10T14:30:00Z"}')
ld_due      = lnv_json.of_get_date(/*path*/ "due")
ldt_created = lnv_json.of_get_datetime(/*path*/ "created")

Un DataStore en JSON, et retour #

PowerBuilder n'a ExportJson et ImportJson qu'à partir de la 2017 R2. n_pbt_json le fait dès PowerBuilder 10, typé par les colonnes : une chaîne, un nombre (un decimal garde tous ses chiffres), une date yyyy-mm-dd, une date-heure, une heure, null pour un NULL. Une surcharge prend un datawindow, une autre un datawindowchild.

// Local variables
n_pbt_json  lnv_json
datastore   lds_orders
long        ll_rows
string      ls_body

// Send : every row of a retrieved DataStore as typed objects - the body of the call
lds_orders = create datastore
lds_orders.DataObject = "d_orders"
lds_orders.SetTransObject(SQLCA)
lds_orders.Retrieve()
ll_rows = lnv_json.of_from_datastore(/*path*/ "orders", /*source*/ lds_orders)
ls_body = lnv_json.of_text()

// Receive : the objects of a response inserted as NEW rows, ready for Update
lds_orders.Reset()
lnv_json.of_load(/*json*/ '{"data":[{"id":7,"customer":"Grace","amount":"19.99","due":"2026-12-24"}]}')
ll_rows = lnv_json.of_to_datastore(/*path*/ "data", /*target*/ lds_orders)
destroy lds_orders

Quand le texte n'est pas du JSON #

// Local variables
n_pbt_json  lnv_json
long        ll_rc
string      ls_why
long        ll_where

// A response with a colon missing on its second line
ll_rc = lnv_json.of_load(/*json*/ '{"id":4152,~r~n "paid" true}')
IF ll_rc < 0 THEN
	ls_why   = lnv_json.of_get_last_error()     // line 2, column 9 : ':' expected after a key
	ll_where = lnv_json.of_error_position()     // 22
END IF

Portée. JSON s'analyse en PowerScript pur, sans page ni moteur : n_pbt_json reste autoinstantiate et fonctionne partout, PowerBuilder 10 compris. Pour du XML, voyez xml (qui s'appuie sur le moteur) ; pour afficher un JSON en arbre repliable, voyez jsontree.

← Référence des composants · Sommaire du guide