doubleval(){
# Alias de la fonction floatval
#
# EXECUTION
# =========
# doubleval "$var"
#
# RETOUR
# ======
# Retourne la valeur flottante de la variable donnée ou 0 en cas d'erreur
#
floatval "$1"
}
empty(){
# Détermine si une variable est vide
#
# EXECUTION
# =========
# empty "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
typeset VAR=$(sed "s/ //g" <<< "$1")
( [ -z "$VAR" ] || grep -E -q '^0*.?0+$' <<< "$VAR" ) && return 0 || return 1
}
floatval(){
# Convertit une chaine en nombre à virgule flottante
# Une donnée numérique valide est un signe optionnel, suivi par un ou plusieurs
# chiffres, suivi par un point décimal optionnel, suivi par un ou plusieurs
# chiffres optionnels, suivi par un exposant optionnel.
# Un exposant est représenté par la lettre 'e' ou 'E', suivi d'un signe optionnel,
# suivi d'un ou plusieurs chiffres.
# 10 / 10.5 / -5.7 / 10. / 4e5 / 5.6E7
#
# EXECUTION
# =========
# floatval "$var"
#
# RETOUR
# ======
# Retourne la valeur flottante de la variable donnée ou 0 en cas d'erreur
#
typeset VAR=$(grep -E -o '^-?[0-9]*\.?[0-9]+((e|E)-?[0-9]+)?' <<< "$1")
if [ -n "$VAR" ]; then
VAR=$(sed -r 's/(e|E)/\*10\^/g' <<< "$VAR")
calcul "1*$VAR"
return 0
fi
echo 0 && return 1
}
intval(){
# Retourne la valeur numérique entière équivalente d'une variable
#
# EXECUTION
# =========
# intval "$var"
#
# RETOUR
# ======
# Retourne une valeur de type entier en cas de succès ou 0 en cas d'erreur.
#
typeset VAR=$(grep -E -o '^-?[0-9]+' <<< "$1")
if [ -n "$VAR" ]; then
calcul "1*$VAR"
return 0
fi
echo 0 && return 1
}
is_array(){
# Détermine si la variable donnée est un tableau.
#
# EXECUTION
# =========
# array=(a b c d e f)
# is_array "${array[@]}"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
typeset VAR=("$@")
if empty ${VAR[*]}; then
return 1
elif [ ${#VAR[*]} -gt 1 ]; then
return 0
else
return 1
fi
}
is_bool(){
# Détermine si la variable est un booléen
#
# EXECUTION
# =========
# is_bool "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
grep -E -q -i '^(true|false|1|0)$' <<< "$1" && return 0 || return 1
}
is_callable(){
# Détermine si la variable est une commande
#
# EXECUTION
# =========
# is_callable "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
type $1 >/dev/null 2>&1 && return 0 || return 1
}
is_double(){
# Alias de la fonction is_float
#
# EXECUTION
# =========
# is_double "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
is_float "$1"
}
is_float(){
# Détermine si une variable est de type nombre décimal
#
# EXECUTION
# =========
# is_float "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
grep -E -q '^-?[0-9]*\.[0-9]+((e|E)-?[0-9]+)?$' <<< "$1" && return 0 || return 1
}
is_int(){
# Détermine si une variable est de type nombre entier.
#
# EXECUTION
# =========
# is_int "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
grep -E -q '^-?[0-9]+$' <<< "$1" && return 0 || return 1
}
is_integer(){
# Alias de la fonction is_int
#
# EXECUTION
# =========
# is_integer "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
is_int "$1"
}
is_long(){
# Alias de la fonction is_int
#
# EXECUTION
# =========
# is_long "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
is_int "$1"
}
is_numeric(){
# Détermine si une variable est un type numérique
#
# EXECUTION
# =========
# is_numeric "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
grep -E -q '^(\+|-)?[0-9]*\.?[0-9]+((e|E)-?[0-9]+)?$' <<< "$1" && return 0 || return 1
}
is_real(){
# Alias de la fonction is_float
#
# EXECUTION
# =========
# is_real "$var"
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur.
#
is_float "$1"
}
calcul(){
# Calcul le résultat de l'opération passée en paramètre
# à l'aide de la commande bc
# Pour installer la commande bc : sudo apt-get install bc
#
# EXECUTION
# =========
# calcul "5*4"
# calcul "(5*4/20)*2"
# var=$(calcul "5*4")
#
# RETOUR
# ======
# Retourne le résultat de l'opération ou le code retour 1 en cas d'échec
#
( echo "$1" | bc -l ) && return 0 || return 1
}
getdecsep(){
# Retourne le séparateur décimal paramétré sur le sytème
# en fonction de la variable locale installée et définie par défaut.
#
# EXECUTION
# =========
# getdecsep
# var=$(getdecsep)
#
# RETOUR
# ======
# Retourne un point '.' ou une virgule ','
#
( printf "%1.1f" 1 | sed "s/[0-9]//g" ) && return 0 || return 1
}
commatodot(){
# Remplace la virgule ',' par le point '.' dans les
# variables représentant des valeurs décimales.
# 10,5 --> 10.5
#
# EXECUTION
# =========
# commatodot "$var"
# var=$(commatodot "$var")
#
# RETOUR
# ======
# Retourne la valeur remplacée en cas de succès ou le code erreur 1 en cas d'échec.
#
typeset VAR=$(sed "s/,/\./" <<< "$1")
is_float "$VAR" && ( echo "$VAR" && return 0 ) || return 1
}
dottocomma(){
# Remplace le point '.' par la virgule ',' dans les
# variables représentant des valeurs décimales.
# 10.5 --> 10,5
#
# EXECUTION
# =========
# dottocomma "$var"
# var=$(dottocomma "$var")
#
# RETOUR
# ======
# Retourne la valeur remplacée en cas de succès ou le code erreur 1 en cas d'échec.
#
is_float "$(commatodot "$1")" && ( sed "s/\./,/" <<< "$1" && return 0 ) || return 1
}
tolocaldecsep(){
# Remplace le point '.' par le séparateur décimal
# paramétré sur le système dans les variables
# représentant des valeurs décimales.
#
# EXECUTION
# =========
# tolocaldecsep "$var"
# var=$(tolocaldecsep "$var")
#
# RETOUR
# ======
# Retourne la valeur remplacée en cas de succès.
# La valeur 0 en cas d'erreur et le code retour 1.
#
if is_float "$(commatodot "$1")"; then
sed "s/\./$(getdecsep)/" <<< "$1" && return 0
else
echo 0 && return 1
fi
}
prerequis(){
# Test si la ou les commandes passées
# en paramètres sont bien installées
# sur le système.
#
# EXECUTION
# =========
# prerequis vim grep ...
# if prerequis vim >/dev/null; then ...; fi
# prerequis vim >/dev/null && ... || ...
#
# RETOUR
# ======
# Code retour 0 en cas de succès et 1 en cas d'erreur ainsi qu'un message explicatif.
#
typeset VAR
for VAR in "$@"; do
which "$VAR" >/dev/null || ( echo -e "Le programme '$VAR' n'est pas encore installé.\n\
Vous pouvez l'installer en tapant : \n\
sudo apt-get install $VAR" && return 1 )
done
}
getipv4(){
# Extrait une ou plusieurs adresses IPV4
# d'une chaine de caractères passée en paramètre.
#
# EXECUTION
# =========
# RET=$(getipv4 "$VAR")
#
# RETOUR
# ======
# Retourne une chaine contenant toutes
# les adresses IPV4 extraites de la chaine
# séparées par un espace.
#
typeset VAR=$(grep -E -o '([0-9]{1,3}\.){3}[0-9]{1,3}' <<< "$1")
typeset ADRIPV4=""
while read IPV4; do
ADRIPV4="$ADRIPV4 $IPV4"
done <<< "$VAR"
ADRIPV4=$(sed "s/^ //" <<< "$ADRIPV4")
echo "$ADRIPV4" && return 0
}
ltrim(){
# Supprime tous les espaces à gauche
#
# EXECUTION
# =========
# ltrim "$var"
#
# RETOUR
# ======
# Retourne la valeur sans les espaces à gauche et le code retour 0.
#
typeset VAR=$(sed "s/^ *//g" <<< "$1")
echo "$VAR" && return 0
}
rtrim(){
# Supprime tous les espaces à droite
#
# EXECUTION
# =========
# rtrim "$var"
#
# RETOUR
# ======
# Retourne la valeur sans les espaces à droite et le code retour 0.
#
typeset VAR=$(sed "s/ *$//g" <<< "$1")
echo "$VAR" && return 0
}
trim(){
# Supprime tous les espaces à gauche et à droite
#
# EXECUTION
# =========
# trim "$var"
#
# RETOUR
# ======
# Retourne la valeur sans les espaces à gauche et à droite et le code retour 0.
#
typeset VAR="$1"
VAR=$(ltrim "$VAR")
VAR=$(rtrim "$VAR")
echo "$VAR" && return 0
}
gettype(){
# Retourne le type de la variable.
#
# Les typespouvant être retournés (Par ordre de détermination)
# 0 - empty
# 1 - booléen
# 2 - integer
# 3 - double
# 4 - array
# 5 - string
#
# EXECUTION
# =========
# gettype "$var"
#
# RETOUR
# ======
# Retourne le type de la variable et le code retour 0.
#
if empty "$1"; then
echo "empty"
elif is_bool "$1"; then
echo "boolean"
elif is_int "$1"; then
echo "integer"
elif is_float "$1"; then
echo "double"
elif is_array "$@"; then
echo "array"
else
echo "string"
fi
return 0
}
abs(){
# Retourne la valeur absolue du nombre "$var".
#
# EXECUTION
# =========
# abs "$var"
#
# RETOUR
# ======
# Retourne la valeur absolue et le code retour 0.
# Ou 0 et le code retour 1 en cas d'erreur
#
if is_numeric "$1"; then
typeset VAR=$(sed "s/^-//g" <<< "$1")
echo "$VAR" && return 0
fi
echo 0 && return 1
}
ceil(){
# Retourne la valeur arrondie à l'entier supérieur
#
# EXECUTION
# =========
# ceil "$var"
#
# RETOUR
# ======
# Retourne la valeur arrondie à l'entier supérieur et le code retour 0.
# Ou 0 et le code retour 1 en cas d'erreur
#
if is_numeric "$1"; then
typeset VAR=$(sed "s/\.0*$//g" <<< "$1")
typeset ENT=$(intval "$VAR")
if [ $(calcul "$VAR<0") -eq 1 ]; then
VAR="$ENT"
fi
if is_float "$VAR"; then
VAR=$(calcul "$ENT+1")
fi
echo "$VAR"
return 0
fi
echo 0 && return 1
}
floor(){
# Retourne la valeur arrondie à l'entier inférieur
#
# EXECUTION
# =========
# floor "$num"
#
# RETOUR
# ======
# Retourne la valeur arrondie à l'entier inférieur et le code retour 0.
# Ou 0 et le code retour 1 en cas d'erreur
#
if is_numeric "$1"; then
typeset VAR=$(sed "s/\.0*$//g" <<< "$1")
typeset ENT=$(intval "$VAR")
if [ $(calcul "$VAR<0") -eq 1 ]; then
VAR=$(calcul "$ENT-1")
fi
if is_float "$VAR"; then
VAR="$ENT"
fi
echo "$VAR"
return 0
fi
echo 0 && return 1
}
fmod(){
# Retourne le reste de la division
#
# EXECUTION
# =========
# fmod "$num1" "$num2"
#
# RETOUR
# ======
# Retourne le reste de la division et le code retour 0.
# Ou 0 et le code retour 1 en cas d'erreur
#
if is_numeric "$1" && is_numeric "$2"; then
calcul "scale=0; $1%$2"
return 0
fi
echo 0 && return 1
}