Fonction sur les Entrées Sorties (Manipulation des
fichiers)
Introduction
Ouverture de fichier (io.open) Fermeture de fichier (io.close) Vide le fichier (io.flush)
Définir le fichier d’entrée par défaut (io.input) Lecture ligne par ligne (io.lines)
Définir le fichier de sortie par défaut (io.output) Ouverture d’un fichier temporaire (io.tmpfile) Vérification de descripteur de fichier (io.type) Ecriture dans un fichier (io.write)
Fermeture de fichier (f:close)
Sauve les données du fichier (f:flush) Lecture ligne par ligne (f:lines) Lecture de fichier (f :read)
Se positionne sur l’index dans un fichier (f:seek) Ecriture d’arguments (f:write)
Introduction
La bibliothèque de fonction d’entrée/sortie (input/output ) propose deux styles différents pour la manipulation de fichiers.
Le premier utilise les descripteurs de fichiers implicite, c'est-à-dire qu’il faut définir un fichier d'entrée par défaut et un fichier de sortie par défaut, et toutes les entrées / sorties sont sur ce fichier par défaut.
Le second style utilise des descripteurs de fichier explicite.
Lorsque vous utilisez les descripteurs de fichiers implicite, toutes les opérations sont fournies par la table io.
Lorsque vous utilisez les descripteurs de fichier explicite, l’opération io.open retourne un descripteur de fichier, puis toutes les opérations sont fournis en tant que méthodes de ce descripteur de fichier.
La table io fournit également trois descripteurs de fichiers prédéfinis avec leur sens habituel à partir du langage C: io.stdin, io.stdout, et io.stderr.
Un descripteur de fichier est un "userdata" contenant le flux de fichier (FILE *), avec un caractère distinctif "Metatable" créée par la bibliothèque I/O.
Sauf indication contraire, toutes les fonctions I / O retourne nil en cas d'échec (plus un message d'erreur en second) et une valeur différente de nil en cas de succès.
Ouverture de fichier (io.open)
file = io.open (filename [, mode])
Cette fonction ouvre un fichier, dans le mode spécifié par la chaîne de
caractères mode. Elle retourne un nouveau descripteur de fichier, ou, en cas d'erreur, nil, plus un message d'erreur.
La chaîne mode peut avoir une des valeurs suivantes:
"w" mode d'écriture; "a" append mode;
"r +" mode mise à jour, toutes les données précédentes sont préservée; "w +" mode mise à jour, toutes les données précédentes sont effacées;
"a +" append mode mise à jour, les données précédentes sont conservées, l'écriture n'est autorisée qu’à la fin du fichier. La chaîne de caractères mode peuvent avoir un b la fin ce qui est indispensable pour ouvrir
un fichier en mode binaire. Cette chaîne de caractères est exactement la même que celle qui est utilisé dans la fonction fopen du langage C standard.
Fermeture de fichier (io.close)
io.close ([file])
Equivalent à file.close. Sans un fichier, il clôt le fichier de sortie par défaut.
Vide le fichier (io.flush)
io.flush ()
Equivalent à file : flush sur le fichier de sortie par défaut.
Définir le fichier d’entrée par défaut (io.input)
(io.input [fichier])
Lorsqu'elle est appelée avec un nom de fichier, il ouvre le fichier nommé (en mode texte), et l'utilise comme descripteur d'entrée par défaut. Lorsque cette fonction est appelée avec un descripteur de fichier, elle établit simplement ce descripteur de fichier comme le fichier d'entrée par défaut. Lorsqu'elle est appelé sans paramètres, elle renvoie descripteur de fichier d'entrée actuel par le défaut.
En cas d'erreur, cette fonction déclenche l'erreur, au lieu de retourner un code d'erreur.
Lecture ligne par ligne (io.lines)
io.lines ([file])
Ouvre le nom de fichier donné en lecture et retourne une fonction itération qui, chaque fois qu'elle est appelée, retourne une nouvelle ligne à partir du fichier. Exemple de
construction:
for line in io.lines(filename) do ... end
Cette syntaxe parcourir toutes les lignes du fichier. Lorsque la fonction itération détecte la fin du fichier, elle ferme le fichier et renvoie nil (pour terminer la boucle).
Un appel à io.lines (sans nom de fichier) est équivalent à io.input ():line() qui parcourt les lignes du fichier d'entrée par défaut.
(io.output [file])
Comparable à io.input, mais fonctionne sur le fichier de sortie par défaut.
Lecture de fichier (io.read)
io.read (format1, ...) Equivalent à io.input (): read.
Ouverture d’un fichier temporaire (io.tmpfile)
io.tmpfile ()
Retourne un descripteur de fichier temporaire. Ce fichier est ouvert en mode mise à jour et il est automatiquement supprimé lorsque le programme se termine.
Vérification de descripteur de fichier (io.type)
(io.type obj)
Vérifie si obj est un descripteur de fichier valide. Renvoie la chaîne "file" si obj est un descripteur de fichier ouvert, "closed file" si obj est un descripteur de fichier fermé, et nil si obj n'est pas un descripteur de fichier.
Ecriture dans un fichier (io.write)
io.write (valeur1, ...)
Equivalent à io.output (): write.
Fermeture de fichier (f: Close)
f:close () Ferme le fichier f.
Sauve les données du fichier (f: flush)
f:flush ()
Enregistre les données écrites sur le fichier f.
Lecture ligne par ligne (f:lines)
f:lines ()
Retourne une fonction itération qui, chaque fois qu'elle est appelée, retourne une nouvelle ligne à partir du fichier f. Par conséquent, la construction
for line in f:lines() do ... end
va parcourir toutes les lignes du fichier de f. (Contrairement io.lines, cette fonction ne ferme pas le fichier lorsque la boucle est finie.)
f: read (format1, ...)
Lit le fichier f, selon les formats de données, qui précisent ce qu'il faut lire. Pour chaque format, la fonction retourne une chaîne (ou un nombre) ainsi que les caractères lus, ou nil si elle ne peut pas lire des données avec le format spécifié. Lorsqu'elle est appelé sans format, elle utilise un format par défaut qui lit la ligne suivante en entier (voir ci-dessous). Les formats disponibles sont :
"* n" lit un nombre, ceci est le seul format qui retourne un nombre au lieu d'une chaîne. "* un" lit le fichier entier, à partir de la position actuelle. Sur la fin du fichier, elle retourne la chaîne vide.
"* l", lit la ligne suivante (en sautant à la fin de ligne), retourne nil à la fin du fichier. Il s'agit du format par défaut.
Numéro lit une chaîne avec un nombre maximum de caractères, retourne nil à la fin du fichier. Si le nombre est égal à zéro, elle ne lit rien et renvoie une chaîne vide ou nil à la fin du fichier.
Se positionne sur l’index dans un fichier (f:seek)
f: seek ([whence] [, offset])
Définit et renvoie la position de l'index pour le fichier f, mesurée à partir du début du fichier, à la position donnée en offset en plus d'une base spécifiée par la chaîne, comme suit:
"set" est la position 0 (début du fichier); "cur" est la position actuelle;
"end" est la fin du fichier;
En cas de succès, la fonction retourne la position du fichier final, exprimé en octets depuis le début du fichier. Si cette fonction échoue, elle retourne nil, en plus d'une chaîne de caractères décrivant l'erreur.
La valeur par défaut pour « whence » est "cur", et pour l'offset est 0. Par conséquent, le fichier d'appel: seek () retourne la position du fichier en cours, sans le modifier, la fonction file: seek ( "SET") définit la position au début du fichier (et renvoie 0) et la fonction file:seek ( "end"), fixe la position à la fin du fichier, et renvoie sa taille.
Ecriture d’arguments (f:write)
f: write (valeur1, ...)
Écrit la valeur de chacun de ses arguments dans le fichier f. Les arguments doivent être des chaînes ou des numéros. Pour écrire d'autres valeurs, utiliser toString ou
String.Format avant d'écrire dans le fichier.
Fonctions du système
Ce document présente les fonctions système en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro Extended Edition.
Voici la liste préliminaire de description des fonctions système:
Temps écoulé depuis le lancement de LUA en seconde (os.clock) Date et heure courante (os.date)
Différence de temps écoulé entre deux dates (os.difftime) Exécution d’un programme du logiciel d'exploitation (os.execute)
Quit le programme (os.exit)
Obtenir la variable d’environnements de l’OS (os.getenv) Suppression de fichier (os.remove)
Renomme un fichier (os.rename) Définir un variable locale (os.setlocale) Table de date et heure (os.time)
Création d’un fichier temporaire (os.tmpname)
Temps écoulé depuis le lancement de LUA en seconde (os.clock)
os.clock()
Retourne le temps écoulé depuis que Lua a commencé en secondes. > = os.clock()
11056.989
Date et heure courante (os.date)
os.date([format [, temps ] ])
Retourne dans une table des informations de date et heure formatté par une chaîne de caractère. La chaîne de caractère a le même format que la fonction strftime() de C. Les caractères suivants sont utilisés pour spécifier le format de la date :
%a - nom abrégé du jour de la semaine (local) %A - nom complet du jour de la semaine (local) %b - nom abrégé du mois (local)
%B - nom complet du mois (local)
%c - représentation préférée pour les dates et heures, en local
%C - numéro de siècle (l'année, divisée par 100 et arrondie entre 00 et 99) %d - jour du mois en numérique (intervalle 01 à 31)
%D - identique à %m/%d/%y
%e - numéro du jour du mois. Les chiffres sont précédés d'un espace (de ' 1' à '31')
%g - identique à %G, sur 2 chiffres
%G - L'année sur 4 chiffres correspondant au numéro de semaine (voir %V). Même format et valeur que %Y, excepté que si le numéro de la semaine appartient à l'année précédente ou suivante, l'année courante sera utilisé à la place
%h - identique à %b
%H - heure de la journée en numérique, et sur 24-heures (intervalle de 00 à 23) %I - heure de la journée en numérique, et sur 12- heures (intervalle 01 à 12) %j - jour de l'année, en numérique (intervalle 001 à 366)
%m - mois en numérique (intervalle 1 à 12) %M - minute en numérique
%n - caractère de nouvelle ligne
%p - `AM' ou `PM', en majuscule, suivant la valeur donnée, ou la chaîne correspondante pour la locale courante
%P - `am' ou `pm', en majuscule, suivant la valeur donnée, ou la chaîne correspondante à la locale courante
%r - l'heure au format a.m. et p.m %R - l'heure au format 24h
%S - secondes en numérique %t - tabulation
%u - le numéro de jour dans la semaine, de 1 à 7. (1 représente Lundi) %U - numéro de semaine dans l'année, en considérant le premier dimanche de
l'année comme le premier jour de la première semaine
%V - le numéro de semaine comme défini dans l'ISO 8601:1988, sous forme décimale, de 01 à 53. La semaine 1 est la première semaine qui a plus de 4 jours dans l'année courante, et dont Lundi est le premier jour. (Utilisez %G ou %g pour les éléments de l'année qui correspondent au numéro de la semaine pour le timestamp donné.)
%W - numéro de semaine dans l'année, en considérant le premier lundi de l'année comme le premier jour de la première semaine
%w - jour de la semaine, numérique, avec Dimanche = 0 %x - format préféré de représentation de la date sans l'heure %X - format préféré de représentation de l'heure sans la date %y - l'année, numérique, sur deux chiffres (de 00 à 99) %Y - l'année, numérique, sur quatre chiffres
%Z ou %z - fuseau horaire, ou nom ou abréviation (suivant le système d'exploitation)
%% - un caractère `%' littéral >os.date("%Y/%m/%d %H:%M:%S") '2010/03/04 09:05:16'
Si la chaîne de caractère de formatage utilisé est "*t" une table est retournée contenant l'information de temps, par exemple,
> table.foreach(os.date('*t '), print) hour 14 min 36 wday 1 year 2003 yday 124 month 5 sec 33 day 4 isdst true
Si le format est précédé par "!" le temps est converti en coordonnées de temps universel , par exemple, > table.foreach(os.date('!*t '),print) hour 21 min 36 wday 1 year 2003 yday 124 month 5 sec 42 day 4 isdst false
os.date() returns une chaine de caractère dans le format MM/DD/YY HH:MM:SS. > print(os.date())
08/16/05 10:22:32
os.difftime(t2, T1)
Calcule le nombre de secondes entre deux référence de temps. > T1 = os.time()
> -- patientez quelques secondes... > = os.difftime(os.time(), T1) 31
> = os.difftime(os.time(), T1) 38
Exécution d’un programme du logiciel d'exploitation (os.execute)
os.execute(command)
Exécute une commande shell du système d'exploitation. C'est comme la fonction system() de C. Un code de statut dépendant de système est retourné. > = os.execute("echo bonjour")
bonjour 0
> = os.execute("mmmmm") -- produise une erreur car 'mmmmm 'n'est pas reconnu comme commande interne ou externe, programme batch ou fichier séquentiel. 1
Quit le programme (os.exit)
os.exit([code ])
Appelle la sortie de fonction de C, avec un code facultatif, pour terminer le programme de centre serveur. La valeur par défaut pour le code retour est le code de succès.
> os.exit(0) -- tue le shell de Lua dans lequel nous sommes et passe la valeur 0 au shell appelant
Obtenir la variable d’environnements de l’OS (os.getenv)
os.getenv(varname)
Renvoie la valeur varname de la variable de processus d'environnement, ou zéro si la variable n'est pas définie.
> = os.getenv("BANANA") nil
> = os.getenv("USERNAME") Nick
Suppression de fichier (os.remove)
os.remove(filename)
Supprime le dossier avec le nom donné. Si cette fonction échoue, elle renvoie nil, plus une chaîne de caractère décrivant l'erreur.
> os.execute("echo bonjour > banana.txt") > = os.remove("banana.txt")
true
> = os.remove("banana.txt")
nil banana.txt : pas de répertoire ou de fichier 2
Renomme un fichier (os.rename)
os.rename(oldname, newname)
Renomme un fichier. Si cette fonction échoue, elle renvoie nil, plus une chaine de caractères décrivant l'erreur.
> os.execute("echo bonjour > banana.txt")
> = os.rename("banana.txt", "apple.txt") -- change le nom du fichier
> = zéro banana.txt d'os.rename("banana.txt", "d'apple.txt") : Aucun un tel dossier ou annuaire 2
Définir un variable locale (os.setlocale)
os.setlocale(locale [, category ])
Permet de définir des variable de localisation spécifique parmi les catégorie suivante "all", "collate", "ctype", "monetary", "numeric", or "time"; La fonction renvoie le nom de la nouvelle variable locale, ou nil si la demande ne peut pas être honorée.
Table de date et heure (os.time)
os.time([table ])
Rempli une table avec la date et l'heure courante, s'utilise comme os.date() retourne le temps en secondes du système.
> t = os.date('*t') -- time now > table.foreach(os.date('*t'), print) hour 15 min 1 wday 1 year 2003 yday 124 month 5 sec 2 day 4 isdst true
> = os.time(t) -- time in system seconds 1052085659
> t.year = 2001 -- 2001, a Lua odyssey > = os.time(t) -- time then
989013659
Création d’un fichier temporaire (os.tmpname)
os.tmpname ()
Défini un fichier qui peut être employé comme fichier temporaire. Cette fonction n'ouvre pas le fichier.
Itération avec LUA
L'utilisation de l'itération for a été abordé dans le le document Itération sur les tables et boucle For.
Ce document complète par quelques notes le moyen d'écrire vos propres iteration. Algorithme
Nous pouvons écrire nos propres iteration à s'appeler par for le rapport. Le pseudo-code suivant de Lua décrit commentfonctionne for avec des iterations :
faites l'iterator local, état, var1 = explist var2 local..., varn tandis que vrai font var1..., le varn = l'iterator(state, var1) si zéro du == var1 cassent alors l'extrémité -- pour
l'extrémité d'extrémité de code de bloc
L'état et la valeur principale courante sont passés dans l'iterator. L'iterator renvoie la nouvelle valeur de la clef et de toutes les autres valeurs, par exemple la valeur produite par l'iterator. Si nil est retourné alors for la boucle est terminée.
Exemple simple
L'iterator suivant renverra un ordre des valeurs carrées. Quand nous ne renvoyons aucune valeur (c.-à-d. n>=state), Lua retourne nil qui termine l'itération. Notez que l'iterator renvoie la prochaine valeur dans l'ordre pour une itération donnée. Nous
employons state pour tenir le nombre d'itérations que nous souhaitons effectuer.
> square(state de fonction, n) si n<state puis n=n+1 n de retour, extrémité d'extrémité de n*n
Voici for le rapport appelle l'iterator :
> pour i,n dans la place, 5, 0 faites le print(i, n) l'extrémité 1 1 2 4 3 9 4 16 5 25
Nous pourrions conclure l'exemple ci-dessus (comme pairs()) et
fournir squares(nbvals) une fonction de constructeur d'iterator. Par exemple,
> place de retour de squares(nbvals) de fonction, nbvals, 0 extrémités -- iterator, état, valeur initiale
Maintenant nous pouvons l'appeler le souhaitons pairs():
> pour i,n en squares(5) faites le print(i, n) l'extrémité 1 1 2 4 3 9 4 16 5 25
Expressions régulières (Pattern matching)
Introduction aux "pattern" (modèles) Classes de caractère
Répétition de caractères Captures de caractères
Prérequit : Si vous êtes novice en terme de manipulation de chaînes de caractères, la lecture du document Chaînes et du document Fonctions des chaînes de caractères est un préalable . Veuillez noter que ce document est une introduction aux concepts utilisé dans les pattern (modèles) et présente quelques exemples de la leur utilisation. Ce n'est pas un présentation détaillé des fonctionnalités des pattern.
Introduction aux "pattern" (modèles)
La bibliothèque de fonction de manipulation des chaîne de caractères de Lua a des fonctionnalité très utile et flexible.
La flexibilité de ces fonctions est due en partie à l'utilisation de pattern (modèles) , parfois (incorrectement) appelées expressions régulières . C'est une manière d'indiquer un jeu de caractères à rechercher dans une chaîne de caractères. Dans l'exemple suivant nous recherchons le jeu de caractères 'an' dans la chaîne de caractères 'banana'. La fonction string.find() renvoie la position de la première
occurrence 'an' de 'banana'.
> = string.find('banana ', 'an') -- trouve la 1er occurence de 'an' 2 3
> = string.find('banana ', 'lua ') -- 'lua 'ne sera pas trouvé nil
C'est assez utile mais peu un rigide, par exemple si nous voulons rechercher les mots de quatre lettres qui commencent par "w" :
> text = 'a word to the wise'
> = string.sub(text, string.find(text, 'w...')) word
> = string.sub(text, string.find(text, 'w...', 5)) -- bit further on... wise
Dans l'exemple ci-dessus nous employons string.sub() pour afficher la sous-chaîne que string.find() a trouvé. La pattern de recherche que nous avons employé les deux fois était 'w...'. Le caractère '.' représente un caractère de wildcard, qui peut remplacer n'importe quel caractère. Les pattern contiennent des séquences de caractères normaux mais aussi des caractères spéciaux qui ont des significations spéciales.
findpattern()
Nous définirons une fonction utile pour la suit. Cette fonction prend juste une chaîne de caractères et une pattern et renvoie la sous-chaîne qui correspond au modèle (pattern) dans cette chaîne de caractères :
> function findpattern(text, pattern, start)
>> return string.sub(text, string.find(text, pattern, start)) >> end
>
> = findpattern('a word to the wise', 'w...') word
> = findpattern('a word to the wise', 'w...', 5) wise
Classes de caractère
Une classe de caractère représente un ensemble de caractères. Le caractère wildcard '.' peut représenter n'importe quel caractère. Il y a plusieurs autres classes représentant des sous-ensembles de caractères, par exemple les nombres, les lettres, caractères
majuscules, minuscules etc... Ces ensembles ont le format %X où X est une lettre représentant la classe. Toutes les classes de caractère disponibles sont entièrement documentées dans le manuel de référence de LUA.
Voyons quelques exemples :
> = findpattern('The quick brown fox', '%a') -- %a is all letters T
> = findpattern('it is 2003', '%d') -- %d finds digits 2
> = findpattern('UPPER lower', '%l') -- %l finds lowercase characters l
> = findpattern('UPPER lower', '%u') -- %u finds uppercase characters U
Juste comme nous pouvons rechercher des chaînes de caractères dans les chaînes de caractères , nous pouvons rechercher des séquences de caractères avec les classes de caractère, et nous pouvons mélanger ces derniers à des chaînes de caractères régulières, par exemple,
> = findpattern('UPPERlower', '%u%l') -- upper followed by lower Rl
> = findpattern('123 234 345', '%d3%d') -- digit 3 digit 234
Ensembles de caractères
De lma même façon que nous définissons des classes prédéfinies de caractère, de la forme %X, nous pouvons également explicitement définir nos propres ensembles. Ceux-ci sont représentés comme [ set ] où "set" est une liste de caractères à rechercher.
> = findpattern('banana ', '[ xyjkn ] ') -- recherchez les caractères dans la liste "xyjkn" n
Employez le trait d'union '-'pour dénoter une fourchette des caractères. > = findpattern('banana ', '[ j-q ] ') -- équivalent au "jklmnopq" n
Nous pouvons employer des classes de caractère dans les ensembles : > = le findpattern('it ist 2003 ', '[ %dabc ] ')
2
Des ensembles peuvent également être employés sous la forme [ ^set ] qui signifie la trouvaille des caractères pas dans l'ensemble énuméré, par exemple,
> = findpattern('banana ', '[ ^ba ] ') -- nous ne voulons pas a ou b n
> = les findpattern('bananas, '[ ^a-n ] ') -- ne pas prendre entre a et n s
> = findpattern('it est 2003 ', '[ ^%l%s ] ') -- pas de lettre minuscule ou espace 2
Répétition de caractères
Parfois nous voulons rechercher des pattern (modèles) mais nous ne connaissons pas le nombre de caractères répété dans la chaîne. Le support de recherche de modèles de longueur variable est possible en utilisant les caractères : * +, - et ?. Ceux-ci sont décritsplus en details dans le manuel de référence LUA aussi nous donnerons un récapitulatif rapide et quelques exemples ici :
* recherche 0 répétitions ou plus de l'élément précédent le modèle, par exemple,
> = findpattern('bananas, 'az * ') a > =findpattern('bananas, 'an* ') an > = findpattern('bannnnnanas, 'an* ') annnnnn
+ recherche 1 répétitions ou plus de l'élément précédent le modèle, par exemple,
> = string.find('banana ', 'az+ ') -- ne seront pas trouvé nil
> = findpattern('bananas, 'an+ ') an
> = findpattern('bannnnnanas, 'de l'an+ ') annnnn
- recherche 0 répétitions ou plus de l'élément précédent le modèle. Mais, ceci diffère
de * qui recherche la séquence la plus courte des éléments, tandis que * recherche la séquence la plus longue, par exemple,
> = findpattern('bananas, 'az - ') a > = findpattern('bananas, 'an- ') a > = findpattern('bannnnanas, 'an- ') a
? recherche les occurrences 0 ou 1 de l'élément précédent de modèle.
> = findpattern('bananas, 'az?') a > = findpattern('bananas, 'an?') an > = findpattern('bannnnanas, 'an?') an
Captures de caractères
Des captures peuvent être marquées dans un modèle à l'aide des parenthèses, par exemple, "w(...)" capturerait les trois dernières lettres du mot de quatre lettres que nous avons employé dans un exemple précédent :
> = string.find('a word to the wise', 'w(...)') -- last three letters 3 6 ord
> = string.find('a word to the wise', '(w.)(..)') -- two! 3 6 wo rd
> = string.find('a word to the wise', '(w(..).)') -- nested 3 6 word or
Vous pouvez constater que string.find() renvoie les index de début et de fin du modèle entier et des captures que nous avons faits à l'aide des parenthèses dans le modèle. Ceci peut être très utile en conjonction avec la fonction string.gsub() , parce qu'au lieu de faire une recherche simple et remplacement, nous pouvons capturer en rpmier et exécuter le remplacement ensuite, par exemple,
> = string.gsub('a word to the wise', '(t%a+)', 'banana') -- simple replace a word banana banana wise 2
>
> = string.gsub('a word to the wise', '(t%a+)', >
> function(x) print(x); return string.upper(x) end) to
the
a word TO THE wise 2 >
> = string.gsub('a word to the wise', '(w%l+)', >
> function(x) return '_'..x..'_' end) a _word_ to the _wise_ 2
