# ulib/base.string

## `straddp`
~~~
ajouter le préfixe $1 à $2..*
~~~
## `strdelp`
~~~
enlever le préfixe $1 à $2..*
~~~
## `strdelp2`
~~~
enlever le préfixe $1 le plus long à $2..*
~~~
## `stradds`
~~~
ajouter le suffixe $1 à $2..*
~~~
## `strdels`
~~~
enlever le suffixe $1 à $2..*
~~~
## `strdels2`
~~~
enlever le suffixe le plus long $1 à $2..*
~~~
## `strlower`
~~~
afficher en minuscule la valeur $*
~~~
## `strlower1`
~~~
afficher la valeur $* après avoir converti la première lettre en minuscule
~~~
## `strlowers`
~~~
afficher les valeurs $1..* après avoir converti leur première lettre en
minuscule
~~~
## `strupper`
~~~
afficher en majuscule la valeur $*
~~~
## `strupper1`
~~~
afficher la valeur $* après avoir converti la première lettre en majuscule
~~~
## `struppers`
~~~
afficher les valeurs $1..* après avoir converti leur première lettre en
majuscule
~~~
## `strmid`
~~~
Afficher la plage $1 de la valeur $2..*. La plage peut être d'une des formes
'start', '[start]:length'. Si start est négatif, le compte est effectué à
partir de la fin de la chaine. Si length est négatif, il est rajouté à la
longueur de la chaine à partir de start
~~~
## `strrepl`
~~~
Remplacer dans la valeur $3..* le motif $1 par la chaine $2. $1 peut commencer
par l'un des caractères /, #, % pour indiquer le type de recherche
~~~
## `strops`
~~~
Appliquer à une chaine de caractères une suite de traitements, e.g:
'strops var deref +suffix' est équivalent à 'echo "${var}suffix"'
En commençant avec la valeur initiale $1, les arguments $2..* sont des
opérations à appliquer dans l'ordre.
Les opérations suivantes considèrent que la valeur courante est un nom de
variable:
:- := :? :+ deref dcount
Toutes les autres opérations travaillent directement avec la valeur
courante. Les opérations suivantes appliquent une transformation:
# % / : ^ , +# -# +% -% + - mid repl
Les opérations suivantes font un test sur la valeur et retournent
immédiatement:
= == != < > -eq -ne -lt -le -gt -ge -n -z
La syntaxe des opérateurs standards de bash est reprise autant que possible,
i.e si on a l'habitude d'écrire ${varOP} en bash, alors la syntaxe à utiliser
à priori est 'strops var OP' ou 'strop var deref OP' suivant les opérateurs.
Autres opérateurs:
deref          indirection
dcount         nombre d'éléments du tableau
+#STR          ajouter un préfixe
-#STR          supprimer un préfixe
+%STR ou +STR  ajouter un suffixe
-%STR ou -STR  supprimer un suffixe
mid RANGE      traiter la chaine avec strmid()
repl FROM TO   traiter la chaine avec strrepl()
~~~
## `first_char`
~~~
retourner le premier caractère de la chaine $*
~~~
## `last_char`
~~~
retourner le dernier caractère de la chaine $*
~~~
## `first_chars`
~~~
retourner tous les caractères de la chaine $*, excepté le dernier
~~~
## `last_chars`
~~~
retourner tous les caractères de la chaine $*, excepté le premier
~~~
## `first_char_is`
~~~
Tester si le premier caractère de la chaine $1 est $2
~~~
## `last_char_is`
~~~
Tester si le dernier caractère de la chaine $1 est $2
~~~
## `beginswith`
~~~
Tester si la chaine $1 commence par le wildcard $2
~~~
## `endswith`
~~~
Tester si la chaine $1 se termine par le wildcard $2
~~~
## `strsplitf`
~~~
Cette fonction doit être appelée avec N arguments (avec N>1). Elle analyse et
découpe l'argument $N comme avec une ligne de commande du shell. Ensuite, elle
appelle la fonction $1 avec les arguments de $2 à ${N-1}, suivi des arguments
obtenus lors de l'analyse de l'argument $N. Par exemple, la commande suivante:
strsplitf cmd arg1 "long arg2" "arg3 'long arg4'"
est équivalente à:
cmd arg1 "long arg2" arg3 "long arg4"
Retourner le code 127 si la fonction à appeler n'est pas spécifiée. Retourner
le code 126 si une erreur s'est produite lors de l'analyse de l'argument $N
~~~
## `strecho`
## `strqvals`
~~~
Afficher chaque argument à part avec des quotes. A chainer avec strsplitf()
~~~
## `strqlines`
~~~
Afficher chaque ligne des fichiers spécifiés comme un argument. A chainer avec
strsplitf()
~~~
## `strqarray`
~~~
Afficher chaque valeur des tableaux $@ comme un argument. A chainer avec
strsplitf()
~~~
## `evals`
~~~
Enchainer des traitements sur des chaines de caractères, comme pour la fonction
evalx(). Il y a cependant quelques différences:
- Seules certains fonctions spécifiques peuvent être utilisées: elles sont
reconnaissables à leur préfixe 'str'. En effet, lors de l'utilisation d'une
commande par evals(), le préfixe 'str' est systématiquement ajouté.
- La fonction strsplitf() est traitée de façon particulière pour lancer une
commande avec le préfixe 'str'
Ainsi, la commande suivante:
evals cmd1 // splitf cmd2
est équivalente à la commande:
strplitf strcmd2 "$(strcmd1)"
~~~

-*- coding: utf-8 mode: markdown -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8:noeol:binary