Introduction au modèle RDF

Resources

Le RDF (Resource Description Framework) est un modèle pour le stockage d'informations sous forme de graphes. Le RDF est employé pour créer des rapports entre différentes ressources, chaque ressource étant une chose, telle qu'une personne, une chanson, une page Web ou un marque-page. Certains considèrent le RDF comme un langage XML de description de données. Cependant, le format RDF/XML est juste une méthode pour stocker du RDF dans un fichier. Si vous essayez d'apprendre le RDF, il peut être déroutant de l'apprendre par l'intermédiaire de la syntaxe RDF/XML ; c'est pourquoi le modèle RDF est décrit ci-dessous, dans assez de détail pour le comprendre sans discuter de la syntaxe RDF/XML.

Imaginez un enchaînement ou un graphique de noeuds interconnectés. Les noeuds sont reliés par l'intermédiaire de diverses relations. Par exemple, disons que chaque noeud représente une personne. Chaque personne pourrait être liée à une autre personne parce qu'elles sont enfants de mêmes parents, parents, conjoints, employés ou des ennemis. Chaque connexion porte le nom de la relation entre les noeuds.

Un autre type de relations est les propriétés physiques d'un noeud. Par exemple, le nom ou l'âge d'une personne. Ces relations seraient nommées par 'nom' et 'âge' au lieu de 'enfant de mêmes parents' ou 'parent'.

le RDF est employé pour décrire ces relations. Il n'inclut pas réellement directement les noeuds, mais indirectement grâce aux relations pointant vers les noeuds. À tout moment, nous pourrions ajouter un nouveau noeud, tel qu'un enfant nouveau-né, et tout ce que nous devons faire est d'ajouter deux liens parents, un pour chaque parent.

Dans le RDF, les noeuds peuvent être de deux types très généraux, ressource ou littéral. Un littéral est une valeur réelle, telle que le nom 'Sandra' ou le nombre '7'. Vous pourriez penser à un littéral comme une chaîne de caractères une fois utilisé dans un langage de programmation. Une ressource se rapprocherait plus d'un objet dans un langage de programmation. Par exemple, une personne serait une ressource, mais le nom de la personne serait un littéral.

Dans le RDF, des ressources sont associées à des URIs permettant de les identifier. Puisqu'un URI est unique, nous pouvons identifier une ressource spécifique. La valeur de l'URI n'est pas vraiment importante dans le RDF puisqu'elle est juste employée comme identifiant. Vous pouvez employer une certaine convention tel qu'un URI qui inclurait un numéro de série permettant d'identifier un objet physique.

Triplets

Nous pouvons ajouter des relations entre deux ressources ou entre une ressource et un littéral. Ces liens s'appellent souvent des triplets ou des arcs. Voici quelques exemples :

<http://www.site.com/rdf/people/Sandra>  ->  name     ->  Sandra

<http://www.site.com/rdf/people/Sandra>  ->  gender   ->  femelle

<http://www.site.com/rdf/people/Sandra>  ->  sibling  ->

      <http://www.site.com/rdf/people/Kevin>

<http://www.site.com/rdf/people/Kevin>   ->  gender   ->  male

Par convention dans cette documentation, les items écrits entre les signes supérieurs et inférieurs seront les ressources tandis que les autres seront les littéraux. Quatre triplets sont définis ci-dessus. Le premier indique que la ressource <http://www.site.com/rdf/people/Sandra> a pour nom Sandra. Le second indique que la même ressource a un genre femelle. Le troisième triplet indique que l'enfant de mêmes parents est une autre ressource <http://www.site.com/rdf/people/Kevin>. Le triplet final indique un genre pour la ressource <http://www.site.com/rdf/people/Kevin>.

Aucun nom n'a été fourni pour la ressource <http://www.site.com/rdf/people/Kevin>. En tant que lecteur humain, nous pourrions supposer que le nom est probablement le littéral 'Kevin ', mais le système informatique n'a aucune manière de le savoir. Nous pourrions employer n'importe quelle forme d'URI pour la ressource ; par exemple ce qui suit serait juste et acceptable :

<urn:x-person:S1>  ->  name  ->   Sandra

La ressource <urn:x-person:S1> ne veut rien dire pour un humain, et serait juste et compréhensible par un système informatique. En fait, un URI moins significatif pour un humain pourrait être meilleur puisque l'arrangement utilisé avec <http://www.site.com/rdf/people/Sandra> ne fonctionnerait pas si quelqu'un d'autre s'appelait Sandra.
Notez que le fait qu'un URI HTTP soit employé ne signifie pas qu'il soit associé à un site Web par le protocole HTTP, bien qu'il vous soit possible de prévoir un téléchargement à cette adresse. En fait, vous devriez utiliser le nom de votre Web pour créer les URIs afin de garantir leur unicité et éviter à d'autres de les utilisés.
Cependant, ces deux règles ne permettent pas au système de déterminer si Sandra est un frère ou une soeur de Kevin, puisque ces deux règles n'indiquent pas le genre de Sandra. Pour cela, nous aurions besoin de la règle appropriée d'un des exemples précédents.
L'étiquette bestFriend, et les autres utilisées ci-dessus s'appellent des prédicats. L'élément à gauche de chaque triplet s'appelle le sujet et celui à droite s'appelle l'objet ou la cible. Le sujet sera toujours une ressource, alors que la cible peut être soit une ressource ou soit un littéral. Vous n'aurez jamais un littéral en relation avec un autre littéral.
Pour les besoins de cette documentation, nous omettrons parfois l'espace de nommage des prédicats pour simplifier les exemples. Les prédicats étant également des ressources, vous pouvez créer des rapports entre un prédicat et autre chose. Cette utilisation sert généralement à définir des propriétés décrivant la signification d'un prédicat, en formant un vocabulaire formel pour ce prédicat.

L'URI est juste un identifiant. Le RDF ne s'inquiète pas de ce qu'il est. Mais si le même URI est employé en plusieurs endroits, le RDF comprendra que tous se rapportent à la même ressource. Dans le premier exemple, plusieurs <http://www.site.com/rdf/people/Sandra> étaient présents, mais ils représentaient tous une même chose.

Le fait de ne pas avoir spécifié de nom pour la ressource <http://www.site.com/rdf/people/Kevin> ne signifie pas qu'il n'y en a pas. Si le triplet n'est pas spécifié dans le graphe, il ne faut pas considérer que la valeur n'existe pas, mais plutôt que la valeur n'est pas connue ou qu'elle sera fournie plus tard.

Dans l'exemple, vous aurez noté que nous n'avons pas précisé si Kevin est un frère ou une soeur de Sandra. Nous l'avons simplement défini comme 'enfant de mêmes parents'. Toutefois, le système peut le déterminer grâce aux informations fournies et un peu de logique. Par exemple, si le système sait qu'un frère est un enfant male de mêmes parents, il peut déterminer que Kevin est le frère de Sandra en utilisant seulement deux triplets :

<http://www.site.com/rdf/people/Sandra>  ->  sibling  ->

      <http://www.site.com/rdf/people/Kevin>

<http://www.site.com/rdf/people/Kevin>   ->  genre   ->  male

RDF nous permet de composer des ressources, des littéraux, et même les étiquettes des arcs (tels que 'enfant de mêmes parents'). Ainsi, nous pouvons créer une nouvelle étiquette à tout moment :

<http://www.site.com/rdf/people/Sandra>  -> bestFriend  ->

      <http://www.site.com/rdf/people/Christine>

Pour assurer l'unicité de l'information, les prédicats sont également identifiés par des URIs. Il y aura un URI unique pour chaque prédicat. Par exemple, l'URI pour 'enfant de mêmes parents' pourrait être <http://www.site.com/rdf/people/sibling>. Habituellement, les étiquettes de prédicats ayant un rapport entre eux auront des espaces de nommage semblables avec le style XML. Le dernier exemple serait ainsi représenté :

<http://www.site.com/rdf/people/Sandra>  ->

      <http://www.site.com/rdf/people/bestFriend>  ->

            <http://www.site.com/rdf/people/Christine>

Vous pouvez avoir de multiples triplets avec le même sujet si vous le souhaitez :

<http://www.site.com/rdf/people/Sandra>  ->  name  ->  Sandra

<http://www.site.com/rdf/people/Sandra>  ->  name  ->  Sandy

Ici, la même ressource a un triplet de même prédicat mais avec une cible différente. Dans cet exemple, nous pouvons imaginer que plusieurs noms peuvent signifier l'emploi de surnoms. RDF ne trie pas les noms, donc chacun d'eux a la même pertinence. N'imaginez pas que si Sandra est le premier triplet affiché, il est plus important que Sandy.

Supposons que nous décidons d'ajouter une autre personne également appelée Sandra :

<http://www.site.com/rdf/people/SandraJr>  ->  name  ->  Sandra

La ressource est différente de celle des exemples précédents car elle représente une personne différente ayant toutefois le même nom. Avec la plupart des APIs RDF, les requêtes peuvent être bi-directionnelles. Si vous ne disposez que du nom Sandra, il vous est possible de lancer une requête inversée pour obtenir toutes les ressources liées à ce nom.

Types

Parfois il est utile de pouvoir identifier le genre d'une ressource, tout comme la façon dont les systèmes orientés objets emploient des classes à cette fin. Le RDF emploie un type à cette fin. En plus des deux types très généraux, ressource et littéral, un type précis peut être attribué à une ressource. Par exemple, la ressource Sandra pourrait avoir un type définissant une personne. La valeur de ce type devrait alors être associée à une autre ressource complétant les informations que le type fournit.

Comme avec d'autres propriétés, les types sont également spécifiés avec un triplet :

<http://www.site.com/rdf/people/Sandra>  ->  rdf:type  ->
      <http://xmlns.com/wordnet/1.6/Person>

La ressource <http://site.com/wordnet/1.6/Person> est employée pour représenter une personne. L'URI est basé sur WordNet qui fournit des URIs de ressources pour des mots. Le prédicat est rdf:type est dans l'espace de nommage de RDF puisque l'attribut type est intégré à RDF. Le nom complet est http://www.w3.org/1999/02/22-rdf-syntax-ns#type. Ici, nous employons rdf: comme abréviation pour l'espace de nommage du RDF, comme pour un document XML. Il est employé ici comme tel pour simplifier l'exemple -- le prédicat est toujours le nom complet avec l'espace de nommage.

Nous pouvons également composer nos propres types. Dans l'exemple ci-dessous nous associons le type <http://www.site.com/rdf/example/Poem> comme type d'une ressource dont l'URI laisse deviner qu'il s'agit d'un poème.

<http://www.site.com/rdf/something/785>  ->  rdf:type  ->
      <http://www.site.com/rdf/example/Poem>

Quelques types de liste

RDF dispose d'un certain nombre de types intégrés pour représenter des listes de choses. Reprenons un exemple précédent où Sandra avait deux noms. Il était mentionné que les noms n'avaient pas d'ordre particulier. Parfois, il peut être utile de pouvoir mettre un ensemble de valeurs dans un ordre particulier. Vous pourriez réfléchir aux manières pour contourner ceci, par exemple en utilisant des attributs 'name1', 'name2' et ainsi de suite. RDF a un mécanisme intégré pour faire ce genre de chose.

En RDF, un prédicat constitué d'un nombre précédé par un underscore est employé comme un item d'une liste. Par exemple, rdf:_1 est employé pour indiquer le premier item d'une liste. Nous employons encore l'espace de nommage du RDF. Par exemple, nous pourrions créer une liste de choses comme ceci :

<http://www.site.com/rdf/people/Karen>  ->  rdf:_1  ->
      <http://www.site.com/rdf/people/Sandra>
<http://www.site.com/rdf/people/Karen>  ->  rdf:_2  ->
      <http://www.site.com/rdf/people/Kevin>
<http://www.site.com/rdf/people/Karen>  ->  rdf:_3  ->
      <http://www.site.com/rdf/people/Jack>

Ici, <http://www.site.com/rdf/people/Karen> est une liste de trois items. Nous, en tant qu'humains, pourrions présumer que les trois items sont les enfants de Karen à la différence du système informatique, mais votre application pourrait faire cette hypothèse. Les trois prédicats ne sont en aucun cas spécifiques, car nous pourrions employer 'name1', 'name2' et 'name3'. Cependant, puisque le RDF permet les prédicats ci-dessus intégrés, nous devrions les employer autant que possible.

Puisque rdf:_XXX représente juste des prédicats, comme n'importe quels autres, nous pourrions indiquer des valeurs multiples avec le même nombre, ou nous pourrions omettre certaines valeurs :

<http://w>w.site.com/rdf/people/Karen>  ->  rdf:_1  ->
      <http://www.site.com/rdf/people/Sandra>
<http://www.site.com/rdf/people/Karen>  ->  rdf:_6  ->
      <http://www.site.com/rdf/people/Kevin>
<http://www.site.com/rdf/people/Karen>  ->  rdf:_6  ->
      <http://www.site.com/rdf/people/Billy>
<http://www.site.com/rdf/people/Karen>  ->  rdf:_8  ->
      <http://www.site.com/rdf/people/Jack>


Ce qui précède est une liste contenant quatre items. Cependant, les nombres ne sont pas séquentiels. La création de tels triplets n'est pas fréquent, mais une liste contenant des omissions de nombres se rencontre lorsque des items ont été effacés.

Afin que le RDF puisse traiter ces prédicats numérotés d'une manière spéciale -- rappelez-vous que ce sont juste des prédicats ordinaires -- le RDF exige également d'employer un type spécial pour les listes. Plusieurs types de liste sont disponibles :

rdf:Seq :
une liste ordonnée, qui est ce que nous voulons utiliser pour les exemples précédents.
rdf:Bag :
une liste non ordonnée.
rdf:Alt :
une liste de valeurs alternatives où seule une valeur sera utilisée.
Pour les exemples ci-dessus, nous emploierons rdf:Seq pour que les items soient placés dans un ordre spécifique. Nous emploierions rdf:Bag si l'ordre des items n'importait pas. Il n'y aurait aucune différence avec l'emploi de plusieurs prédicats 'nom' identiques, toutefois si le type est rdf:bag, nous saurions que la ressource contient une liste de noms au lieu d'un seul. Pour des noms, nous pourrions employer un type rdf:Alt lorsqu'une application devra utiliser un seul des noms à la fois.

Nous assignons ces types de liste simplement comme n'importe quel autre type décrit ci-avant :

<http://www.site.com/rdf/people/Karen>  ->  rdf:type  ->
      <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>

Ici, l'espace de nommage 'rdf' est utilisé pour la valeur à atteindre. Maintenant que Karen est du type rdf:Seq, nous pouvons ajouter les trois enfants comme ci-dessus. Le problème ici est que maintenant que Karen est du type rdf:Seq, elle n'est plus du type personne Person. Nous pourrions résoudre ce problème en assignant un deuxième type à Karen, comme avec d'autres prédicats. Une meilleure manière est d'employer une deuxième ressource comme conteneur de la liste des enfants de Karen. Karen restera une personne, mais la liste d'enfants sera du type rdf:Seq.

<http://www.site.com/rdf/people/Karen>       ->  rdf:type  ->
      <http://xmlns.com/wordnet/1.6/Person>
<http://www.site.com/rdf/people/Karen>       ->  children  ->
      <http://www.site.com/rdf/people/KarensKids>
<http://www.site.com/rdf/people/KarensKids>  ->  rdf:type  ->
      <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>
<http://www.site.com/rdf/people/KarensKids>  ->  rdf:_1    ->
      <http://www.site.com/rdf/people/Sandra>
<http://www.site.com/rdf/people/KarensKids>  ->  rdf:_2    ->
      <http://www.site.com/rdf/people/Kevin>
<http://www.site.com/rdf/people/KarensKids>  ->  rdf:_3    ->
      <http://www.site.com/rdf/people/Jack>


Nous avons fait de Karen une personne, et lui avons assigné un lien avec une ressource <http://wwwsite.com/rdf/people/KarensKids> par l'intermédiaire du prédicat enfants children. Au lieu d'associer les trois enfants directement à Karen, nous les associons à cette ressource supplémentaire qui a un type rdf:Seq. Le résultat est que Karen est associée aux trois enfants mais en conservant un type unique de personne.

En termes de RDF, nous n'avons pas besoin d'indiquer explicitement l'URI <http://www.site.com/rdf/people/KarensKids>. Puisque le modèle ci-dessus est généralement employé, RDF permet d'utilisation des noeuds vides ou des ressources anonymes. Une API RDF vous permettra de créer ces noeuds, et habituellement un URI pourrait être aléatoirement produit pour vous. Techniquement, ils n'ont pas d'URIs, mais vous pouvez toujours les manipuler comme des ressources, et ajoutez ou enlevez des triplets qui leurs sont liés

Dans tous les exemples ci-dessus, nous avons toujours défini des triplets. Chaque ligne a un sujet, un prédicat et un objet. Même lorsque nous définissons des types et des listes, nous employons toujours des triplets pour les définir. Le RDF est seulement une liste de triplets, ou de liens entre les choses.

Une chose intéressante au sujet de RDF est que nous pourrions prendre une liste de triplets d'une source et les combiner avec des triplets d'une autre source. Puisque l'ordre est sans importance, nous aurions le même résultat que si nous avions commencé par les définir ensemble. Par exemple, supposons qu'une autre source fournisse le triplet suivant :

<http://www.site.com/rdf/people/KarensKids>  ->  rdf:_4  ->
      <http://www.site.com/rdf/people/Wendy>

Une fois combiné avec l'exemple précédent, il signifierait que Karen aurait maintenant quatre enfants au lieu de trois. C'est un aspect important du RDF -- pouvoir combiner ou agréger des données de sources multiples.

Exemple de triplets

Dans le contexte d'un navigateur, les marque-pages peuvent être stockés comme une série de triplets RDF.


  <urn:x-mark:1>  ->  Name         ->  site.com
  <urn:x-mark:1>  ->  URL          ->  <http://www.site.com>
  <urn:x-mark:1>  ->  LastVisited  ->  Sept 8, 2003
  <urn:x-mark:2>  ->  Name         ->  mozilla.org
  <urn:x-mark:2>  ->  URL          ->  <http://www.mozilla.org>

Cet exemple contient cinq triplets décrivant deux marque-pages. Chaque marque-page a un nom Name et une URL, et l'un d'eux a un prédicat LastVisited. Les valeurs de l'URL sont placées dans une autre ressource, ce qui signifie qu'elles pourraient être employées dans d'autres triplets.

Si vous avez différents types de marque-pages, vous pourriez créer un type pour chacun d'eux. Par exemple, votre application pourrait avoir un concept d'abonnement stocké comme un marque-page, ainsi vous pourriez employer un type pour celui-ci :

  <urn:x-mark:1>  ->  rdf:type  -> http://www.site.com/rdf/example/Subscription

Vous pourriez utiliser la convention disant qu'un marque-page de type Seq est un dossier de marque-pages. Les enfants de ce Seq seraient les marque-pages stockés dans le dossier.

  <urn:x-mark:folder>  ->  rdf:type  <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>
  <urn:x-mark:folder>  ->  rdf:_1    <urn:x-mark:1>
  <urn:x-mark:folder>  ->  rdf:_2    <urn:x-mark:2>

Il s'agissait seulement d'un exemple des genres de choses pouvant être stockés avec RDF. Presque toute sorte de données peuvent être gérée avec RDF.

Apprendre le Javascript : les bases du langage

Cette partie du site consacrée à Javascript ne ressemble en rien aux pages web que vous avez déjà visitées sur le même sujet !

En effet, je n'ai pas l'intention de faire un cours magistral avec des chapîtres, des tomes I et II (d'ailleurs, j'en serai bien incapable :o) et je ne pense pas que cela vous plairait !)

Non, je vais vous faire aborder Javascript comme je l'ai moi-même abordé, ce qui veut dire avec plus ou moins de bonheur...

Allez, c'est parti !

En HTML, pour écrire ou afficher des données, vous insérez ces données directement dans le <body> pour le texte, par la balise <img src=""> pour les images, et <embed> pour le reste.

Ce qui fait surtout l'interêt de Javascript, c'est sa capacité à s'intégrer au code html environnant. En Javascript, la fonction qui combine toutes ces... combinaisons(!) est la fonction write(), embarquée (c'est-à-dire intégrée dans le code-même de Javascript).

** Exemple :

<html>
<body>
<script language="Javascript">
document.write("Bonjour")
</script>
</body>
</html>

va afficher Bonjour sur le "document" que constitue la page web. Vous noterez au passage que les guillemets ont pour fonction de délimiter la variable à afficher.

** Vous pouvez dans le code de Javascript insérer des codes HTML :

<script>
document.write("<b>Bonjour</b>")
</script>

va afficher Bonjour

** On peut aussi insérer des images :

<script>
document.write("<img src='mon_image.jpg'>")
</script>

On notera simplement que habituellement en HTML, dans <img src=""> on met des guillemets et qu'ici on a mis des guillemets "simples" qu'on nomme "quotes". Pourquoi ? Parce qu'en Javascript, lorsqu'une variable est déjà délimitée par des guillemets "doubles", tout ce qui se trouve à l'intérieur ne peut recevoir que des "quotes", des apostrophes. C'est ainsi !

Vous savez maintenant afficher avec document.write() du texte, des images. La belle affaire !
Le HTML vous le permettait déjà ! Alors c'est quoi l'interêt de Javascript ?

En HTML, vous pouviez afficher du texte, des images mais pas l'utilisateur... Pour que l'utilisateur, il le mérite bien :o), puisse lui-aussi sortir de sa passivité, il doit faire appel à des fonctions, qui elles-mêmes vont faire appel à Javascript. Une chaîne donc, dont vous serez l'initiateur.

**Pour faire appel à des fonctions Javascript, l'utilisateur doit agir. Agir sur les éléments de votre page web, par des "Event Handlers", en français des gestionnaires d'évenements (survol ou clic d'un lien, d'un bouton, d'un texte, d'une image...)

Exemple :



** Nouvelle fonction :
L'exemple que vous venez de voir a fait appel à une autre fonction embarquée alert().Cette fonction, vous l'aurez remarqué :o) fait apparaître une boîte de dialogue. La syntaxe est la même que pour la fonction document.write().

<script>
alert("Vous êtes bien curieux !")
</script>

Mais cette fonction est incapable par elle-même d'être, d'exister, d'agir ! Elle a besoin pour "vivre" d'un "event handler", ici, un bouton par lequel vous avez activé la fonction alert().

<input type="button" value="exemple" onClick="javascript:alert('Vous êtes bien curieux !')">

Traduction :
Au moment du clic, le bouton va faire appel à Javascript pour activer la fonction nommée alert(). Ici la fonction alert() est définie au sein même de l'event handler, mais ce n'est pas toujours le cas.

Apprendre les bases de données MySQL

MySQL est dérivé de SQL (Structured Query Language), en français, langage de requête structurée. Concrètement, SQL permet de dialoguer avec une base de données en langage presque courant, étant entendu que le langage dont il est question ici est l'anglais...

SQL s'utilise surtout via une fenêtre de commande, MySQL s'utilisant via un langage de programmation, PHP étant LE langage de prédilection de MySQL... 

Le meilleur moyen de se mettre à MySQL et de progresser est d'installer EasyPHP, un logiciel freeware qui crée un environnement serveur complet à la fois pour PHP et MySQL. 

Une base de données s'apparente à un tableau comportant des lignes appelées des enregistrements : si la base de données (bdd) comporte 6 lignes, cela signifie qu'il existe 6 enregistrements. Chaque enregistrement comporte un ou plusieurs champs. Un enregistrement extrait d'un carnet d'adresses simplifié pourrait, par exemple se présenter ainsi : 

id_user, nom, prénom, age. 

Les types de données avec MySQL

Au moment de créer une table, vous devez vous demander ce qu'elle va contenir car le type (de données) de chaque champ est très important et aura des conséquences dans la suite des évènements. 

Ainsi, dans notre table que nous nommerons "carnet", le champ "nom" pourra contenir n'importe quel caractère alors que le champ "âge" ne devrait en toute logique accueillir que des numériques. Voici un aperçu des types possibles acceptés par MySQL : 

create table carnet (
nom varchar,
prenom varchar,
age int
);

MySQL vous permet de spécifier pour chaque type le nombre de caractères qu'il sera possible de stocker. Si vous prévoyez qu'aucun de vos contacts n'aura un nom plus long que 50 caractères et qu'aucun de vos contacts n'aura raisonnablement plus de 99 ans, vous pourrez coder : 

create table carnet (
nom varchar (50),
prenom varchar (50),
age int (2)
);

Les différents types proposés par MySQL sont classés en 3 catégories :

• les numériques
• les alphanumériques
• les types "date" (non décrits ici)

Les types numériques

• Ils peuvent être classés à leur tour par rapport à leur "longueur", ie, la taille des données qu'ils peuvent accueillir. Dans l'ordre décroissant, on trouve principalement :int (accepte des nombres de -2147483648 à +2147483647)
• mediumint (accepte des nombres de -8388608 à +8388607)
• smallint (accepte des nombres de -32768 à +32767)
• tinyint (accepte des nombres de -128 à +127)

Note : chaque type accepte un nombre compris dans la plage des valeurs entre parenthèses 
Note 2 : un type peut accepter ou pas les valeurs négatives (par défaut, elles sont acceptées) 
Note 3 : il existe d'autres types (bigint, décimaux) décrits sur le site officiel de MySQL... 

Pour revenir à notre table "carnet", il en ressort que nous pouvons modifier certains éléments. En particulier, le champ "age", de toute évidence, ne doit pas être de type int mais de type tinyint. Et comme il s'agit de l'âge de nos contacts, il n'y a aucune raison de permettre des valeurs négatives.

Nous devrions donc coder notre table ainsi : 

create table carnet (
nom varchar (50),
prenom varchar (50),
age tinyint (2) unsigned
);

C'est du pareil au même, direz-vous... Simplement sachez que MySQL réserve pour chaque champ un espace mémoire spécifique. Ainsi, pour le champ int, 4 octets sont réservés et seulement 1 pour le champ tinyint... Si votre table contient finalement 10000 enregistrements * 1 octet ou 4 (selon le type choisi), la différence sur le poids de votre base peut aller du simple au quadruple ! 

Lorsque vous créez votre table "carnet", vous avez l'intention d'enregistrer plusieurs contacts. Pour différencier les données qui vont venir alimenter la table, MySQL se sert des identifiants. Il s'agit d'un numéro associé à chaque enregistrement, un peu comme un numéro de série. Ce nombre s'auto-incrémentera à chaque enregistrement et il vous appartient de créer ce champ explicitement : 

create table carnet (
id_carnet smallint unsigned auto_increment,
nom varchar (50),
prenom varchar (50),
age tinyint (2) unsigned
);

Nous avons choisi délibérément smallint car raisonnablement on peut penser que vous aurez sensiblement moins de 2147483647 contacts (comme envisagés avec le type int) et plus que les 127 prévus par le typetinyint... 

Note : nous avons indiqué aussi que ce champ ne pouvait pas être négatif (avec unsigned) et explicitement déclaré qu'il s'auto-incrémentait avecauto-increment.

Les types alphanumériques

• Les principaux sont :char (accepte de 1 à 255 caractères). ex. char(5)
• varchar (accepte de 1 à 255 caractères) ex. varchar(30)
• text (accepte jusqu'à 65535 caractères)

Note : char occupe un espace mémoire fixe. Si vous codez char(8) et que les données saisies font 4 caractères, ce champ occupera tout de même 8 caractères en mémoire. Le type varchar permet d'ajuster cet espace mémoire. Si vous déclarez varchar(20) et que les données saisies font 5 caractères, votre champ n'occupera effectivement que 5 caractères. 

Présentation Générale C++

Généralités

Puisque cela n’est pas foncièrement utile, je vous fais grâce de l’historique du langage C++. Vous devez juste savoir, éventuellement, qu’il a été conçu par Bjarne Stroustrup, ce qui aide pour trouver l’excellente bible du C++, écrite par lui-même[1].

Pour commencer cette présentation, parlons de quelques généralités, et d’abord du pourquoi du C++.

C’est avant tout une nécessité de répondre à des besoins générés par de gros projets. Ils nécessitent une façon de travailler plus rigoureuse, pour un code plus structuré, extensible, réutilisable et enfin si possible, portable. Ceci est assez limité lorsque l’on emploie un langage simplement structuré tel que C ou Turbo Pascal.

Programmation Orientée Objet

La Programmation Orientée Objet (P.O.O.) est une solution. Elle permet d’introduire le concept d’objet justement, qui consiste en un ensemble de données et de procédures qui agissent sur ces données.

Lorsque l’objet est parfaitement bien écrit, il introduit la notion fondamentale d’Encapsulation des données. Ceci signifie qu’il n’est plus possible pour l’utilisateur de l’objet, d’accéder directement aux données : il doit passer par des méthodes spécifiques écrites par le concepteur de l’objet, et qui servent d’interface entre l’objet et ses utilisateurs. L’intérêt de cette technique est évident : l’utilisateur ne peut pas intervenir directement sur l’objet, ce qui diminue les risques d’erreur, ce dernier devenant une "boîte noire".

Une autre notion importante en P.O.O. est l’héritage. Elle permet la définition d’une nouvelle classe à partir d’une classe existante. Il est alors possible de lui adjoindre de nouvelles données, de nouvelles fonctions membres (procédures) pour la spécialiser.

Différences entre C et C++

Nous allons parler ici d’un certain nombre de différences existant entre le C et le C++. Nous pourrions d’ailleurs plutôt utiliser le terme d’incompatibilités.

Les fonctions

Les fonctions en C peuvent être définies suivant deux modèles :

int CalculeSomme ( a, b )
int a; 
int b; 
{ 
     ... /* Fonction */ 
}    
int CalculeSomme ( int a, int b ) 
{ 
     ... /* Fonction */ 
}

Il faut simplement savoir que le C++ n’accepte que la seconde méthode.

Const

Le C++ a quelque peu modifié l’utilisation "C" de ce qualificatif. Pour rappel, "const" est utilisé pour définir une variable constante. C’est une bonne alternative à un define.

La portée en C++ est désormais plus locale. En C, un const permettait pour une variable globale d’être "visible" partout. C++ limite quant à lui la portée d’une telle variable, au fichier source contenant la déclaration.

Compatibilité de pointeurs

En C ANSI, un "void*" est compatible avec tout autre type de pointeurs, et inversement.

Par exemple, ceci est légal en C :

/* C */
void * pQqch;    /* Pointeur générique */
int * pEntier;    /* Pointeur sur un entier */
pEntier = pQqch;
pQqch = pEntier; 

Ces affectations font intervenir des conversions implicites. En C++, seule la conversion int* --› void* est implicite. L’autre reste possible, mais nécessite ce que l’on nomme un "cast" :

// C++ 
void * pQqch;             // Pointeur générique 
int * pEntier;            // Pointeur sur un entier 
pEntier = (int*)pQqch;  // "cast" en entier

Les fonctions en Javascript

En effet, il arrive très souvent que les fonctions soient bien plus complexes et bien plus "encombrantes" que cette fonction alert(). De plus, une même fonction peut être appelée plusieurs fois dans une même page web.

D'où l'interêt de définir à l'avance la fonction et de la stocker dans un endroit "sûr" : la partie <head> de la page HTML.

Posons que nous ayons besoin de la fonction alert() pour faire apparaître les messages "Bienvenue chez vous !" ou "Votre code est erroné !" dans une boîte de dialogue selon qu'un champ contient ou non une certaine valeur. Dans notre exemple, nous savons aussi que cette fonction sera sollicitée 10 fois dans la même page.

Nous avons le choix entre écrire la fonction alert() et sa "longue" variable autant de fois que nécessaire dans la page OU créer cette fonction et simplement faire appel à elle au moment voulu.

Voici la fonction qui recourt à la fonction Javascript alert() :

<script>
function quoi () 
{
var d="mon_code"
if (document.forme.champ.value==d)
{
alert("Bienvenue chez vous !")
}
else
{
alert ("Votre code est erroné !")
}
}
</script>

Traduction :
Si le champ contient la valeur "d" donc le bon code "mon_code", "Bienvenue chez vous" s'affiche, sinon l'écran indiquera "Votre code est erroné".
** Note :
>  une fonction porte un nom (ici elle s'appelle quoi)
>  tout comme document.write() ou alert(), votre fonction s'écrit quoi() avec les parenthèses qui pourront par la suite inclure des variables
>  entre les accolades { } se trouvent les instructions de la fonction, ce qu'elle va faire, (ici elle active la fonction embarquée alert())
>  le tout est encapsulé dans les balises <script> et </script>

Mais n'oubliez pas qu'une fonction n'existe pas par elle-même ! C'est le bouton qui va l'activer :

<input type="button" value="essai" onclick="javascript:quoi()">

Admettez qu'il est bien plus simple d'écrire <onclick="javascript:quoi()"> 10 fois que d'écrire 10 fois la totalité du code de la fonction quoi() !!!
Vous connaissez maintenant les fonctions document.write() et alert() et savez comment les appeler par un event handler !
Les évenements en Javascript représentent les étapes de la vie d'une page HTML, par exemple son chargement, sa fermeture, ou plus simplement les actions de la souris...
Pour une fonction nommée faire() les principaux évenements placés dans leur contexte sont les suivants :
** <body bgcolor="red" onload="faire()">
La fonction faire() est appelée lors du chargement de la page

** <body bgcolor="red" onunload="faire()">
La fonction faire() est appelée lors de la fermeture de la page...

** <img src="votre_image.jpg" onmouseover="faire()">
La fonction faire() est appelée lors du survol de l'image...

** <img src="votre_image.jpg" onmouseout="faire()">
La fonction faire() est appelée lorsque la souris quitte la zone de l'image...

** <input type="button" onclick="faire()">
La fonction faire() est appelée lorsque le bouton est cliqué...

Les bases du C++

Les spécificités de C++

Le langage C++ a adopté un certain nombre de nouvelles spécificités qu’il faut connaître avant de se lancer dans la P.O.O. proprement dite.

Les commentaires

Les commentaires d’un code source peuvent désormais être indiqués de deux façons différentes :

/* Ceci est un commentaire typique venant du C */
int nEntier; // Et ceci est la seconde possibilité

Ces nouveaux commentaires sont utilisables uniquement dans le cas où tout le reste de la ligne est un commentaire.

Déclarations

Les objets de Javascript

A ce stade de notre apprentissage, un peu de théorie ne nous fera pas de mal !
Nous avons vu la fonction document.write() et savons que cette fonction écrit ("write") dans la page web ("document").

Tout ceci pour dire que Javascript est un "langage orienté objet". Késako ?
Cela signifie que avec Javascript vous pouvez influer, modifier ou appeler (on dit adresser) les objets.

Les objets sont des éléments de votre page web que "connaît" Javascript, objets qui respectent une hiérarchie :
--> l'objet WINDOW qui est la fenêtre "générale" de votre page web, parent de
--> l'objet DOCUMENT qui est la page en cours, parent de
--> l'objet FORM (c'est le <form> que vous connaissez), parent de
     --> l'objet TEXTAREA
     --> l'objet BUTTON
     --> l'objet TEXT

Je m'arrête là pour l'instant car les objets sont nombreux ; nous n'avons pas parlé de l'objet navigator, ni de l'objet screen...etc.

Revenons à notre fonction quoi()

<script>
function quoi ()
{
var d="mon_code"
if (document.forme.champ.value==d)
{
alert("Bienvenue chez vous !")
}
else
{
alert ("Votre code est erroné !")
}
}
</script>

 

Il n'y a pas de secret ! Regardez plutôt le code :

<form name="forme">
<input type="text" name="champ">
<input type="button" value="essai" onclick="javascript:quoi()">
</form>

Que déclare la fonction quoi() ? Elle dit que si la valeur de
<input type="text name="champ"> situé dans
<form name="forme"> situé dans
l'objet document c'est-à-dire la page web
est égale à "d" alors on affiche cela, sinon on affiche ceci.

** Il est donc bien important d'adresser les bons objets et de leur affecter un nom (name="") pour que Javascript puisse les identifier (et vous aussi d'ailleurs !).

** dans document.forme.champ, vous avez en fait 1 objet (l'objet text qui s'appelle ici "champ" contenu dans l'objet form qui s'appelle ici "forme" lui-même contenu dans l'objet document).

** dans document.forme.champ.value, nous avons ici ajouté une propriété à cet objet. Un objet peut posséder plusieurs propriétés, c'est-à-dire plusieurs attributs :
- value sert par exemple à évaluer le contenu de l'objet "text"
- length mesure la "longueur" de la chaîne de caractères de l'objet "text"

Exemple :

<script>
function longb()
{
var c=document.formeb.champb.value
if (c.length>=3)
{
alert("Bienvenue chez vous !")
}
else
{
alert ("Votre code est erroné !")
}
}
</script>

Vous voyez ici que nous avons utilisé la propriété "length" pour évaluer la "longueur" de la chaîne de caractère de champb. Tant que la saisie de l'utilisateur ne sera pas égale ou supérieure à 3 caractères, c'est la deuxième fenêtre qui s'affichera ("code erroné").

** Vous aurez noté que le script de la fonction longb() parle de "formeb" et de "champb". En effet, il est préférable pour ne pas dire IMPERATIF lorsque dans la même page vous avez d'une part, plusieurs fonctions ET plusieurs <form> <textarea> ou <text> de les nommer distinctement les uns des autres pour ne pas provoquer des "interférences" entre les fonctions.

** Remarque : nous avons déjà parlé des variables et leur avions jusqu'à maintenant affecté des entiers d=123456, des chaînes de caractères d="comment allez vous ?".

Ici dans la fonction longb() nous avons attribué à c la valeur de document.formeb.champb.value.

Introduction à XML

1.XML

1.1.A quoi sert XML ?

La norme XML (eXtensible Markup Language) permet avant tout de stocker dans un fichier des informations structurées. On parle alors de document XML.
Ce dernier est alors composé de texte libre et de balises (à la manière de ce que vous pouvez connaître avec l'HTML) possédant éventuellement des attributs.
L'utilisation du XML permet entre autre: D'échanger des informations entre diverses applications. De générer des documents (HTML par exemple) ayant différents aspect selon l'utilisateur final. D'exporter et importer vers/de bases de données. etc. Les données sont indépendantes de l'affichage ainsi à partir d'un seul fichier XML, on pourra créer des documents sonores, pour téléphones portables, pour des appareils brailles, et bien sûr des pages HTML.

1.2.Quel est le principe d'XML ?

En HTML, toutes les balises sont définies, elles sont recensées et on s'en sert comme bon nous semble (ex: <b>,<i>...). En XML il n'existe aucune balise prédéfinie, c'est à nous de les définir en mettant l'accent sur la signification de la données, ce n'est qu'ensuite que cela pourra être traduit par un affichage en gras, en bleu, en italique et en Arial à la fois.
En XML, les données sont séparées de l'affichage.
Les fichiers XML sont souvent très simples, voici un exemple de fichier XML:

<?xml version="1.0" encoding="ISO-8859-1"?>

<annuaire>

    <personne>

        <nom>HEUTE</nom>

        <prenom>Thomas</prenom>

        <email>webmaster@xmlfacile.com</email>

    </personne>

    <personne>

        <nom>CANTAT</nom>

        <prenom>Bertrand</prenom>

        <email>noir@desir.fr</email>

    </personne>

</annuaire>

Avec ce fichier, on n'a pas défini comment sera écrit cet annuaire mais on y a déjà mis des informations. Pour l'affichage, on utilisera des fichiers CSS et XSL.

1.3.Ecrire un fichier XML bien-formé

Un document XML bien-formé est un document XML qui respecte certaines rêgles simples.
Il ne doit exister qu'une seule balise racine (le bloc de l'ensemble des balises du document doit être compris entre et ) Toute balise ouverte doit être refermée (a <balise> doit être associé </balise>) Les noms des balises doivent commencer par une lettre ou "_", les autres caractères peuvent être des chiffres, des lettres, "_", "." ou "-". Les noms des balises ne doivent pas commencer par xml Par convention, les balises sont en minuscules.
Quand un élément est vide, les balises peuvent être simplifiées <balise></balise> est identique à <balise/>

1.4.Mon premier document XML

Voici un document XML:

<?xml version="1.0" encoding="ISO-8859-1"?>

<annuaire>

    <personne type="étudiant">

        <nom>HEUTE</nom>

        <prenom>Thomas</prenom>

        <email>webmaster@xmlfacile.com</email>

    </personne>

    <personne type="chanteur">

        <nom>CANTAT</nom>

        <prenom>Bertrand</prenom>

        <email>noir@desir.fr</email>

    </personne>

</annuaire>

Ce document XML est bien-formé, il a une seule racine (annuaire), 2 éléments (personne), 1 attribut associé à <personne> (type) et la balise personne a 3 éléments (nom,prénom,email).

Un fichier XML représente syntaxiquement un arbre, l'arbre correspondant à ce fichier est le suivant: