1. Introduction
1. Qu'est-ce que Shell
Shell est l'interface permettant aux utilisateurs d'interagir avec le système. Le shell est un interpréteur de commandes et un langage de programmation de haut niveau
2. Types courants de shells
En même temps, Bash est également le Shell par défaut pour la plupart ; Systèmes Linux ;
3. Limitations du Shell
1.3. Applications clés (bases de données, sites Web, etc.)
1.5. Besoin d'un accès direct au matériel
1.6. Développer des applications fermées (par rapport à l'open source)
Fichier. système : Le système de fichiers Linux est une structure organisationnelle hiérarchique qui comprend des répertoires et des fichiers. Le répertoire supérieur est appelé répertoire racine, représenté par une barre oblique /
Répertoire : C'est un fichier contenant. entrées du répertoire. Chaque entrée du répertoire contient le nom du fichier
Nom du fichier : le contenu du répertoire est appelé une entrée du répertoire, et l'entrée du répertoire contient Dans les noms de fichiers, seuls deux caractères ne sont pas autorisé à apparaître dans les noms de fichiers : barre oblique et caractère nul (la valeur ASCII est 0). La barre oblique est utilisée pour séparer les noms de fichiers dans le chemin, et le caractère nul est utilisé pour indiquer la fin du chemin. La longueur du nom de fichier peut généralement atteindre 255 caractères.
Chemin : Une série de noms de fichiers reliés entre eux et séparés par des barres obliques est appelée un chemin. Le chemin est utilisé pour indiquer l'emplacement de. le fichier ; Le chemin commençant par un tiret est appelé chemin absolu, sinon c'est un chemin relatif. Un chemin relatif est relatif au répertoire de travail actuel
.
Code retour : toutes les commandes ont une valeur de retour, représentée par un entier compris entre 0 et 255 ; un script est une commande, et il a également une valeur de retour. De plus, les fonctions du script ont également un retour. valeurs
La manière formelle de quitter un script est d'utiliser explicitement la commande exit [code] pour quitter, telle que : exit 0; exit $?
2. read
1. Définition
read est une commande intégrée, qui complète principalement l'affectation des paramètres, similaire à scanf en C. langue;
autre Non seulement des variables peuvent être attribuées, mais des tableaux peuvent également être attribués
L'entrée n'est pas seulement l'écran, mais aussi le descripteur de fichier
2. Opération pratique
# read a --Saisissez une chaîne et attribuez la chaîne à la variable a; # echo $a
bonjour tout le monde !!
# lire le nom sexe âge --Attribuer trois variables en même temps Affectation, le séparateur d'entrée est par défaut le caractère espace
zhangsan mâle 50
# non défini nom sexe âge --supprimer la variable
# IFS=';' --lirea Changez le séparateur d'entrée en ';'
# vim test.sh
#!/bin/bash
prompt="Veuillez entrer votre nom :"
read -p "$prompt" name
echo "Greetings $name"
3. Outils informatiques
1. Opérations mathématiques simples
# echo $((1+2**2-3*4/5% 6)) --Afficher les résultats du calcul à l'écran
# a=$((1+2**2-3*4/5%6)) --Attribuer le résultat du calcul à la variable a
# ((a=1+2**2- 3*4/5%6)) --Identique à ci-dessus
# echo "scale=3;10/3" | bc --bc calculator; conserver trois décimales
# echo "2^10" | bc --bc calculator; calculer 2 élevé à la puissance 10
# awk 'BEGIN{print 1 /3}' --awk calculate
2 , Obtenez un nombre aléatoire
# od -N4 -tu4 /dev/urandom | * //p' --Obtenir un numéro à 7 chiffres
# od -Ad -w24 -tu4 /dev/urandom --Obtenir un numéro aléatoire
# od -tu8 /dev/urandom --Obtenir un numéro aléatoire
# od -tu8 /dev/urandom | sed -r 's/^[0-9]+s+//' | -r -n '/^.{8}$/p' | sed 's/^/186/' |head -n5000 |vi - --Obtenir dix mille numéros de téléphone
# od -N40000 - tu4 /dev/urandom | sed -r 's/^[0-9]+(s+)?//' | sed -r 's/s+/n/g' | ; 10k_random -- Générer 10 000 nombres aléatoires
# sed -r -n '/^.{8}$/p' 10k_random |
3. Obtenez la séquence de nombres
# seq 10 --obtenez 1 à 10
# seq 1 2 10 --obtenez 1 à 10 , la taille du pas est de 2
# seq 10 100 --Obtenez 10 à 100
# seq 10 -1 1 --Dans l'ordre inverse, 10 à 1
4. Exemples si/alors
1. Déterminez si le caractère "a" est égal à "A"
. # test vim. sh
#!/bin/bash
if [[ "a" = "A" ]]; 🎜>if [ "a" = "A" ]; then
echo "a est égal à A"else
echo "a non est égal à A"
fi
2. Déterminez si /root/test/test.sh existe et dispose d'autorisations exécutables
# vim test.sh# !/bin/bash
if test -x /root/test/test.sh;then
echo "/root/test/test.sh est exécutable"
fi
3. Déterminez s'il y a un utilisateur root dans le système
# vim test. sh #!/bin/bash
if grep -E --color=auto ^root: /etc/passwd then
echo; "l'utilisateur root existe"fi
4. Déterminez le type de fichier
# vim test.sh#!/ bin/bash
fonction isSymbolicLink() {
file=$1
flag=$(ls -ld $file | cut -b1)
test "$flag" = "1"
return $?
}
file=$1
if isSymbolicLink $file; puis
echo "Lien symbolique"
elif test -d $file; then
echo "Fichier répertoire"
elif test -f $file; then
echo "Fichier régulier"
elif test -b $file; then
echo "Bloc spécial"
elif test -c $file; then
echo "Caractère spécial"
elif test -p $file; then
echo "Named pipe"
elif test -S $file; puis
écho "Socket"
autre
écho "Inconnu"
fi
5、判断输入数字的大小
# vim test.sh
#!/bin/bash
num=$1
if test "$num" -lt 10 ;puis
echo "小数字"
elif test "$num" -lt 20;puis
echo "中数字"
elif test "$num" -lt 30;then
echo "大数字"
else
echo "超大数字"
fi
6. 🎜> echo -n "Entrez un nombre : "
lire num
if [ "$num" -lt 100 ]; then
echo "moins de 100"
elif [ "$num" -ge 100 -a "$num" -lt 200 ]; then
echo "supérieur ou égal à 100 et inférieur à 200"
elif [ "$num" -ge 200 -a "$num" -lt 300 ];
echo "Supérieur ou égal à 200 et inférieur à 300"
else
echo "Autres nombres"
fi
Cinq. boucle wihle
1. Comprendre
Testez le code de retour d'une commande après le mot-clé while When. la condition est vraie, le programme lit la directive du corps de la boucle while 0 est vrai. Le corps de la boucle est le suivant :
while [] --while puis exécutez la commande [ ] et testez le code retour de la commande [ ]
cat /filename | while read line --While, exécutez la commande read plus tard et testez le code de retour de la commande read
do
......
terminé
2. Instruction de contrôle de boucle
continue --termine la boucle actuelle et démarre la suivante
pause - -terminer la boucle actuelle et quitter le corps de la boucle
exit -- Terminer le script actuel
Exemple
# vim test.sh --Distinguer la différence entre continuer et pause
#!/bin/bash
while true
faire
dormir 1
test d'écho
continue/pause
écho
fait
# vim test.sh --Distinguer la différence entre break et exit
#!/bin/bash
while test -e /data/test/test.sh
do
écho "existe"
sommeil 1
pause/sortie
terminé
écho "fin de boucle"
# vim test.sh --Recherchez le chemin que nous avons donné jusqu'à ce que nous le trouvions
#!/bin/bash
if test $# - ne 1;puis
echo "mauvais paramètre" >&2
sortie
fi
path=$1
pendant le test ! -e "$path"
faire
dormir 1
echo "pas trouvé !!!"
fait
echo "found"
# vim test.sh --Le script s'exécute pendant le temps spécifié et se termine lorsque le temps est écoulé ; /bin/ bash
if test $# -ne 1;then
echo "Usage: $(basename $0) TIME" >&2
exit 1
fi
timeLength=$1
beginTime=$(date +%s)
endTime=$(( $beginTime + $timeLength ))
- ----------------------------------------------- --- ------
while test $(date +%s) -lt "$endTime"
do
echo "processing.... ."
dormir 1
terminé
--------------------------- ----- ----------------
tout en étant vrai
faire
if test $(date +%s) -ge "$endTime";then
break
fi
echo "processing...."
dormir 1
terminé
-------------------------------------------------------------- --- ----------
echo "time out"
# vim test.sh --Boucle pour lire chaque ligne du fichier et calculer la valeur de chaque ligne Nombre de caractères
#!/bin/bash
file=$1
------------ ----- -----------------------------------------
totalLines=$( wc -l < $file)
line=1
while test $line -le $totalLines
do
lineData =$(sed - n "${line}p" $file)
len=$(echo -n $lineData | wc -c)
echo "line ${line} : $len"
line=$(( $line + 1 ))
terminé
----------------- ---- ----------------------------------
line=1
pendant la lecture de lineData
do
len=$(echo $lineData | wc -c)
echo "line ${line} : $len "
line=$(( $line + 1 ))
done < $file
------ --- ----------------------------------------
# vim test.sh -- imprimer 10 lignes de hello world; <(seq 10) équivaut à un chemin de fichier appelé remplacement de processus
#!/ bin/bash
pendant la lecture du numéro
faire
écho "bonjour tout le monde"
fait < <(seq 10)
------------------------------------------------ ----------------
n=1
pendant que [ $n -le 10 ]
faire
faire écho à "bonjour tout le monde"
n=$((n+1))
fait
-------- -- ------------------------------------------------ --
# vim test.sh --Créer une boucle sans fin, exigeant que la boucle se termine automatiquement après 1 minute d'exécution
#!/bin/bash
start_time =$(date +%s)
while true
do
cur_time=$(date +%s)
test $((cur_time - start_time)) -ge 10 && break
time=$((cur_time - start_time))
echo "le temps est $time..."
sommeil 1
done
# vim test.sh --Utilisez d'abord une boucle while pour créer 100 fichiers .txt ; puis modifiez le suffixe de tous les fichiers en .html
#!/bin/bash
count=100
--------------------- ----- ---------------------------
seq $count | pendant la lecture de i
do
touchez ${i}.txt
done
ls -1 *.txt pendant la lecture de l'ancien nom
do
newname=$(echo $oldname | sed 's/.txt$/.html/')
mv $oldname $newname
done
-------------------------------------------------------------- - ---------------
pendant la lecture, je
faire
toucher ${i}.txt
done < <( seq $count )
pendant la lecture de oldname
do
newname=$(echo $oldname | sed 's / .txt$/.html/')
mv $oldname $newname
done < <(ls -1 *.txt )
# vim test.sh --Calculez la somme des nombres pairs dans les 1000 ; les tuyaux ne peuvent pas être utilisés car les tuyaux généreront des sous-processus
#!/bin/bash
sum=0
pendant que lire num
do
sum=$(( $sum + $num ))
done < <(seq 2 2 998)
echo "somme : $sum"
# vim test.sh --Ajoutez 100 utilisateurs de messagerie par lots, les noms d'utilisateur sont u1 à u100, le mot de passe est abc, le shell de connexion est /sbin/nologin, appartient uniquement au groupe de messagerie
#!/bin/bash
password=abc
group=email
grep -Eq "^${group}:" /etc/group || groupadd $group
pendant que je lis
do
useradd u${i} -N -g $group -s /sbin/nologin
passwd u${ i} --stdin <<< "$password"
done < <(seq 100)
# vim test.sh - - La suppression par lots vient de créer 100 utilisateurs de messagerie
#!/bin/bash
pendant que je lis je
do
userdel -r u${ i>
done< Dans la chaîne, prenez-en une dans l'ordre. Lorsqu'elle est terminée, la boucle se termine
La chaîne retirée à chaque fois sera enregistrée dans une variable, qui peut. être utilisé dans le corps de la boucle
Les chaînes séparées par des délimiteurs peuvent être fournies via les méthodes suivantes :
1 Entrez manuellement la chaîne pour boucler un nombre de fois spécifié
<. 🎜>
# vim test .sh
#!/bin/bash
pour moi en 1 2 3
faire
echo $i
don
2. Fournir une chaîne par variable
# vim test.sh
#! /bin/bash
FILES="/bin/bash /bin/ls /bin/cat"
pour le fichier dans $FILES
do
écho $fichier
done
3. Chaîne générée par le programme
# vim test.sh
#!/bin/bash
pour n dans $(seq 11)
do
echo $n
done
4. Généré par l'expansion du shell, bouclage des fichiers dans le répertoire
# vim test.sh
#!/bin/bash
pour f in / etc /init.d/*
do
echo $f
done
# vim test.sh
5. Imprimez les noms de fichiers de tous les fichiers commençant par loop sous /dev
# vim test.sh
#!/bin/bash
pour le fichier dans /dev/loop*
do
echo $(basename $file)
done
6. Calculer 1000 La somme. de nombres pairs dans
# vim test.sh
#!/bin/bash
sum=0
pour le nombre en $( seq 2 2 998)
do
sum=$(( $sum + $number ))
done
echo "total : $ sum"
7. Ajoutez 100 utilisateurs de messagerie par lots. Les noms d'utilisateur sont u1 à u10, le mot de passe est abc, le shell de connexion est /sbin/nologin et ils appartiennent uniquement au groupe de messagerie <🎜. >
# vim test.sh
#!/bin/bash
function checkGid() {
gid=$1
if ! grep -qE "^$gid:" /etc/group; then
groupadd $gid
fi
}
function isRoot() {
id=$(id | awk -F "[=(]" '{print $2}')
if test "$id" -ne 0; then
echo " doit être root" >&2
exit 1
fi
}
count=10
namePrefix=u
password=abc
shell=/sbin/nologin
gid=email
isRoot
checkGid $gid
pour num dans $(seq $count)
do
name=${namePrefix}${num}
useradd $name -s $shell -g $gid &> /dev/null
if test $? -ne 0; then
echo "échec de la création de $name" >&2
else
echo "créé avec succès -- $name"
echo "$password" | passwd --stdin $name &> /dev/null
if test $ -ne 0;
echo "échec de la modification du mot de passe pour $name" >&2
else
echo "mot de passe modifié avec succès -- $name"
fi
fi
fait
8、获取局域网内所有电脑的IP 和MAC 地址的对应表
# vim test.sh
#!/bin/bash
ipPrefix=192.168.1.
startIp=1
endIp=254
pour num en $ (seq $startIp $endIp)
do
ip=${ipPrefix}$num
ping -W1 -c1 $ip &>/dev/null &
terminé
attendre
arp -n sed '/incomplete/d' | awk '{print $1,$3}'| chat | trier -n -t '.' -k4,4 | colonne -t
9. Imprimez la table de multiplication
# vim test.sh
#!/bin/bash
pour la ligne en $ ( seq 9)
do
pour col dans $(seq $row)
do
echo -n "${col}x${ row }=$(( $col * $row )) "
fait
echo
fait | colonne -t
10, simple calculatrice
#!/bin/bash
varnum=3
if test "$#" -ne "$varnum" alors
echo "mauvais argument" >&2
sortie 1
fi
num1=$1
num2=$3
opérateur= $2
si test "$operator" = "x";then
operator="*"
fi
si test "$operator " = "/" -a "$num2" = 0; puis
echo "division par 0" >& 2
sortie 1
fi
result=$(( $num1 $operator $num2 ))
echo "$result"
Remarque : traitement de la multiplication lorsque le dividende est 0
11. Copiez certains fichiers du répertoire spécifié dans le répertoire spécifié. Exigences :
#1 Recevez deux paramètres des paramètres de ligne de commande, à savoir le répertoire source et le répertoire cible.
#2. Si le répertoire source n'existe pas, une erreur doit être signalée
#3 Si le répertoire cible n'existe pas, créez-en un
#4. Si Si la cible existe déjà mais n'est pas un répertoire, une erreur sera signalée
#5. Copiez uniquement les fichiers normaux et les fichiers de liens symboliques
#6 Pour les fichiers normaux, uniquement les fichiers moins. une taille supérieure à 1 M sera copiée
# vim /test.sh
#!/bin/bash
fonction displayHelp()
{
echo "Utilisation : $(basename $0) SRCDIR DSTDIR"
}
fonction getSize()
{
file=$1
size=$(ls -l $file | awk '{print $5}')
echo $size
}
if test $# -ne 2; puis
displayHelp >&2
sortie 1
fi
srcdir=$1
dstdir=$2
si test ! -d "$srcdir"; then
echo "$srcdir n'existe pas ou n'est pas un répertoire" >&2
exit 1
fi
if test ! -e "$dstdir"; alors
mkdir "$dstdir"
fi
if test ! -d "$dstdir"; then
echo "$dstdir n'est pas un répertoire" >&2
exit 1
fi
pour le fichier dans $srcdir/*
faire
if test -L $file; alors
cp -a $file $dstdir/
elif test -f $file; alors
--------------------------------------------------------- --------
size=$(getSize $file)
if test "$size" -lt 1048576; alors
cp -a $file $dstdir/
fi
---------------------- -----------------------------
trouver $file -type f -size -1024k -exec cp -a {} $dstdir/ ;
-------------------------------------- -------------
fi
fait
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment intercepter des chaînes dans le shell
Quelle est la priorité de l'interruption ?
Résumé du plug-in du navigateur Firefox
fenêtre.invite
Pourquoi ne puis-je pas supprimer la dernière page vierge de Word ?
ps quitter la touche de raccourci plein écran
qu'est-ce que le serveur
Introduction au contenu technologique de base Java
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
