Was ist eine Muschel? Einführung in gängige Muscheltypen

1. Einführung

2. Computer-Tools

🎜>4. if/then-Struktur

5. while-Schleife

6 🎜>1. Einführung

1. Was ist Shell

Shell ist die Schnittstelle, über die Benutzer mit dem System interagieren können. Die Shell ist ein Befehlsinterpreter und eine höhere Programmiersprache

2. Gängige Arten von Shells

Bourne Shell (/usr/bin/sh oder /bin/). sh)

Bourne Again Shell (/bin/bash)

C Shell (/usr/bin/csh)

K Shell (/usr/bin/ksh)

Shell für Root (/sbin/sh)

Unter ihnen: Bash wird häufig in der täglichen Arbeit verwendet

Gleichzeitig ist Bash für die meisten auch die Standard-Shell Linux-Systeme ;

3. Shell-Einschränkungen

1.1 Aufgaben, die viele Ressourcen erfordern, insbesondere solche, die eine hohe Ausführungsgeschwindigkeit erfordern1.2. Mit vielen mathematischen Berechnungen

1.3. Wichtige Anwendungen (Datenbanken, Websites usw.)

1.4. Anwendungen zum Entwerfen von Grafiken oder GUI

1.5. Benötigen Sie direkten Zugriff auf Hardware

Entwickeln Sie Closed-Source-Anwendungen (im Vergleich zu Open Source)

Datei System: Das Linux-Dateisystem ist eine hierarchische Organisationsstruktur, die Verzeichnisse und Dateien umfasst. Das oberste Verzeichnis wird als Stammverzeichnis bezeichnet und durch einen Schrägstrich /

Verzeichnis: Es handelt sich um eine Datei, die Folgendes enthält Verzeichniseinträge. Jeder Verzeichniseintrag enthält den Dateinamen

Dateiname: Der Inhalt des Verzeichnisses wird als Verzeichniseintrag bezeichnet, und der Verzeichniseintrag enthält in Dateinamen nur zwei Zeichen dürfen in Dateinamen vorkommen: Schrägstrich und Nullzeichen (ASCII-Wert ist 0, um Dateinamen im Pfad zu trennen, und Nullzeichen werden verwendet, um das Ende des Pfads anzuzeigen). Die Länge des Dateinamens kann normalerweise 255 Zeichen erreichen.

Pfad: Eine Reihe von Dateinamen, die miteinander verbunden und durch Schrägstriche getrennt sind, wird als Pfad bezeichnet. Der Pfad wird verwendet, um den Speicherort anzugeben die Datei; Der Pfad, der mit einem Bindestrich beginnt, wird als absoluter Pfad bezeichnet, andernfalls ist er ein relativer Pfad. Ein relativer Pfad ist relativ zum aktuellen Arbeitsverzeichnis

Rückgabecode: Alle Befehle haben einen Rückgabewert, der durch eine Ganzzahl zwischen 0 und 255 dargestellt wird. Ein Skript ist ein Befehl, und außerdem haben die Funktionen im Skript auch einen Rückgabewert Werte

Der formale Weg, ein Skript zu beenden, besteht darin, explizit den Befehl „exit [code]“ zum Beenden zu verwenden, wie zum Beispiel: exit 0; exit $?

2. read

1. Definition

read ist ein Build-Befehl, der hauptsächlich die Zuweisung von Parametern ausführt, ähnlich wie scanf in C Sprache;

andere Es können nicht nur Variablen, sondern auch Arrays zugewiesen werden

Die Eingabe ist nicht nur der Bildschirm, sondern auch der Dateideskriptor

2. Praktische Bedienung

# read a --Geben Sie eine Zeichenfolge ein und weisen Sie die Zeichenfolge der Variablen a zu; # echo $a

Hallo Welt!!

# Name Geschlecht Alter lesen --Weisen Sie drei Variablen gleichzeitig zu Zuweisung, das Eingabetrennzeichen ist standardmäßig das Leerzeichen

zhangsan männlich 50

# Name Geschlecht Alter nicht gesetzt --Variable löschen

# IFS=';' --wird angezeigt. Ändern Sie das Eingabetrennzeichen in ';'

# vim test.sh

#!/bin/bash

prompt="Bitte geben Sie Ihren Namen ein:"

read -p "$prompt" name

echo "Greetings $name"

3. Rechenwerkzeuge

1. Einfache mathematische Operationen

# echo $((1+2**2-3*4/5% 6)) --Geben Sie die Berechnungsergebnisse auf dem Bildschirm aus

# a=$((1+2**2-3*4/5%6)) --Weisen Sie das Berechnungsergebnis der Variablen a zu

# ((a=1+2**2- 3*4/5%6)) – Wie oben

# echo "scale=3;10/3" | bc --bc Rechner; drei Dezimalstellen behalten

# echo "2^10" |. bc --bc Rechner; berechne 2 hoch 10

# awk 'BEGIN{print 1 /3}' --awk berechne

2 , Erhalte eine Zufallszahl

# od -N4 -tu4 /dev/urandom |. * //p' --Erhalte eine 7-stellige Zahl

# od -Ad -w24 -tu4 /dev/urandom --Erhalte eine Zufallszahl

# od -tu8 /dev/urandom --Zufallszahl abrufen

# od -tu8 /dev/urandom |. sed -r 's/^[0-9]+s+//' |cut -b1-8 |sed -r -n '/^.{8}$/p' |. sed 's/^/186/' |head -n5000 |vi - --Erhalten Sie zehntausend Telefonnummern

# od -N40000 - tu4 /dev/urandom |. sed -r 's/^[0-9]+(s+)?//' |. sed -r 's/s+/n/g' | ; 10k_random – Erzeuge 10.000 Zufallszahlen

# sed -r -n '/^.{8}$/p' 10k_random |. sed 's/^/186/' >

3. Holen Sie sich die Zahlenfolge

# seq 10 – erhalten Sie 1 bis 10

# seq 1 2 10 – erhalten Sie 1 bis 10 , die Schrittgröße beträgt 2

# seq 10 100 --Erhalte 10 bis 100

# seq 10 -1 1 --In umgekehrter Reihenfolge, 10 bis 1

4. Wenn/Dann-Beispiele

1. Bestimmen Sie, ob das Zeichen „a“ gleich „A“ ist

# vim test. sh

#!/bin/bash

if [[ "a" = "A" ]] then

if [ „a“ = „A“ ]; then

echo „a equal A“

else

echo „a no equal A“

fi

2. Bestimmen Sie, ob /root/test/test.sh vorhanden ist und über ausführbare Berechtigungen verfügt

# vim test.sh

# !/bin/bash

if test -x /root/test/test.sh;then

echo "/root/test/test.sh ist ausführbar“

fi

3. Bestimmen Sie, ob es einen Root-Benutzer im System gibt

# vim test. sh

#!/bin/bash

if grep -E --color=auto ^root: /etc/passwd; then

echo „Benutzer root existiert“

fi

4. Bestimmen Sie den Dateityp

# vim test.sh

#!/ bin/bash

Funktion isSymbolicLink() {

　　file=$1

　　flag=$(ls -ld $file | cut -b1)

　　test "$flag" = "1"

　　return $?

}

file=$1

if isSymbolicLink $file; then

　　echo "Symbolic Link"

elif test -d $file; then

　　echo "Verzeichnisdatei"

elif test -f $file; then

　　echo „Regular file“

elif test -b $file; then

　　echo „Block special“

elif test -c $file; then

　　echo „Character special“

elif test -p $file; then

　　echo "Named Pipe"

elif test -S $file; then

　　echo „Socket“

else

　　echo „Unkown“

fi

5、判断输入数字的大小

# vim test.sh

#!/bin/bash

num=$1

if test "$num" -lt 10 ;then

　　echo "小数字"

elif test "$num" -lt 20;then

　　echo "中数字"

elif test "$num" -lt 30;then

　　echo "大数字"

else

　　echo "超大数字"

fi

6、从标准输入获取一个数字，并根据其大小输出指定字符串

# vim.test.sh

#!/bin/bash

echo -n "Geben Sie eine Zahl ein: "

Num lesen

if [ "$num" -lt 100 ]; then

echo "weniger als 100"

elif [ "$num" -ge 100 -a "$num" -lt 200 ]; dann

echo „größer oder gleich 100 und kleiner als 200“

elif [ „$num“ -ge 200 -a „$num“ -lt 300 ];

echo „Größer als oder gleich 200 und kleiner als 300“

else

echo „Andere Zahlen“

fi

Fünf. Wihle-Schleife

1. Verstehen Sie

Testen Sie den Rückgabecode eines Befehls nach dem Schlüsselwort while die Bedingung ist wahr, das Programm liest in die while-Schleifenkörper-Anweisung; 0 ist wahr. Der Schleifenkörper lautet wie folgt:

while [] --while führen Sie dann den Befehl [ ] aus und testen Sie den Rückkehrcode des Befehls [ ]

cat /filename |. while read line　　　 --While, führen Sie den Lesebefehl später aus und testen Sie den Rückgabecode des Lesebefehls

do

......

Fertig

2. Schleifenkontrollanweisung

Weiter – Beende die aktuelle Schleife und starte die nächste

Pause – -Beenden Sie die aktuelle Schleife und verlassen Sie den Schleifenkörper

exit – Beenden Sie das aktuelle Skript

3. Beispiel

# vim test.sh --Unterscheiden Sie den Unterschied zwischen continue und break

#!/bin/bash

while true

do

sleep 1

Echo-Test

Weiter/Pause

Echo

fertig

# vim test.sh --Unterscheiden Sie den Unterschied zwischen Pause und Exit

#!/bin/bash

while test -e /data/test/test.sh

do

Echo „existiert“

Schlaf 1

Pause/Beenden

fertig

Echo „Schleifenende“

# vim test.sh --Suchen Sie nach dem Pfad, den wir angegeben haben, bis wir ihn finden

#!/bin/bash

if test $# - ne 1;then

echo "wrong paraneter" >&2

exit

fi

path=$1

while test ! -e „$path“

do

sleep 1

echo „nicht gefunden!!!“

fertig

echo "found"

# vim test.sh --Das Skript wird für die angegebene Zeit ausgeführt und beendet, wenn die Zeit abgelaufen ist.

#! /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.... "

1 schlafen

fertig

---------------------------- ---- -----------

während wahr

tun

if test $(date +%s) -ge "$endTime";then

break

fi

echo "processing...."

1 schlafen

fertig

--------------------------------- --- ----------

echo "time out"

# vim test.sh --Schleife, um jede Zeile der Datei zu lesen und zu berechnen der Wert jeder Zeile Anzahl der Zeichen

#!/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 ))

fertig

----------------- ---- --------------------

Zeile=1

while read lineData

do

len=$(echo $lineData | wc -c)

echo "line ${line} : $len "

line=$(( $line + 1 ))

fertig < $file

------ --- --------------------------

# vim test.sh -- 10 Zeilen von „hello world“ ausdrucken; >while read num

do

echo „Hallo Welt“

fertig < <(seq 10)

------------------------------------------------ -n=1

while [ $n -le 10 ]

mache echo „Hallo Welt“

n=$((n+1))

fertig

-------- -------------------------------------------------- --

# vim test.sh – Erstellt eine Endlosschleife, sodass die Schleife automatisch beendet wird, nachdem sie 1 Minute lang ausgeführt wurde

#!/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 „time is $time…“

sleep 1

fertig

# vim test.sh --Erstellen Sie zunächst 100 TXT-Dateien mit einer While-Schleife. Ändern Sie dann das Suffix aller Dateien in .html

#!/bin/bash

count=100

--------------------- ----- --------------------------

seq $count | während ich gelesen habe

do

touch ${i}.txt

done

ls -1 *.txt |. while read oldname

do

newname=$(echo $oldname | sed 's/.txt$/.html/')

mv $oldname $newname

done

--------------------------------- - ---------------

während des Lesens

berühre ich

${i}.txt

done < <( seq $count )

while read oldname

do

newname=$(echo $oldname | sed 's / .txt$/.html/')

mv $oldname $newname

fertig < <(ls -1 *.txt )

# vim test.sh --Berechnen Sie die Summe gerader Zahlen innerhalb von 1000; Pipes können nicht verwendet werden, da Pipes Unterprozesse generieren

#!/bin/bash

sum=0

while read num

do

sum=$(( $sum + $num ))

done < <(seq 2 2 998)

echo "sum: $sum "

# vim test.sh --Fügen Sie 100 E-Mail-Benutzer in Stapeln hinzu, die Benutzernamen sind u1 bis u100, das Passwort ist abc, die Login-Shell ist /sbin/nologin, gehört nur zur E-Mail-Gruppe

#!/bin/bash

password=abc

group=email

grep -Eq "^${group}:" /etc/group ||. groupadd $group

while read i

do

useradd u${i} -N -g $group -s /sbin/nologin

passwd u${ i} --stdin <<< "$password"

done < <(seq 100)

# vim test.sh - - Batch-Löschen hat gerade 100 E-Mail-Benutzer erstellt

#!/bin/bash

while read i

do

userdel -r u${ i}

Fertig< Nehmen Sie in der Zeichenfolge eine davon. Wenn sie fertig ist, endet die Schleife.

Die jeweils herausgenommene Zeichenfolge wird in einer Variablen gespeichert im Schleifenkörper verwendet werden

Durch Trennzeichen getrennte Zeichenfolgen können mit den folgenden Methoden bereitgestellt werden:

1 Geben Sie die Zeichenfolge für die angegebene Anzahl von Schleifen manuell ein

# vim test .sh

#!/bin/bash

for i in 1 2 3

do

echo $i

don

2. Geben Sie eine Zeichenfolge nach Variable an

# vim test.sh

#! /bin/bash

FILES="/bin/bash /bin/ls /bin/cat"

für Datei in $FILES

do

echo $file

fertig

3. Vom Programm generierte Zeichenfolge

# vim test.sh

#!/bin/bash

for n in $(seq 11)

do

echo $n

done

4. Erzeugt durch Shell-Erweiterung, Schleife von Dateien im Verzeichnis

# vim test.sh

#!/bin/bash

für f in / etc /init.d/*

tun

echo $f

fertig

# vim test.sh

5. Drucken Sie die Dateinamen aller Dateien aus, die mit „loop“ beginnen, unter /dev

# vim test.sh

#!/bin/bash

für Datei in /dev/loop*

do

echo $(basename $file)

fertig

6. Berechnen Sie 1000. Die Summe von geraden Zahlen innerhalb von

# vim test.sh

#!/bin/bash

sum=0

für Zahl in $( seq 2 2 998)

do

　sum=$(( $sum + $number ))

done

echo "total: $ sum"

7. Fügen Sie stapelweise 100 E-Mail-Benutzer hinzu, das Passwort ist abc, die Login-Shell ist /sbin/nologin und sie gehören nur zur E-Mail-Gruppe

# 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 " muss root sein" >&2

exit 1

fi

}

count=10

namePrefix=u

password=abc

shell=/sbin/nologin

gid=email

isRoot

checkGid $gid

für num in $(seq $count)

do

name=${namePrefix}${num}

useradd $name -s $shell -g $gid &> /dev/null

if test $? -ne 0 then

echo "failed to create $name" >&2

else

echo „erfolgreich erstellt – $name“

echo „$password“ |

echo „Passwort für $name konnte nicht geändert werden“ >&2

else

echo „Passwort erfolgreich geändert – $name“

fi

fi

fertig

8、获取局域网内所有电脑的IP 和MAC 地址的对应表

# vim test.sh

#!/bin/bash

ipPrefix=192.168.1.

startIp=1

endIp=254

für num in $ (seq $startIp $endIp)

do

ip=${ipPrefix}$num

ping -W1 -c1 $ip &>/dev/null &

fertig

warte

arp -n sed '/incomplete/d' | awk '{print $1,$3}'| Katze | sort -n -t '.' -k4,4 | Spalte -t

9. Drucken Sie die Multiplikationstabelle aus

# vim test.sh

#!/bin/bash

für Zeile in $ ( seq 9)

do

for col in $(seq $row)

do

echo -n "${col}x${ row }=$(( $col * $row )) "

fertig

echo

fertig | Spalte -t

10, Einfach Rechner

#!/bin/bash

varnum=3

if test "$#" -ne "$varnum"

echo „falsches Argument“ >&2

exit 1

fi

num1=$1

num2=$3

Operator= $2

if test „$operator“ = „x“;then

operator="*"

fi

if test „$operator“ = "/" -a "$num2" = 0; then

echo "division by 0" >& 2

exit 1

fi

result=$(( $num1 $operator $num2 ))

echo "$result"

Hinweis: Verarbeitung der Multiplikation; Verarbeitung, wenn der Dividend 0 ist

11. Bestimmte Dateien im angegebenen Verzeichnis in das angegebene Verzeichnis kopieren:

#1. Erhalten Sie zwei Parameter aus den Befehlszeilenparametern, nämlich Quellverzeichnis und Zielverzeichnis

#2. Wenn das Quellverzeichnis nicht existiert, sollte ein Fehler gemeldet werden

#3 Wenn das Zielverzeichnis nicht existiert, erstellen Sie eines

#4. Wenn das Ziel bereits existiert, aber kein Verzeichnis ist, wird ein Fehler gemeldet

#5 Nur reguläre Dateien und Softlink-Dateien kopieren

#6. Bei regulären Dateien nur Dateien weniger größer als 1 M werden kopiert

# vim /test.sh

#!/bin/bash

Funktion displayHelp()

{

echo „Verwendung: $(basename $0) SRCDIR DSTDIR“

}

Funktion getSize()

{

file=$1

size=$(ls -l $file | awk '{print $5}')

echo $size

}

if test $# -ne 2; dann

displayHelp >&2

exit 1

fi

srcdir=$1

dstdir=$2

wenn test! -d "$srcdir"; dann

echo „$srcdir existiert nicht oder ist kein Verzeichnis“ >&2

exit 1

fi

if test ! -e "$dstdir"; then

mkdir "$dstdir"

fi

if test ! -d "$dstdir"; dann

echo „$dstdir ist kein Verzeichnis“ >&2

exit 1

fi

für Datei in $srcdir/*

tun

if test -L $file; then

cp -a $file $dstdir/

elif test -f $file; dann

---------------------------- --------

size=$(getSize $file)

if test "$size" -lt 1048576; dann

cp -a $file $dstdir/

fi

---------------------- -----------------------------

find $file -type f -size -1024k -exec cp -a {} $dstdir/ ;

-------------------------------------- -------------

fi

fertig

Das obige ist der detaillierte Inhalt vonWas ist eine Muschel? Einführung in gängige Muscheltypen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!