pluriTAL – BLOG Master pluriTAL [ParisX, ParisIII, INALCO]

ME@SAOULED :D

Posted in Projet 2006-2007 by pluritaluser on 30 novembre 2006

EZZAT, Mani.

Hello everyone.

Alors voilà, si je me réfère strictement au sujet de ce mini-projet, je peux dire que je l’ai fini. Néanmoins, je n’ai pas encore ajouté toutes les optimisations que je voulais, à savoir :

Gestion des liens morts (OK)

C’est assez simple à mettre en place en utilisant une certaine variable d’environnement intégré dans Perl.

Afficher un tableau de 20 lignes maximum, passer sur une autre page après, en prenant soin de mettre des links sur la page précedente et suivante (OK)

Ca a l’air simple comme ca, mais croyez-moi, c’est probablement l’option la plus difficile à implémenter niveau code, car cette mini option va impliquer de nombreuses structures conditionnelles imbriquées et si cela reste lisible, ce n’est pas abordable par le premier venu. Oubliez pas que la premiere page n’a qu’un seul lien vers la suivante, la derniere page n’a qu’un seul lien vers la précédente, et tout les pages entre ont deux liens pointant vers la suivante et la précédente. Si vous traitez les « else » quand il faut les traiter, en considérant que ces structures conditionnelles imbriquées, sont elle même comprises dans des boucles imbriquées, on s’en sort plus.

Petit tips pour vous aider : Vous pouvez rester à deux variables en utilisant la condition (pour 20 lignes dans un tableau) « if($i%20==0) etc… ». J’avais déja rencontré un problème similaire auparavant, donc ici, j’ai immédiatement pensé à l’utilisation du modulo, qui indique LE RESTE d’une division. Donc si on se base sur des tableaux de 20 lignes, il suffit de vérifier que votre compteur est divisible par 20 (ou que son reste soit égal à 0 en d’autres termes). Si vous passez par une troisième variable pour la comparaison, en considérant la structure du code (les conditions, les boucles), vous allez droit en enfer. Car incrémenter ou décrémenter au bon endroit est vital ici.

-gestion des redirections, des pages non-html (NON-OK)

GET marche pas, wget non plus, on a tesé ça tout à l’heure. D’apres Mr Fleury, il y aurai peut-etre un nouveau browser en ligne de commande style Lynx qui permettrait d’arriver à nos fins.

-portabilité totale du code (NON-OK)

A l’heure actuel, mon code est portable sur toutes les machines, à condition de respecter l’arbo du projet, et que le répertoire courant soit programmes/ lorsque vous appelez le script. Il est possible de rendre le projet portable à toutes les machines ET qu’on puisse l’appeller de n’importe où dans l’arborescence de n’importe quelle bécane, mais cela implique d’utiliser la variable d’environnement $0 (implémentée dans bash comme dans perl), de se battre avec une regexp afin de pouvoir récupérer le chemin à partir duquel vous avez call le script, et d’agir en fonction dans les différents path de votre code. (désolé Rachid, j’ai oublié la regexp que tu m’avais si gentiment expliqué, je te resoaulerai pour l’avoir :D)

Un peu lourd en somme. Suffit d’avertir l’utilisateur de bien vérifier d’être au bon endroit:/

– Design (NON-OK)

j’avais commencé à étoffer le tableau esthétiquement, genre mettre une jolie bannière que j’aurai au préalable réalisée sous PHOTOSHOP (c’est toujours bon photoshop pour les design de site, avec son systeme de layout/calque), mais je me suis aperçu que si je devais modifier un truc dans mon script, ca allait foutre tout mon design par terre. Normal me direz-vous, étant donné qu’on gere la création du site en HTML par une boucle, et qu’il est impossible de revenir en arrière dans une boucle…

pas tout à fait impossible en fait en perl (attention, je ne fais pas de propagande pour perl, au contraire même, j’ai justement trouvé un énorme défaut là). Perl permet de sortir d’une boucle et de revenir derriere dans le code, grâce au system des LABEL. Ceux qui ont déjà fait de l’assembleur, c’est exactement la même chose. Vous allez définir un bloque avec un LABEL et y revenir quand vous voulez avec un GOTO. Perl permet une chose similaire, mais le problème c’est que comme en assembleur, cela va TRES vite devenir complètement incomprhénsible pour le commun des mortels. C’est pour cette raison que beaucoup de gens dénigrent Perl, car les scripts deviennent très vite illisibles.

En ce qui concerne les fonts et autre, cela reste possible et facile à réaliser, sans pour autant toucher à la maléabilité du code. C’est encore plus simple en ce qui concerne les regexp, puisqu’en perl vous pouvez stocker les occurences et leur contextes dans des variables…

DIVERS (OK?)

J’ai ajouté d’autres options utiles, comme par exemple le fait de gérer les erreurs lors de la saisie du fichier dans lequel se trouve la liste d’url. Si on tappe un fichier qui existe pas, mon script s’arretera après avoir afficher un truc du genre « fichier introuvable ». Ce n’est pas un billet gagnant pour l’Euromillion certes, mais c’est toujours ça de fait. En perl c’est simple a faire, et ça se résume en 1 demi-ligne.

Voili Voilou, je vais c/p mon code derriere si ça interesse qqn, je le considère « propre », mais il reste difficile d’accès à la lecture, même avec des commentaires.


#!/usr/bin/perl
$i=0;
$j=0;
print « File le nom du fichier url qui se trouve dans le folder LISTES-URL! \n »;
$url=<STDIN>;
print « $url »;
chomp($url);
open(LECTURE, « ../LISTES-URL/$url ») or die »impossible de trouver $url!! `\n »;
print « File le nom du file SANS EXTENSION pour le tableau en html qui sera saved dans le folder programmes/ ffs! \n »;
$my_tab=<STDIN>;
print « $my_tab »;
chomp($my_tab);
open(ECRITURE, « >$my_tab$j.html »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
while($ligne=<LECTURE>)
{
print $ligne;
chomp($ligne);
print ECRITURE « <tr><td><a href=\ »$ligne\ »>URL$i</a></td> »;
$wgett= »wget -O ../PAGES-ASPIREES/toto$i.html $ligne »;
system($wgett);
if($?==0)
{
print ECRITURE « <td><a href= \ »../PAGES-ASPIREES/toto$i.html\ »>FILE$i</a></td> »;
$lynx= »lynx -dump ../PAGES-ASPIREES/toto$i.html > ../DUMP-TEXT/toto$i.txt »;
system($lynx);
print ECRITURE « <td><a href= \ »../DUMP-TEXT/toto$i.txt\ »>TEXT$i</a></td> »;
$contextfile= »../DUMP-TEXT/toto$i.txt »;
open(CONTEXTE, « $contextfile »);
$i++;
while($lignetxt=<CONTEXTE>)
{
if($lignetxt =~ /barrage/i)
{
$avant = $`;
$apres = $’;
$barrage = $&;
print ECRITURE « <td><i>…$avant<b>$barrage</b>$apres…</i></td></tr> »;
if($i%20==0 || eof(LECTURE))
{
if($j==0)
{
$j++;
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>next</a></align></table></body></html> »;
close(ECRITURE);
open(ECRITURE, « >$my_tab$j.html »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
}
else
{
$j–;
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>prec</a></align> »;
$j++;
$j++;
if(<LECTURE>)
{
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>…next</a></align> »;
close(ECRITURE);
open(ECRITURE, « >$my_tab$j.html »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
}

}

}
last;
}

}
}
else
{
close(CONTEXTE);
print ECRITURE « <td>PROBLEME</td> »;
print ECRITURE « <td>PROBLEME</td> »;
print ECRITURE « <td>PROBLEME</td></tr> »;
if($i%20==0 || eof(LECTURE))
{
if($j==0)
{
$j++;
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>next</a></align></table></body></html> »;
close(ECRITURE);
open(ECRITURE, « >$my_tab$j.html »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
}
else
{
$j–;
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>prec</a></align> »;
$j++;
$j++;
if(<LECTURE>)
{
print ECRITURE « <align=\ »center\ »><a href=\ »$my_tab$j.html\ »>…next</a></align> »;
close(ECRITURE);
open(ECRITURE, « >$my_tab$j.html »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
}

}

}
$i++;
}
}

print ECRITURE « \n</table>\n</body>\n</html> »;
close(LECTURE);
close(ECRITURE);

Cela devient plus gros deja:/ et ce, en ayant ajouté seulement 2, 3 trucs:/

Have fun ceux qui vont essayé de le lire:/

Publicités

ME@HOME

Posted in Projet 2006-2007 by pluritaluser on 26 novembre 2006

EZZAT, Mani.

Bonjour à tous.

J’ai décidé de réaliser le projet en perl car finalement, d’une part le bash ressemble énormément au tcsh que j’ai déjà pratiqué, et d’autre part je suis complètement vierge en ce qui concerne Perl et c’est un bon moyen de m’y mettre. Lors des séances du jeudi, il ne nous restait plus qu’à copy/paste ce qui était écrit sur le tableau pour finir le projet, ce qui ne m’ammène pas tellement de satisfaction personnelle (évidemment, sans connotation négative sur les autres personnes bien entendu).

Je pense également que cela serait plus instructif de mettre en exergue les problèmes que nous pouvons rencontrer, plutôt que de vômir un code obscur qui fonctionne. En gros, je vais tenter de montrer ce qu’il ne faut pas faire (comment ça tout le monde s’en fou ?! :/)

Première remarque : Perl est facile d’accès, très puissant, et proche du C. Il suffit d’être un poil autodidacte et ça passe tout seul. Merci à Mr Fleury de m’avoir fourni ses cours. Je pense que tout le monde y trouvera son comptes dans ces dits cours (je les ai sur ma clé USB si il y a des interessés, pas trop envi de les mettre en ligne sans permission au préalable:/)

J’ai rapidement codé un script qui s’arrete à la 3eme colonne du tableau, c’est a dire aux pages lynxées. Perl comprend des outils extremement puissant concernant les regexp, surpassant de loin ce que grep peut nous fournir. J’y reviendrai donc plus tard.

Le script en question n’a pas de boucle imbriquée. Il va regarder la premiere url du fichier-liste (ligne par ligne), mettre le lien, wget ce lien, le lynxé, tout en écrivant le code html qui va bien pour notre tableau final, et recommencer pour la ligne suivante.

Une seule boucle est alors nécessaire.

Voici un exemple de code en perl, volontairement crados 😀 et examinons les problèmes que l’on peut rencontrer :


#!/usr/bin/perl
print « File le nom du fichier url AVEC LE PATH! \n »;
$url=<STDIN>;
print « $url »;
chomp($url);
print « File le nom du file pour le tableau en html! \n »;
$my_tab=<STDIN>;
print « $my_tab »;
chomp($my_tab);
open(LECTURE, « $url »);
open(ECRITURE, « >$my_tab »);
print ECRITURE « <html>\n<head>\n<title>tableau de liens</title>\n</head><body>\n<table border=\ »1\ »>\n » ;
$i=1;
while($ligne=<LECTURE>) #ma seule boucle
{
print $ligne;
chomp($ligne);
print ECRITURE « <tr><td><a href=\ »$ligne\ »>URL$i</a></td> »;
$wgett= »wget -O ../PAGES-ASPIREES/toto$i.html $ligne »;
system($wgett);
print ECRITURE « <td><a href= \ »
file:///E:/cygwin/home/Lalooz/plurital/projet/PROJET-MASTER/PAGES-ASPIREES/toto$i.html\ »>FILE$i</a></td> »;
$lynx= »lynx -dump ../PAGES-ASPIREES/toto$i.html > ../DUMP-TEXT/toto$i.txt »;
system($lynx);
print ECRITURE « <td><a href= \ »
file:///E:/cygwin/home/Lalooz/plurital/projet/PROJET-MASTER/DUMP-TEXT/toto$i.txt\ »>TEXT$i</a></td></tr> »;
$i++;
}
print ECRITURE « \n</table>\n</body>\n</html> »;
close(LECTURE);
close(ECRITURE);

Un peu dégueulasse, je vous l’accorde.

Premièrement, le problème de la portabilité du code s’impose. Lorsqu’on regarde les PATH, on s’aperçoit tout de suite que ce script ne fonctionnera QUE CHEZ MOI SUR MA MACHINE. Si je veux l’exporter ça coincera. En considérant l’arbo de notre projet, il faudra s’interesser aux chemins absolus/relatifs, pour ceux qui regarderont leur tableau avec un browser windows par exemple (bah ouais, on utilise cygwin, rien n’empeche d’utiliser un brower windows pour afficher notre tableau)

./ .. voir meme le pwd (affiche le chemin dans lequel on est) peut s’avérer fort utile.

Deuxièmement, que se passe-t-il si un des sites a fermé entre temps ? ou leur serveurs sont en pannes? wget ne pourra rien d/l, lynx -dump ne transfomera rien, pire encore, lynx ne trouvera pas le ficher à transformer car wget n’a rien aspiré. Ce qui affichera surement des erreurs sur la console. Votre tableau se constituera quand même ceci dit:/

La solution paraît simple. Il suffit de rajouter une itération qui stipule : « si wget réussit, tu continues ton bordel, si il réussit pas, tu vas m’afficher -lien mort- ou autre sur mon tableau »

Avec Ivan, nous discutions d’une premiere solution un peu compliquée mais qui devrait marcher :

utiliser le fichier log de wget (-o il me semble), regarder dans ce fichier log, et voir si pour chaque fichier, on trouve un « file saved » quelque part. Si on le trouve, c’est que wget a reussi a aspiré le site, et le script peut continuer a faire son tableau. Si on le trouve pas, wget n’a pas réussi, et le script devra réagir en fonction (mettre « lien mort », changer de couleur ou n’importe quoi d’autre)

Une autre solution plus simple et « propre » (cad deja sans creer de fichier log tout dégueulasse sur le dur):

utiliser les variables d’environnement. Quezako ?

Un exemple simple, vous voulez savoir l’heure. Et bien votre OS comprend tout un tas de variables, dont l’heure qu’il est, auxquels vous pouvez accedez facilement.

Pour les voir, tappez sur votre console env et elles s’afficheront.

Ce qui m’interesse ici, c’est la variable $?. Lorsque j’appelle un programme, si le programme ne rencontre pas de problème, il retournera 0 dans cette variable, sinon il retournera un autre nombre.

Il suffit alors dans votre script apres votre wget, de voir si $? = 0 ou autre chose et voilà !

Mais tout n’est pas si rose, car env ne contient aucune variable s’appellant ?:/ En fait perl a déjà des variables « d’environnement »définies pour les gesitions d’erreurs dont $?, $@, $!. et je peux y acceder directement dans le script. (Cela m’a posé problèmes, j’ai cherché pendant longtemps dans env sans jamais rien trouver:/)

NB: je fonctionne d’une manière binaire ici. A savoir « 0 ou autre chose » seulement. Le man de wget ne dit pas ce que wget renvoie dans $? selon le type d’erreurs. Il peut y en avoir plusieurs, comme par exemple ne pas pouvoir se connecter au domaine, ou ne pas trouver le fichier etc… Il faudrait tester pour chaque cas ce que renvoie wget, mais j’ai la flemme:D. Donc je reste dans la logique « ca fonctionne ou ca fonctionne pas » sans m’interesser au « pourquoi ca fonctionne pas ».

En bash, vous pouvez accéder à ces variables facilement et intuitivement, comme sous la console. En revanche en Perl, c’est un peu plus différent. Perl crée de base un tableau associatif (pensez un tableau de char * en C par exemple, si vous savez ce qu’est un pointeur) qui permet d’acceder aux variables d’environnement sous la forme $env{ PATH} pour la variable des PATH par exemple.

Tout le reste va encore concerner la gestion d’erreur et l’optimisation.

Avec Nicolas, on discutait de faire un tableau de 20 lignes maximum, et d’ajouter des liens page1 page 2 etc… pour la suite. Car si on a 50 urls a mettre dans un tableau, ca va. Si vous en avez 1000, ca fait un peu lourd:/ La solution reste simple ceci dit. Lorsque vos compteurs boucle atteignent 20, vous passez sur une autre page (un autre fichier donc). C’est basique mais c’est un grand pas en avant pour la lisibilité.

Autre problemes, les sites en php (ou autre cgi et consorts)

Si votre lien n’est pas en html, il y a de fortes chances que vous ne récupériez qu’un script bidon, sans aucune information relative à barrage. Comment régler ce problème? Simple, en utilisant GET http:// au lieu de wget. Par ce biais, vous récupererez ce qui est AFFICHE sur votre browser (donc ce qui nous interesse) et non pas le fichier cible de wget avec les scripts php par exemple. Il suffira de faire encore une itération qui va regarder l’extension de votre fichier et qui agira en fonction. Mais cela implique de pouvoir trier les fichiers html php et autres:/ et donc de faire appel aux regexp. ATTENTION, c’est plus compliqué que cela paraît. Car un script php peut etre sous forme domaine.com/script.php, ou alors le lien peut contenir des valeurs correspondantes à la base SQL par exemple, ou encore les différents « case » d’un fichier php (quand c’est codé un peu cochon) et ce n’est donc pas forcément facile de repérer ce genre de chose automatiquement via regexp.

Pour ce qui est des redirections, je ne trouve pas de solutions malheureusement:/

Ni même pour tous les sites php sur base sql, dans lesquels vous devez vous identifier pour avoir accès au content. Les options user password de wget ne fonctionnent que sur les log/pass style corpus le monde. Un simple forum de discussion, pour la majorité d’entre eux (95% peut-être?) utilisent le format php sur BDD mySQL.

Il serait aussi interessant de pouvoir pomper ce qu’on trouve sur newsgroup (en passant par des servers de type news.domaine.truc). Je suis persuadé que c’est possible, je lisais des ng avec emacs, mais je ne sais pas trop comment on pourrait l’automatiser. Il doit sûrment exister un outil quelque part permettant de le faire :/ Je sais bien que maintenant c’est un repère de warez et de binaires, plutot que de textes, mais des « vieux de la veille » doivent encore utiliser ce machin.

… to be continued (comment ça « non c’est pas la peine?!! » T_T )

ML-PED01-23.11.06

Posted in Projet 2006-2007 by pluritaluser on 23 novembre 2006

Objectif de la séance:

enrichir le script d’une nouvelle colonne contenant les contextes du mot ‘barrage’ extraits avec la commande egrep.

Ma binôme Marianna a maîtrisé le HTML très rapidement!(grâce à son intelligence remarquable!) (elle a fait une S ;] )

Et maintenant, nous avons quasiment terminé la génération des tableaux d’URLs en modifiant la structure du tableau dans le script!!

La semaine prochaine, on se donne rendez-vous pour la finalisation du site final du projet 🙂 et aussi pour demander aux profs de nous aider à résoudre quelques petits soucis dans les tableaux en sortie.

Bon travail à tous!

M&M’s

Merci Arianna et Christian!

Posted in Projet 2006-2007 by pluritaluser on 23 novembre 2006

Comme romis, voilà la ligne de commande pour afficher en couleur le mot filtré:

sed ‘s/barrage/\<font color=\ »blue\ »\>barrage\<\/font\>/g’

qu’il faut empiler avec ‘|’ à la ligne de commande egrep!

mon mail au cas ce n’est pas clair : marguerite.leenhardt@laposte.net
Encore merci pour la bonne idée 😉

Marguerite

Ressources pour préparer le rapport

Posted in Projet 2006-2007 by tal-p3 on 22 novembre 2006

un modèle de site (vide) pour le rapport final. On regardera aussi sur ce site : [1] Apprendre le langage HTML (« site réservé aux débutants ») et ici : [2] Maîtrisez le langage HTML (« cours pour niveau avancé en HTML »)

PED13-ML-séance 16.11.06

Posted in Projet 2006-2007 by pluritaluser on 22 novembre 2006

Bonjour à tous,

cette séance a été majoritairement consacrée à des points de rappel sur ce qui a été vu jusqu’ici (rappels sur les commandes Unix, les arborescences Unix, etc…).

Un second aspect abordé est relatif la mise en place de la présentation HTML finale du projet à rendre.

Pour ma part, j’ai commencé à m’intéresser à la structuration du site, à savoir:

– comment gérer les frames HTML

– comment appliquer une feuille de style à une page HTML

Je n’avais jamais été confrontée à ces aspects en HTML, cela m’a donc pris un certain temps pour arriver à un résultat sympa, i.e. un peu plus que les 3 heures de la séance! Enfin, c’est toujours ça de fait!

Comme nous avons la possibilité de nous organiser en binôme pour ce projet Barrage, nous nous sommes réparties le travail en fonction de nos compétences respectives. Ma binôme n’ayant jamais monté de page HTML, nous avons convenu que je prenais en charge la structure du site (comme je l’ai dit plus haut), dans la mesure où mettre en place ses propres résultats d’exercices constitue une bonne initiation pour elle au langage HTML.

A jeudi prochain, pour arriver à l’étape finale de traitement des URLs : la récupération des contextes avec egrep!

Bon travail à tous!

Marguerite

PED13-ML-séance 09.11.06

Posted in Projet 2006-2007 by pluritaluser on 9 novembre 2006

Bonjour à tous!

> on est dans l’étape de traitement des URLs; on a déjà vu la commande wget

> aujourd’hui, on va voir l’outil lynx et l’outil egrep

  • lynx

C’est un navigateur en ligne de commandes.

Jetons un oeil au man de lynx, et en particulier à l’option -dump de cette commande :

LYNX(1)                                                   LYNX(1)

NAME
       lynx  -  a general purpose distributed information browser
       for the World Wide Web

SYNOPSIS
       lynx [options] [path or URL]

       use "lynx -help" to display a  complete  list  of  current
       options.

DESCRIPTION
       Lynx  is  a fully-featured World Wide Web (WWW) client for
       users running cursor-addressable,  character-cell  display
       devices (e.g., vt100 terminals, vt100 emulators running on
       Windows 95/NT or Macintoshes, or  any  other  "curses-ori-
       ented"  display).   It  will display hypertext markup lan-
       guage (HTML) documents containing links to files  residing
       on  the  local system, as well as files residing on remote
       systems running Gopher, HTTP, FTP, WAIS, and NNTP servers.
       Current  versions of Lynx run on Unix, VMS, Windows 95/NT,
       386DOS and OS/2 EMX.

       Lynx can be used to access information on the  World  Wide
       Web,  or  to  build information systems intended primarily
       for local access.  For example,  Lynx  has  been  used  to
       build  several Campus Wide Information Systems (CWIS).  In
       addition, Lynx can  be  used  to  build  systems  isolated
       within a single LAN.

OPTIONS
       At  start  up, Lynx will load any local file or remote URL
       specified at the command line.  For help with URLs,  press
       "?"   or  "H"  while  running  Lynx.  Then follow the link
       titled, "Help on URLs."

       Lynx uses only long option names. Option names  can  begin
       with  double  dash  as well, underscores and dashes can be
       intermixed in option names (in the reference below options
       are with one dash before them and with underscores).

 

> l’option lynx -dump URL : permet de récupérer le texte d’une URL

 

      -dump  dumps the formatted output of the default  document
              or  one  specified  on the command line to standard
              output.  This can be used in the following way:

              lynx -dump http://www.trill-home.com/lynx.html

Problème : cette commande affiche à l’écran l’ensemble des données récupérées (le texte de l’URL).

Il faut insérer une redirection de flux (>) pour que ça soit plus lisible. En principe on doit obtenir le texte sans les balises.

Il faudra intégrer ce mécanisme (lynx -dump URL > fichier-redirige.txt) dans le script mis à disposition par les enseignants.

 

En fait, c’est le même mécanisme que enregistrer sous une page web à partir d’un navigateur comme Firefox.

 

  • egrep

La commande egrep est un outil UNIX qui permet de faire du filtrage de motifs. A l’aide de cette commande, on peut extraire d’un fichier texte toutes les lignes qui contiennent la châine de caractères (le motif) spécifié.

 

Syntaxe : egrep [motif] [fichier]

 

Pour représenter de manière générique les chaînes de caractères, on utilise les expressions régulières, qui permettent donc de filtrer la chaîne recherchée.

Pour ce faire, il faut utiliser les opérateurs d’expressions régulières, qui ont une sémantique particulière:

    • .‘ : n’importe quel caractère sauf le point

    • *‘ : on peut avoir le caractère autant de fois qu’on veut (de 0 à n fois)

    • []‘ : permet de spécifier qu’on veut un seul des deux caractères spécifié dans l’ensemble, i.e. entre crochets

    • ?‘ : le point d’interrogation est un opérateur d’optionnalité qui porte sur le caractère qui le précède, et qui indique qu’on peut avoir ce caractère dans le motif O ou 1 fois

    • +‘ : comme le ?, cet opérateur porte sur le caractère qui le précède et indique qu’on peut l’avoir au moins une fois dans le motif

    • {3, }‘ : précise qu’on veut au moins 3 occurrences du motif qui précède, et au plus autant d’occurrences que possible; si on avait eu {3, 5}, on aurait recherché au moins 3 occurrences, au plus 5, du motif recherché

    • ( )‘: le fait de parenthéser une partie du motif permet de limiter la portée d’un opérateur, i.e. appliquer un opérateur sur le contenu de la parenthèse

    • |‘ : le pipe permet de signifier qu’on veut filtrer soit ce qui est à gauche soit ce qui est à droite du pipe; par exemple ‘clé|clef‘ signifie qu’on veut filter soit ‘clé‘ soit ‘clef‘. Attention, ici, le pipe est un opérateur d’expression régulières, ce n’est pas le pipe d’empilement de commandes!

  • exemple : egrep  » .*isme » mots.txt = on obtient tout les mots finissant par ‘-isme’ contenus dans le fichier mots.txt

ATTENTION > * > | : règle de précédence (concaténation > étoile > optionnalité) qui spécifie un ordre de lecture dans les expressions régulières

    • \‘: c’est l’opérateur de déspécialisation, qui, appliqué aux autres opérateurs d’expressions régulières, permet de les prendre en compte dans le motif en tant que caractère et non pas en tant qu’opérateurs; autrement dit, \ permet de ne pas interpréter les opérateurs si jamais les caractères des opérateurs figurent dans un motif d’expression régulière

    • $‘ : fin de ligne

    • ^‘ : début de ligne

    • [^a-z]‘ : on recherche toutes les suites de caractères sauf celles qui suivent (i.e. celles en minuscules); le chapeau a donc une valeur différente en fonction de son contexte

    • \b‘ : permet de rechercher le début ou la fin d’une chaîne de carcatère comprise entre deux blancs (i.e. permet de spécifier le début ou la fin d’un mot)

 

Voyons quelques options de la commande egrep :

    • l’option egrep -v permet de filtrer toutes les lignes qui ne contiennent pas le motif spécifié

On peut combiner egrep avec d’autres commandes, par exemple wc -l, qui permet de compter les lignes : on peut empiler les commandes avec l’opérateur ‘|‘.

Si on empile egrep [motif] [fichier] | wc -l , on obtient le nombre de lignes qui contiennent le motif spécifié à extraire du fichier.

 

    • -i : on recherche le motif qu’il sans contrainte sur la casse

 

Exemple : egrep -v  »^$ » mots.txt permet de filter les lignes vides du fichier

 

Faire un man egrep donnera des informations plus précises.

Pour davantage d’exemples pratiques avec les expressions régulières, je vous invite à consulter la page suivante :

http://www.cavi.univ-paris3.fr/ilpga/ilpga/tal/sitespp/L5T51-2005-2006
/KristinIRSIG-MargueriteLEENHARDT/TAL.htm

où sont présentés un ensemble d’exercices de prise en main des opérateurs d’expressions régulières, entre autres.

Travail à faire pour le projet barrage

 

Il faut maintenant modifier le script pour obtenir, dans le tableau:

Voilà pour la sénace d’aujourd’hui!

A bientôt pour les étapes ultérieures!

Marguerite

« Barrage » sur le Web

Posted in Projet 2006-2007 by pluritaluser on 9 novembre 2006

Marianne MICHIELS, email: marianne_younes@hotmail.com

Bonjour,

Commençons par le commencement…

Mon point de départ était la lecture du dossier de l’Entreprise intitulé « Recherches sur Internet, il n’y a pas que google dans la vie ». Voici quelques points essentiels que j’ai retenue:

  • Saisir les mots-clés primaires + les mots-clés secondaires – les mots à exclure
  • Interroger les bases de données des moteurs car ils ne recensent qu’une partie du web.
  • Se connetcter aux sites portails, exemple: Enfin.fr.
  • Ni Google, le plus connu parmi les moteurs de recherche, ni ses concurrents ne couvrent l’ensemble des données disponibles sur le web.

1. Recherche du mot « Barrage » sur le web et récupération des pages « pertinentes »:

Par manque d’expérience, la récupération sera faite à la main.

A. La recherche du mot « Barrage » via GOOGLE :

>> « Un barrage hydraulique » :

>> « Un barrage de police » :

>> « Faire barrage à quelqu’un » :

=> Le copier/coller des URLs une par une n’est pas du tout amusant. Vivement que j’utilise wget. Le contenu de mes pages est enregistré dans le fichier « PAGES ASPIREES » de mon arborescence tandis qu mes URLs se trouvent dans le fichier « LISTES URL »

Bonjour ou plutôt Bonsoir

Posted in Projet 2006-2007 by pluritaluser on 9 novembre 2006

Comme je n’ai pas pu être présente aux premiers cours de « Programmation et projet encadré » pour des raisons professionnelles, j’ai malheureusement râté les introductions. Je suis restée un long moment avant de trouver le moyen de me connecter et de rédiger cet article. Finalement, j’y suis arrivée … j’éspère que je n’ai pas fait d’erreur. En attendant la réponse du(des) professeur(s), je rédige mon premier billet:

MICHIELS Marianne

Diplôme préparé: Master Pro TIM

Formations suivies (2002-2005):

  • Licence LEA, anglais-arabe, option: affaires & commerce international-Sorbonne III
  • 2ème année de DEUG Biologie
  • 1ère année de médecine

Informatique: Microsoft office, Internet…. Niveau débutant pour l’instant 😉

Cordialement,

Marianne

ped14-IS : BARRAGE – script pour le cours du 9/11/06

Posted in Projet 2006-2007 by pluritaluser on 9 novembre 2006

Ce que le script doit faire :

  1. aspirer les pages Web (sur les quels pointent les URLs stockés dans les fichiers textes dont nous disposons déjà dans un répertoire) dans des répertoires locaux de sorte qu’il existe pour chaque fichier d’URL (= pour chaque usage) un répertoire avec les pages aspirées correspondantes >> commande wget.
  2. extraire un fichier texte brut (débalisé qui ne contiendrait pas de balisage HTML) à partir de chaque page aspirée >> commande lynx -dump.
  3. donner un joli tableau html qui contiendrait les liens vers les pages web (publiées donc sur le réseau Internet), vers les pages aspirées (stockées donc localement sur nos machines) et vers les fichiers contenant du texte débalisé (pareil, stockées sur nos machines) >> sortie du script dans un fichier interprétable comme du HTML

Comment il va le faire

L’utilisateur saisit trois valeurs : le nom du répertoire contenant les fichiers avec les URLs, le nom du répertoire où seront stockés (1) les sous-répertoires avec les pages wgetées (un répertoire par usage) contenant chacun à son tour un répertoire avec les fichiers lynx-o-dumpées et (2) le fichier html avec le tableau.
Le script va créer un seul tableau pour tous les usages. Pour cela, j’ai utilisé deux boucles for x in y { … } : (1) celle qui liste le répertoire contenant les fichiers, qui crée les sous-répertoires pour chaque usage et qui inscrit dans le tableau une ligne d’entête correspondante à chaque usage et (2) celle (qui est embriquée dans la première) qui lit les fichiers, exécute les commandes wget et dump, qui inregistre les fichiers sortie là où il faut et qui fait pour chaque enregistrement une ligne avec des liens.

Pour donner le nom aux répertoires d’usage et pour nommer les fichiers wgetés et lynx-o-dumpé, j’ai utilisé un compteur avec la syntaxe: compt=$[$compt + 1] Cela marche, mais est-ce la meilleure façon de faire un compteur dans la programmation shell?

Et voici le code


#######################################################################
#!/bin/bash

##########################SAISIE DES VALEURS PAR L’UTILISATEUR #################

echo "***Donnez le nom du repertoire contenant les listes des URL : »;
read rep;
echo « ***Donnez le nom du repertoire pour le resultat : »;
read nr;
mkdir $nr;
echo « ***Donnez le nom pour le fichier avec le tableau : »;
read nf;

reporg=`pwd`; cd $rep ; cheminURL=`pwd` ; cd $reporg/$nr ;

#################################ENTETE de la page HTML#######################
echo « <html><head><title>TABLEAU DE LIENS : $nf</title><meta charset=\ »UTF-8\ »></meta></head><body><font face=\ »Arial\ »/><h2><font color=\ »peru\ »>$nf</font></h2><hr></hr><i>généré à partir du répértoire :</i> <b>$cheminURL</b><br/> <i>contenant les fichiers : </i> <b>|  » >>$nf.html;

for file in `ls $cheminURL` #enumérer les fichier d’URL traités
{
echo « $file | » >>$nf.html;
}
echo « </b><br/><br/> » >>$nf.html;

#################### LE TABLEAU COMMENCE ICI ##################################
####faire l’entête de la table

echo « <table border=\ »3\ »><tr bgcolor=\ »peru\ »><th>URL</th><th> PAGE ASPIREE </th><th> DUMP LYNX </th><th> CONTEXTE </th></tr> » >>$nf.html;

######première boucle pour le traitement des fichiers d’entrée

for file in `ls $cheminURL`

{
numREP=$[$numREP + 1] ; #compteur pour le numéro de répertoire = dd’usage
mkdir usage$numREP ; #créer le répertoire pour les pages aspirées

echo « <tr><td colspan=\ »4\ » align=\ »center\ » bgcolor=\ »papayawhip\ »><i>répertoire </i>: <b>usage$numREP</b> <i>fichier source </i>: <b>$file</b></td></tr> » >>$nf.html;

cd usage$numREP ;
mkdir DUMP;

######boucle imbriquée pour le traitement des URL: wget, lynx et les inscriptions dans le tableau###
for url in `cat $cheminURL/$file`
{
numURL=$[$numURL + 1]; #compteur pour le numéro d’enregistrement : c-à-d la page web avec le fichier aspirée et le fichier dumpé
wget –tries=1 -O pagASP$numURL.html $url;
lynx -dump $url >DUMP/pagDUMP$numURL.txt;

echo « <tr align=\ »center\ »><td><a href=\ »$url\ » target=\ »_blank\ » title=\ »$url\ »>page WWW n°$numURL</a></td><td><a href=\ »./usage$numREP/pagASP$numURL.html\ » target=\ »_blank\ »>pagASP$numURL.html</a></td><td><a href=\ »./usage$numREP/DUMP/pagDUMP$numURL.txt\ » target=\ »_blank\ »>pagDUMP$numURL.txt</a></td><td>CONTEXTE la prochaine fois</td></tr> » >>../$nf.html;
}

######fin de la boucle imbriquée#################################################
cd ..;
}

echo « </table></body></html> » >> $nf.html;

############################################FIN#########################

… j’ai mis quelques commentaires, les variables sont en gras, mais je suis d’accord que cela reste plutôt illisible. Regardez ce que cela fait … MAIS ATTENTION, quand je fais copier-coler des scripts publiés sur le blog vers un fichier en local cela fait des choses bizarres avec les signes  » (double quôte) et Cygwin a du mal à le lire… Avez vous le même problème?

A demain

Ivan Šmilauer

AB : Amélioration du script fait-tableau-v1.sh

Posted in Projet 2006-2007 by pluritaluser on 8 novembre 2006

Je vais maintenant créer un tableau en format html, contenant les listes d’URL.

A partir du petit programme fait-tableau-v1.sh fourni par les professeurs, je cherche à améliorer le script des façons suivantes :

1) création de liens « cliquables » vers les pages Web correspondantes à mes URL :

j’utilise la balise <A href=www.page_web.html>…</A> :

<A href= »$nom »>$nom</A>

 

2) séparation de la colonne contenant les URL et de celle contenant les liens aux pages Web correspondantes :

j’introduis la balise de lien après la balise de la première colonne :

<tr><td>$nom</td><td><A href= »$nom »>$nom</A></td></tr>

et je donne un titre à chaque colonne par le biais de la balise TH, juste après le code de début de tableau :

<table border=1><TH>Liste URL</TH><TH>Liens vers la page WEB</TH>

(Le script ainsi modifié s’appelle MY_fait_tableau1.sh)

3) possibilité de créer et enchaîner automatiquement plusieurs tableaux relatifs à différents fichiers .txt contenant chacun une liste d’URL où apparaît un des sens du mot barrage :

Pour l’instant je ne sais travailler que sur un nombre limité de fichiers (deux,

dans ce cas). Je fais suivre la commande de lecture de 2 noms de variables :

read fic1 fic2

et j’écris deux blocs d’instructions semblables, un pour $fic1 et une pour $fic2.

NB : attention à ne par répéter deux fois le code de fin de fichier </html> et à mettre toujours deux signes >> devant $tablo quand on modifie ce fichier, sinon le premier tableau sera écrase par le deuxième.

4) affichage, avant chaque tableau, d’un titre explicitant le sens du mot barrage concerné:

J’utilise la balise de grande taille h2 avec attribut de centrage et la balise de mise en gras strong:

<h2 align=center><strong>Barrage_$fic1</strong></h2>

5) création d’une troisième colonne contenant les liens aux pages aspirées (avec wget).

Problème : comment utiliser, dans la même boucle, deux variables provenant de deux fichiers différents ? Faut-il modifier le résultat de la boucle après son exécution pour insérer une troisième colonne ? Je ne trouve pas de solution pour l’instant.

 

Mon nouveau script amélioré s’appelle MY_fait_tableau2.sh. Voici le texte complet :

#!/bin/bash

echo « donne les noms de fichier contenant les liens http »; #ce sont les listes des pages wgettées

read fic1 fic2; #le programme connait les fichiers de liens sous les noms $fic1 et $fic2

echo « donne nom de fichier html où stocker ces liens »; #c’est le tableau de liens à créer

read tablo; #enregistre nom donné par utilisateur dans la variable $tablo

echo « <html><head><title>tableau de liens</title></head><body><h2 align=center><strong>Barrage_$fic1</strong></h2><table border=1><TH>Liste URL</TH><TH>Liens vers la page WEB</TH> » > $tablo; #code de début de tableau

for nom in `cat $fic1` #$nom est la variable dans laquelle sera stocké chaque lien

{

echo « <tr><td>$nom</td><td><A href= »$nom »>$nom</A></td></tr> » >> $tablo; #création d’un tableau à deux colonnes et autant de lignes qu’il y a d’URL avec lien vers la page correspondante

}

echo « </table> » >> $tablo; #code de fin de tableau

echo « <h2 align=center><strong>Barrage_$fic2</strong></h2><table border=1><TH>Liste URL</TH><TH>Liens vers la page WEB</TH> » >> $tablo; #code de début de tableau

for nom in `cat $fic2` #$nom est la variable dans laquelle sera stocké chaque lien

{

echo « <tr><td>$nom</td><td><A href= »$nom »>$nom</A></td></tr> » >> $tablo; #création d’un tableau à deux colonnes et autant de lignes qu’il y a d’URL avec lien vers la page correspondante

}

echo « </table></body></html> » >> $tablo; #code de fin de tableau et code de fin document html

#le fichier dont le nom correspond à la variable tablo est maintenant créé, ouvrez-le

 

Arianna Bisazza

AB : Pages aspirées avec wget

Posted in Projet 2006-2007 by pluritaluser on 8 novembre 2006

Dans le répertoire PAGES-ASPIREES j’ai créé un dossier pour chaque sens du mot « barrage ». Chaque dossier contient le fichier .txt avec la liste d’URL. J’utilise la commande wget pour aspirer mes pages. L’option –i signifie que la liste de URL à enregistrer se trouve dans le fichier indiqué.

wget -i action.txt

wget -i match.txt

etc.

Mes pages se trouvent maintenant sur mon disque dur. Pour pouvoir toutes les afficher je renomme les fichier .php en changeant simplement l’extension => .html. Par exemple :

spip.php@article816 => spip.html@article@816

 

Arianna Bisazza

AB : Nouvelle liste d’URL

Posted in Projet 2006-2007 by pluritaluser on 8 novembre 2006

En utilisant Google j’ai collecté environ 50 URL de pages contenant le mot « barrage ».

Chaque sens du mot (source : le Trésor de la Langue Française Informatisé) est associé à un fichier .txt contenant une liste d’URL :

Sens générique : Action de barrer. S’opposer à. Faire barrage

=> action.txt

http://www.armenews.com/article.php3?id_article=1789

http://perso.orange.fr/jacques.loess/declarations.htm

http://endehors.org/news/11760.shtml

http://www.france.attac.org/spip.php?article5661

http://www.energay.org/spip/article.php3?id_article=103

http://www.acalpa.org/lettres_ouvertes.htm

http://www.mutualite.fr/web/Frameset.nsf/Mutuelles/CP_2002-4-25-1?OpenDocument&AutoFramed

TECHN. MILIT. Tir de barrage. Tir d’artillerie destiné à barrer le passage à l’ennemi.

=> tir_militaire.txt

http://www.ville-oissel.fr/pages/histoire_14-18.htm

http://www.lefigaro.fr/liban/20060726.WWW000000247_un_bombardement_israelien_tue_quatre_observateurs_de_l_onu.html

http://perso.orange.fr/jlf.site/Vouziers.htm

http://www.jeux-strategie.com/Les-unites-de-Winter-Assault.2504.0.html

http://www.annales.org/archives/x/bouvier.html

http://dessins1418.free.fr/la_page_litteraire.htm

http://www.vac-acc.gc.ca/youth_f/sub.cfm?source=history/firstwar/1diary/bottomley/oct1918

 

Sens figuré : Opposition (à quelqu’un ou à quelque chose) se manifestant par une série de protestations ou d’actions

=> tir_opposition.txt

http://afrique.blogs.liberation.fr/afrique/2005/11/index.html

http://www.liberation.fr/dossiers/gauche/guerre/38501.FR.php

http://www.medhyg.ch/mh/formation/comments.php3?op=Reply&pid=0&sid=22762

http://umpsinges.blogmilitant.com/index.php/2006/07/23/49-affaire-paris-match-genestar

http://www.alternatives-internationales.fr/article.php3?id_article=14

Dans le domaine sportif:

=> tir_sport.txt

http://fr.sports.yahoo.com/23102006/53/tir-l-arc-cm-park-et-zhang-sacres.html

http://www.lakeshoresoccer.ca/HLPlayoffs/about.htm

http://www.francetop.com/articles/coupe-du-monde-de-football-2006.htm

http://sports.linternaute.com/fr/cmc/tennis/200636/mauresmo-ca-fait-cher-_106589.html

http://www.fca.ca/ex/03wingamestecpkgFR.htm

PSYCHOL. [Correspond à barrer II] Test de barrage. Test de l’attention qui consiste à barrer d’un trait certains signes géométriques simples, mélangés à d’autres signes presque semblables (d’apr. Psychol. 1969).

=> psycho.txt

http://ura1195-6.univ-lyon1.fr/SFRS/pub/bulletins/9/map.html

http://www.meimon-nisenbaum.avocat.fr/lexique.htm?lettre=neuropsychologique

http://www.ajol.info/viewarticle.php?id=6515

http://www.recrutement.gendarmerie.defense.gouv.fr/contenu/decouvrir/soutien_administration/corps_de_soutien_technique_et_administratif_de_la_gendarmerie_nationale/

administration_et_gestion_du_personnel

http://www.aapel.org/bdp/BLbpd-Bi-AD.html

 

Match de barrage. Match servant à départager deux concurrents ou deux équipes qui, au cours d’une compétition générale (championnat, coupe, etc.), sont à égalité de points.

=> match.txt

http://www.letemps.ch/template/transmettre.asp?contenupage=nlreader&page=newsletterdisplay&id=15&NLArtID=5129

http://fifaworldcup.yahoo.com/06/fr/050910/1/2g2k.html

http://www.maroc-echecs.com/spip.php?article816

http://www.ff-handball.org/ffhb/html/les-championnats/de-france/seniors/n1m/la_formule.php

http://www.mytennis.ch/daviscup/pages/index.cfm?dom=2&rub=1031&id=1715&vDate=09%7C2005

Par métonymie : Barrière, obstacle qui ferme un passage. Ex : Barrage de police; forcer un barrage

=> police.txt

http://www.mondialisme.org/article.php3?id_article=671

http://www.legrandsoir.info/article.php3?id_article=3852

http://www.nepalembassy.org/NepalFrance.INFO/article_view.php?id=970&title=Barrages-anti-CPE-en-province&by=

http://del-oceanalaboucleduniger.blogs-de-voyage.fr/

http://lyon-figaro.com/international/20061024.FIG000000176__budapest_commemoration_agitee_de_l_insurrection_de_.html

http://www.amb-pays-bas.fr/fr/ambassade/jbz/actualitesdrogue2004.htm

Sens figuré (1) : Ex. Le christianisme, par exemple, n’est plus aujourd’hui qu’un barrage

=> metaph_constituer.txt

http://www.zenit.org/french/visualizza.phtml?sid=54058

http://site.pacte.free.fr/pacte/82/pacte82b.htm

http://users.skynet.be/gresea/ap_rse_02_98.htm

http://cathisere.cef.fr/chroniquesrcf/billetrcfbinet/textesarchivesrcfbinet0304/binet190404eglisegenocide.htm

Sens figuré (2) : Barrage linguistique

=> metaph_ling.txt

http://www.lesnouvelles.org/P10_magazine/15_grandentretien/15025_genevieverosset.html

http://osi.bouake.free.fr/article.php?id_article=438

http://ahrf.revues.org/document1011.html

http://www.iru.org/events/CTPsem2006/Marchadour.e.htm

DR. FÉOD. Barrière qu’on ne pouvait franchir qu’en payant un droit de péage. Droit de barrage: => moyen-age.txt

http://www.fordham.edu/halsall/french/feod.htm

http://www.corpusetampois.com/cbe-michelbillard.html

http://savarymandereau.free.fr/mandereau.html

http://www.corpusetampois.com/cbe-20-ame-aa1990chabin.html

http://diderot.alembert.free.fr/B.html

TRAV. PUBL. Ouvrage construit sur un cours d’eau, soit pour dériver ou régulariser le cours, soit pour en utiliser la retenue comme source d’énergie ou comme réserve pour l’irrigation : Ex. Barrage d’accumulation, de prise, de régulation, de retenue; barrage fixe, mobile, provisoire, artificiel.

=> hydro.txt

http://www.sflp.org/fr/007/pub1/84.htm

http://www.cnrs.fr/cw/dossiers/dosclim/biblio/pigb16/04_ressources.htm

http://www.alliancefrancaise.org.cn/chengdu/v1/Guide_Chengdu.htm

http://www.mincom.gov.ma/french/reg_vil/regions/Gharb-Chrarda/equipements.html

http://www.projetmontsaintmichel.fr/projet/couesnon.asp

http://www.icilome.com/togo/index.asp

http://www.gaia-energies.indepnet.org/article.php3?id_article=50

http://www.unesco.org/courier/2000_04/fr/planet.htm

http://eau.apinc.org/article.php3?id_article=234

ped02-CJ-barrage-wget-discussion

Posted in Projet 2006-2007 by pluritaluser on 5 novembre 2006

Bonjour à tous et à toutes,

voici un nouveau post pour faire part de l’expérience que j’ai eu ce dimanche : il concerne wget et ses options et comment les options d’un programme peuvent influencer la structure d’un programme.

J’avais conçu mon programme c’est à dire je l’avais imaginé, presque couché sur papier, j’avais donc une bonne idée de comment réaliser le programme pour le projet barrage.

Tout était prêt, je commence à programmer, jusqu’à ce que j’arrive à l’instruction wget.

En effet nous avons vu précédemment trois options de wget :

-i nom_de_fichier : permet de télécharger toutes les URLs présentent dans le fichier.

-O nom_de_fichier : Enregistre la page téléchargée avec le nom nom_de_fichier.

-P repertoire : Enregistre les pages téléchargées dans le repertoire.

Il semble que certaines combinaisons ne fonctionnent pas tel -O et -P, je pensais qu’en spécifiant ces deux options je pourrais enregistrer le fichier spécifié par l’option -O dans le répertoire spécifié par l’option -P mais a postériori cela ne fonctionne pas (wget 1.10 sous linux, ex wget -O fichier.html -P PAGES_ASPIREES url).

Il y a bien une solution qui est la concaténation (ce mot est entré dans mon lexique depuis peu :-)), d’un nom de répertoire et du nom de fichier.

Ex en shell :

nomFichierComplet= »$repertoire » »/ » »$nom_de_fichier »

Et ensuite utilisé wget -O $nomFichierComplet url
Ceci n’est qu’un accident de parcours, le vrai problème est la réponse à la question suivante :

Peut-on utiliser les options -O et -i simultanément, si oui que se passe-t-il ?

Oui ces options sont utilisables simultanément mais que font-elles ?

D’après man wget :

-O fichier
–output-document=fichier
Les documents ne seront pas crits dans les fichiers appropris,
mais tous concatns les uns aux autres et crits dans fichier. Si
fichier existe dj, il sera remplac. Si fichier vaut -, les docu-
ments seront crits sur la sortie standard. Cette option positionne
automatiquement le nombre de tentatives 1.

On a ici la réponse, qui ammène une aute question :

– Comment le choix de l’option -i ou -O pour wget va-t-il influer sur la structure du programme shell que l’on doit écrire ?

Christian JEAN.

séance 02.11.06_ML PED13

Posted in Projet 2006-2007 by pluritaluser on 2 novembre 2006

1- Un rapide coup d’oeil sur les bases en HTML

2- Quelques rappels sur les scripts bash

Intérêt des scripts : automatisation des traitements, i.e. de l’exécution des lignes de commandes qui constituent le script.

Il faut un fichier exécutable (le script) dans lequel est bien spécifié l’interpréteur par lequel le script peut être exécuté par la suite (1° ligne de script ‘#!/bin/bash‘).

 

Les chemins de type ‘cd f:

ne fonctionnent sous Cygwin que parce qu’on est sous une OSWindows, mais ça ne marcherait pas sous une OSLinux : il faudrait entrer la commande complète

cd /cygdrive/f

Si le chemin doit contenir des espaces, il faut les despécialiser afin qu’ils ne soient pas interprétés comme faisant partie de la ligne de commande dans l’invite de commande Cygwin

 

Dans l’invite de commande Cygwin, le ./‘ qui précède le nom de fichier que l’on veut lancer indique qu’on est dans le répertoire courant.

On aura simplement ‘./nomdufichieràlancer‘ si le fichier en question est dans le répertoire courant.

Mais si l’on est dans un autre répertoire, pour lancer l’exécution du fichier, il faut spécifier le chemin absolu, par exemple ‘./repertoire1/répertoirecourant/nomdufichieràlancer‘.

 

Dans un script shell, il n’y a pas de déclaration de variables.

Les double-quotes signifient que leur contenu est une chaîne de caractères, sauf s’il y a une variable dedans.

3- Commentaire détaillé du script bash mis à disposition par les enseignants

  • Il s’agit du script fait-tableau-v1 .

#!/bin/bash
# Cette première ligne indique au shell où il doit chercher l’interpréteur bash
# i.e. quel interpréteur de commandes de shell il doit chercher.
# ‘bash’ est une commande ayant la fonction d’interpréteur.
# Pour que les lignes de commandes du programmes soient ‘comprises’ par la machine,
# il faut spécifier l’interpréteur de commandes.
# On parle de ‘shell d’automatisation de tâches’.

echo « donne nom de fichier contenant les liens http »; #c’est la liste des pages wgettées
# cette ligne signifie que le programme exécute la commande ‘echo’, qui affiche un message
# le programme attend une donnée d’entrée de départ, qu’il faut indiquer dans la fenêtre de commandes
# à la suite de la commande ‘echo’
read fic; #le programme connait le fichier de liens sous le nom $fic
# cette commande associe la variable ‘fic’ à la valeur ‘adresse du fichier en entrée’
echo « donne nom de fichier html où stocker ces liens »; #c’est le tableau de liens à créer
read tablo; #enregistre nom donné par utilisateur dans la variable $tablo
echo « <html><head><title>tableau de liens</title></head><body><table border=1> » > $tablo; #code de début de tableau
# prend le contenu entre guillemets et l’insère en contenu de la variable ‘$tablo’

# la commande ‘for’ initie une boucle, i.e. un ensemble de commandes qu’on va répéter plusieurs fois
for nom in `cat $fic` #$nom est la variable dans laquelle sera stocké chaque lien
# les back-quotes qui entourent la commande ‘cat’ permettent de récupérer
# le contenu de l’exécution de cette commande,
# i.e. la récupération de l’affichage des lignes du fichier ‘$fic’;
# ce contenu récupéré est renvoyé vars la commande ‘for’ dont dépend la boucle
{
echo « <tr><td><a href=\ »$nom\ »>$nom</a></td></tr> » >> $tablo;
#création d’un tableau à une colonne et autant de lignes qu’il y a d’URL
}
echo « </table></body></html> » >> $tablo; #code de fin de tableau
#le fichier dont le nom correspond à la variable tablo est maintenant créé, ouvrez-le

Voilà pour aujourd’hui ^^

A bientôt!

Marguerite