Bash

• Ctrl + a : Pour aller au début de la ligne
• Ctrl + e : Pour aller à la fin de la ligne
• Ctrl + b : Pour se déplacer d'un caractère vers l'arrière (flèche gauche)
• Ctrl + f : Pour se déplacer d'un caractère vers l'avant (flèche droite)
• Alt + b : Pour se déplacer d'un mot vers l'arrière
• Alt + f : Pour se déplacer d'un mot vers l'avant
• Ctrl + xx : Pour passer de la position du curseur au début de la ligne et revenir à la position où se trouvait le curseur
• TAB : Pour compléter automatiquement les noms de fichiers/dossiers/commandes
• Ctrl + d : Pour effacer le caractère sur lequel se trouve le curseur
• Ctrl + h : Pour effacer le caractère précédant le curseur (la fonction classique du retour arrière)
• Alt + d : Pour effacer le mot suivant le curseur
• Alt + retour arrière : Pour effacer le mot précédant le curseur
• Ctrl + l : Pour nettoyer l'écran (l'équivalent de la commande clear)
• Alt + t : Pour échanger la place du mot où se trouve le curseur avec celui le précédant
• Ctrl + t : Pour échanger la place des deux caractères précédant le curseur
• Ctrl + w : Pour couper le mot précédant le curseur
• Ctrl + k : Pour couper la partie de la ligne suivant le curseur
• Ctrl + u : Pour couper la partie de la ligne précédant le curseur
• Ctrl + y : Pour coller la dernière chose coupée
• Ctrl + _ : Pour annuler la dernière modification (undo)
• Ctrl + j : Pour créer une nouvelle ligne
• Ctrl + c : Pour arrêter la commande en cours et créer aussi une nouvelle ligne
• Ctrl + r : Pour rechercher une commande précédente dans l'historique
• Ctrl + g : Pour quitter la recherche dans l'historique
• Ctrl + p : Commande précédente (flèche haut)
• Ctrl + n : Commande suivante (flèche bas)
• Ctrl + x + e : Pour lancer un traitement de texte (nano par ex.) pour écrire une longue commande.

• !! : Pour répéter la dernière commande
• alt + . : Pour ajouter le dernier argument de la dernière commande

$ vim todo.txt
$ mv [alt + .]todo.txt ~/tmp

• !$ : Egalement utile pour ajouter le dernier argument de la dernière commande
• !* : Pour reproduire tous les arguments de la dernière commande

C'est utile si vous faites une erreur du genre :
$ vim cd ~/downloads
$ !*
ce qui donnera
$ cd ~/downloads

• !foo : Pour réutiliser la dernière commande en commençant par foo (on peut aussi faire foo !!)
• !:- : Pour réutiliser la dernière commande sans le dernier argument

Un exemple:
$ ping -c 3 linuxfr.org
$ !:- framasoft.org
Ce qui donnera
$ ping -c 3 framasoft.org

• A ces commandes, vous pouvez ajouter à la fin :p (par ex. !*:p) pour afficher la commande sans qu'elle se lance.

See all bash builtins. Type the following command:

$ help
$ help | less

For your ready references here are all your handy bash parameter substitution operators.

${parameter:-defaultValue}	Get default shell variables value
${parameter:=defaultValue}	Set default shell variables value
${parameter:?"Error Message"}	Display an error message if parameter is not set
${#var}	Find the length of the string
${var%pattern}	Remove from shortest rear (end) pattern
${var%%pattern}	Remove from longest rear (end) pattern
${var:num1:num2}	Substring
${var#pattern}	Remove from shortest front pattern
${var##pattern}	Remove from longest front pattern
${var/pattern/string}	Find and replace (only replace first occurrence)
${var//pattern/string}	Find and replace all occurrences

The syntax is as follows:

${parameter:-defaultValue}
var=${parameter:-defaultValue}

If parameter not set, use defaultValue.

The syntax is as follows:

${var:=value}
var=${USER:=value}

The assignment ( := ) operator is used to assign a value to the variable if it doesn't already have one.

If the variable is not defined or not passed, you can stop executing the Bash script with the following syntax:

${varName?Error varName is not defined}
${varName:?Error varName is not defined or is empty}
${1:?"mkjail: Missing operand"}
MESSAGE="Usage: mkjail.sh domainname IPv4"             ### define error message
_domain=${2?"Error: ${MESSAGE}"}  ### you can use $MESSAGE too

This is used for giving an error message for unset parameters.

You can easily find string length using the following syntax:

${#variableName}
echo ${#variableName}
len=${#var}

The syntax is as follows:

${var#Pattern}
${var##Pattern}

The first syntax removes shortest part of pattern and the second syntax removes the longest part of the pattern.

The syntax is as follows:

${var%pattern}
${var%%pattern}

Exactly the same as above, except that it applies to the back of $var.

The syntax is as follows:

${varName/Pattern/Replacement}
${varName/word1/word2}
${os/Unix/Linux}

To replace all matches of pattern, enter :

out="${x//unix/linux}"

The syntax is as follows:

${parameter:offset}
${parameter:offset:length}
${variable:position}
var=${string:position}

Expands to up to length characters of parameter starting at the character specified by offset.

complete -W "$(echo `cat ~/.ssh/known_hosts | cut -f 1 -d ' ' | sed -e s/,.*//g | uniq | grep -v "\["`;)" ssh scp sftp

Copier un fichier avec progression pv Pour copier un fichier, on va utiliser uniquement la commande pv :

pv fic-source > fic-dest

Ce qui donne par exemple :

pv Fedora-Cinnamon-Live-x86_64-24_Beta-1.6.iso > copie.iso
1.28GiO 0:00:02 [ 529MiB/s] [==========================>] 100%

Créer une clé USB bootable avec dd et pv Pour créer une clé USB (/dev/sdc) bootable d'une ISO Linux, la commande est :

dd if=fichier-image-linux.iso of=/dev/sdc

Dorénavant, on peut utiliser avec pv pour avoir une progression de l'avancement de la copie :

pv fichier-image-linux.iso | dd of=/dev/sdc

Ce qui donne en fin de copie ceci : (Imaginer le curseur ===⇒ avancer au cours de la copie)

pv fichier-image-linux.iso | dd of=/dev/sdc
1,41GiO 0:00:54 [26,5MiB/s] [=======================================================>] 100%
2965504+0 enregistrements lus
2965504+0 enregistrements écrits
1518338048 octets (1,5 GB) copiés, 54,5804 s, 27,8 MB/s

Créer une archive compressée .tar.gz Coupler tar et pv est possible, utiliser comme ceci :

tar -czf - dossier | pv > archive.tar.gz

Décompresser une archive .tar.gz Pour décompresser, même principe que la compression, mais à l'envers :

pv sox.tar.gz |tar xzf -
/code>

===== Rm except =====
  * Delete all file except file1
<code>rm  !(file1)

• Delete all file except file1 and file2

rm  !(file1|file2)

• Delete all file except all zip files

rm  !(*.zip)

• Delete all file except all zip and iso files

rm  !(*.zip|*.iso)

• You set full path too

rm /Users/vivek/!(*.zip|*.iso|*.mp3)

• Pass options

rm [options]  !(*.zip|*.iso)

rm -v  !(*.zip|*.iso)

rm -f  !(*.zip|*.iso)

rm -v -i  !(*.php)

Lorsque que l'on écrit le script suivant foo.sh:

#!/usr/bin/env bash

foo() {
    echo "Hello World!"
}

foo
exit 1

on peut écrire un fichier de test test.bats:

#!/usr/bin/env bats

@test "test sur l'output dans stdout" {
    run bash foo.sh
        [ "${lines[0]}" = "Hello World!" ]
}

@test "test sur l'exit code" {
    run bash foo.sh
        [ "$status" -eq 0 ]
}

et lancer la commande:

bats test.bats

Cela fournit le résultat suivant:

✓ test sur l'output dans stdout
✗ test sur l'exit code
    (in test file test.bats, line 10)
        `[ "$status" -eq 0 ]' failed

2 tests, 1 failure

#!/bin/bash
vercomp () {
    if [[ $1 == $2 ]]
    then
        return 0
    fi
    local IFS=.
    local i ver1=($1) ver2=($2)
    # fill empty fields in ver1 with zeros
    for ((i=${#ver1[@]}; i<${#ver2[@]}; i++))
    do
        ver1[i]=0
    done
    for ((i=0; i<${#ver1[@]}; i++))
    do
        if [[ -z ${ver2[i]} ]]
        then
            # fill empty fields in ver2 with zeros
            ver2[i]=0
        fi
        if ((10#${ver1[i]} > 10#${ver2[i]}))
        then
            return 1
        fi
        if ((10#${ver1[i]} < 10#${ver2[i]}))
        then
            return 2
        fi
    done
    return 0
}