Qu'est-ce qu'une coquille ? Introduction aux types courants de coquilles

1. Introduction

2. lire

3. 🎜>4. structure if/then

5. boucle while

6. 🎜>

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

Bourne Shell (/usr/bin/sh ou /bin/ sh)

Bourne Again Shell (/bin/bash)

C Shell (/usr/bin/csh) K Shell (/usr/bin/ksh )

Shell pour Root (/sbin/sh)

Parmi eux : Bash est largement utilisé dans le travail quotidien

En même temps, Bash est également le Shell par défaut pour la plupart ; Systèmes Linux ;

3. Limitations du Shell

1.1. Tâches qui nécessitent beaucoup de ressources, notamment celles qui nécessitent une vitesse d'exécution élevée1.2. Impliquant de nombreux calculs mathématiques

1.3. Applications clés (bases de données, sites Web, etc.)

1.4. Applications de conception graphique ou GUI

1.5. Besoin d'un accès direct au matériel

1.6. Développer des applications fermées (par rapport à l'open source)

Bases

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!

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Linux - Introduction d'une instance d'attaque par inondation ICMPArticle suivant：Linux - Introduction d'une instance d'attaque par inondation ICMP

Articles Liés

Voir plus

• Apprenez à installer le serveur Nginx sous Linux
• Introduction détaillée à la commande wget de Linux
• Explication détaillée d'exemples d'utilisation de yum pour installer Nginx sous Linux
• Explication détaillée des problèmes de connexions des travailleurs dans Nginx
• Explication détaillée du processus d'installation de python3 sous Linux