You are looking at the HTML representation of the XML format.
HTML is good for debugging, but is unsuitable for application use.
Specify the format parameter to change the output format.
To see the non HTML representation of the XML format, set format=xml.
See the complete documentation, or
API help for more information.
<?xml version="1.0"?>
<api>
<query>
<pages>
<page pageid="20" ns="0" title="Sujets en cours">
<revisions>
<rev contentformat="text/x-wiki" contentmodel="wikitext" xml:space="preserve">
==<br/> Intelligramme ==
<br/>
Un '''intelligramme''' est un datagramme couche six présentation. Il s'agit donc d'un concept multimatique utilisable au sein d'un "neb" pour supporter des échanges structurés comprenant à la fois de l'information et des [http://cnrtl.fr/definition/dmf/commandation commandations] <ref>c'est à dire, dans l'environnement PLUS des commandes que les retransmetteurs successifs et le receveur peuvent choisir d'exécuter ou d'ignorer selon ses raisons d'accès.</ref>).
'''DJSON''' entend être une approche de l'intelligramme pouvant être utilisée en environnent '''[http://yiam.net YIAMnet]''' ou '''nebDB''' <ref> netDB est un projet d'étude d'une systémique mémorielle intégrable à l'intrastructure du réseau.</ref>.
La description d'un intelligramme pourrait être celle d'un message (e-mail) structuré pour être utilisable aussi bien par un homme que par une machine.
* en-tête : les composants seraient associés en énonciation et réception à des utags ou à des ntags non transmis.
* intro : texte non-formaté ou formaté (par exemple "mediawiki").
* djson : utilisation d'un lexique polynyme des champs.
* pièces-jointes :
''<small><references/></small>''
== <br/>Délinéation, perlition et émergence ==
<br/>
'''DJSON''' introduit le support pratique du concept d'intellition. Ceci est une importante évolution par rapport à la théorie de l'information. Une formule simple pour faire comprendre la différence :
* l''''information''' est ce qui '''étend''' la '''connaissance'''.
* l''''intellition''' est ce qui '''l'approfondit'''.
L'information traite d'un point précis concernant la réalité observable : comme une photo. L'on peut ajouter d'autres photos pour constituer un panormama.
L'intellition va résulter de l'observation et du traitement de :
* ce qu'il renferme en '''profondeur''' : c'est une première application de la '''délinéation'''. Un domaine est délinéé, auquel vont appartenir toutes les informations obtenues en le pénétrant.
* ce qu'il sera possible d'observer "'''perligement'''" <ref> ces notions sont explorées sur le blik http://perligence.com.</ref> c'est à dire '''par l'entour''', à partir des points de cette pénétration et de sa dynamique : c'est la '''perlition'''.
* et de manière générale de la délinéation "'''plurigente'''" de cette perligence : ce qui a été identifié comme les '''classes''' (des '''énonciateurs''' et les '''groupes''' des '''auditeus'''.
Nous allons ainsi voire '''émerger''' peu à peu une "'''entendance'''", une connaissance multiple, croisée et complexe d'où va à son tour '''émerger''' la compréhension, plus rapidement (par le filtrage des syllodonnées entre '''classes''' et '''groupes''' au sein du réseau intersemantique ['''intersem''']).
== <br/>Hyperespace ==
<br/>
Un hyperespace est l'espace d'une agora de données non directement accessible aux membres d'une nébularité et donc a tous les membres d'une communauté globale telle que définie par la RFC 6852. Les données d'un hyperespace sont des hyperdonnées pour qui n'y a pas intérieurement accès (ex. les hyperliens) et doit les résoudre selon un processus filtrant.
==<br/>Sémiotique artificielle ==
<br/>
Une lecture plus complexe va pouvoir être supportée par une délinéation mise au service d'une perlition distribuée. Une classe d'origine d'intelligrammes pourra être délinées en plusieurs parties associées à des groupes de desserveurs. Lorsque l'intelligramme pénètre sur un de ces desserveurs la partie correspondante sera mise à jour. L'intelligramme pourra ainsi acquérir des compléments d'intellition. L'inter-compréhension sera atteinte lorsque le passage à travers tous les groupes de toutes les parties laissera l'intelligramme inchangé.
''<small><references/></small>''
<br/></rev>
</revisions>
</page>
<page pageid="35" ns="0" title="Utilisation Json comme base de données">
<revisions>
<rev contentformat="text/x-wiki" contentmodel="wikitext" xml:space="preserve">
(Cet article a été écrit il y a très longtemps, dans une galaxie très très lointaine, par un nakama inconnu)
Aujourd’hui on va voir comment utiliser le Json comme base de données. L’avantage est de ne plus avoir besoin de MySQL.
Cette solution peut être intéressante pour de petits sites qui ne demandent pas trop d’administration.
Cet article va montrer comment utiliser le format Json et quelques points intéressants &#63042; comme par exemple mettre en place une Api qui va stocker dans un fichier Json des utilisateurs.
Ce qu’il faut garder en tête ici, c’est que chaque fichier Json peut être comparé à une table d’une base de données.
__TOC__
==== Variables et constructeur ====
<pre>
class UserJson {
private $id;
private $data;
private $table;
private $table_id;
private $user;
private $users;
public function __construct(){
$this->table = "users.json";
$this->table_id = "users_id.txt";
// si le fichier n'existe pas, on le crée
if(!file_exists($this->table)){
$this->createTable();
}
}
</pre>
* ise en place des variables
* le constructeur va renseigner quelques informations : le nom du fichier Json et txt.
* on termine en vérifiant si les fichiers n’existent pas déjà, si ce n’est pas le cas on fera appel à la méthode qui les créera.
====Les méthodes====
<pre>
// création des fichiers Json et txt
// le fichier txt servira uniquement à l'incrémentation
public function createTable(){
$handle = @fopen($this->table, "a+");
$handle_id = @fopen($this->table_id, "a+");
if($handle && $handle_id) {
fclose($handle);
fclose($handle_id);
return true;
}
}
</pre>
<pre>
// Ajout d'un nouvel utilisateur
public function addUser($data){
// info sur le nouvel user
$this->data = $data;
// on récupère le nouvel ID
$this->id = $this->getId();
if( $this->id !== null ){
// on ajoute l'ID au nouvel user
$this->data = array('id'=>$this->id) + $this->data;
// on ajoute le nouvel user au fichier
$file = @fopen($this->table, 'a+');
fputs($file, json_encode($this->data).',');
fclose($file);
return true;
}else{
return "Erreur pour l'ajout de l'utilisateur.";
}
}
</pre>
* a méthode getId() récupère un nouvel identifiant qui est contenu dans le fichier txt
* ligne 10 : on teste bien que le résultat n’est pas null sinon c’est qu’il y a eu un problème lors de la création de l’identifiant
* chaque utilisateur est sauvegardé sous cette forme : {« id »:31, »pseudo »: »Iron Man », »date »:1387821811},
<pre>
// on récupère un nouvel ID
private function getId(){
if( $txt = @fopen($this->table_id, "r+") ){
$this->id = fgets( $txt ); // récupération de la valeur
$this->id = intval( $this->id ); // on vérifie qu’il s’agit bien d’un nombre
$this->id++; // on incrémente
fseek( $txt, 0 ); // réinitialisation du curseur
fputs( $txt, $this->id ); // on écrit le nouveau nombre
fclose($txt);
return $this->id;
}else{
return null;
}
}
</pre>
Une simple méthode pour récupérer la valeur qui se trouve dans le fichier, l’incrémenter et ensuite sauvegarder la nouvelle valeur. J’ai repris la méthode du site openclassrooms pour compter le nombre de téléchargement.
Ici l’élément important : c’est que la méthode est en private, cela signifie qu’on va pouvoir y faire appel uniquement à l’intérieur de la class. Du coup on est certain qu’elle ne peut pas être appelé de l’extérieur, donc un identifiant sera créé uniquement quand on l’appellera dans la class elle-même.
<pre>
// on récupère un user spécifique
public function getUser($id){
// l'id de l'user qu'on souhaite récupérer
$this->id = $id;
// liste de tous les users
$datas = $this->getAllUser();
// on teste si l'id correspond, si oui on renvoie le résultat
foreach ($datas as $key => $row) {
if($row->id == $id ) return $row;
}
// sinon
return 'Aucun utilisateur ne correspond.';
}
</pre>
<pre>
// liste de tous les users
public function getAllUser(){
// Si les users sont déjà définis
if (isset($this->users)) return $this->users;
// on récupère le contenu du fichier
$contents = file_get_contents($this->table);
$this->users = json_decode("[". substr($contents, 0, -1)."]");
// on renvoi le tableau des users
return $this->users;
}
</pre>
* ligne 5 : elle permet de renvoyer directement tous les utilisateurs si la variable est déjà définie. Cela évite de faire plusieurs fois le travail si on appelle cette méthode plusieurs fois dans un même object
* on récupère le contenu encoder en Json, que l’on va décoder pour pouvoir l’utiliser
Cependant, les données sont sauvegardées de cette manière :
<pre>
{"id":31,"pseudo":"Iron","date":1387821811},{"id":32,"pseudo":"Iron","date":1387821811},{"id":33,"pseudo":"Iron","date":1387821811},
</pre>
Et pour pouvoir décoder le format Json les données doivent être comme cela :
<pre>
[{"id":31,"pseudo":"Iron","date":1387821811},{"id":31,"pseudo":"Iron","date":1387821811},{"id":31,"pseudo":"Iron","date":1387821811}]
</pre>
C’est pour cela que j’ajoute les [ ] et que je supprime la dernière virgule (ligne 9).
Il est tout à fait possible de faire autrement, enregistrer directement le tableau des utilisateurs, du coup on aura tout de suite la bonne syntaxe. Cependant, pour chaque ajout il faudrait tout récupérer et ré-écrire à chaque fois … perso je préfère écrire uniquement le nouvel utilisateur
<pre>
// modification d'un utilisateur
public function updateUser($id, $data){
$this->id = $id;
$this->data = $data;
// liste de tous les users
$this->users = $this->getAllUser();
// on ouvre et on vide le fichier
if($handle = @fopen($this->table, "w+")) {
$this->data = "";
foreach ($this->users as $key => $row) {
// si l'id correspond
// on modifie le nouveau pseudo par exemple
if( $row->id == $this->id ){
if($data['pseudo'] != "") $row->pseudo = $data['pseudo'];
}
$this->data .= json_encode($row).',';
}
// on ajoute tous les utilisateurs dans le fichier
fputs($handle, $this->data);
fclose($handle);
return true;
}
}
</pre>
<pre>
// suppression d'un utilisateur
public function removeUser($id){
$this->id = $id;
// liste tous les users
$this->users = $this->getAllUser();
if($handle = @fopen($this->table, "w+")) {
$this->data = "";
foreach ($this->users as $key => $row) {
if($row->id == $this->id )
unset($this->users[$key]);
else
$this->data .= json_encode($row).',';
}
fputs($handle, $this->data);
fclose($handle);
return true;
}
}
</pre>
La suppression se passe plus ou moins comme la modification, on regarde si l’id correspond, si oui on le supprime du tableau des utilisateurs et ensuite on ré-écrit le tout dans le fichier.
On n’oublie pas la dernière accolade de la class &#63042;
<pre>
}
</pre>
====C’est fini====
La class permet de créer, de modifier, de supprimer et de lister tous les utilisateurs. Évidemment, elle peut être améliorée &#63042; ici je propose uniquement une base comme exemple &#63042;
====Mais il ne manque rien ?====
Il manque peut-être les appels à la class &#63042; enfin la création de l’object.
<pre>
// initialisation
$json = new UserJson();
// liste de tous les utilisateurs
print_r( $json->getAllUser() );
// appel d'un utilisateur spécifique
print_r( $json->getUser(31) );
// ajout d'un nouvel utilisateur
$user = array('pseudo' => 'Batman', 'date'=>time());
var_dump( $json->addUser($user) );
// modification d'un utilisateur
$update = array('pseudo'=>'Thor');
var_dump( $json->updateUser(44, $update) );
// suppression d'un utilisateur
print_r( $json->removeUser(42) );
</pre>
====Idées d’amélioration ?====
* Pseudo et email unique
* Rajouter des champs : mdp, email, date de modification etc.
* Mettre en place une 2e table pour classer les utilisateurs par catégories
* Mettre en place un système d’identification (login/mdp)
* etc.</rev>
</revisions>
</page>
</pages>
</query>
</api>