zshmisc(1)

zshmisc(1)

NAMN

zshmisc – allt och lite till

ENKLA KOMMANDON & RÖRLEDNINGAR

Ett enkelt kommando är en sekvens av valfria parameter­tildelningar följt av blankseparerade ord, med valfria omdirigeringar insprängda. Det första ordet är kommandot som ska köras, och återstående ord, om några, är argument till kommandot. Om ett kommandonamn anges påverkar parameter­tildelningarna kommandots miljö när det körs. Värdet (returkoden) för ett enkelt kommando är dess avslutsstatus, eller 128 plus signalnumret om det avbryts av en signal.

Exempel:

echo foo

när echo är ett enkelt kommando med argument.

En rörledning (pipeline) är antingen ett enkelt kommando, eller en sekvens av två eller fler enkla kommandon där varje kommando separeras från nästa med | eller |&.

• Med | kopplas standard ut från föregående kommando till standard in på nästa.
• |& är en förkortning av 2>&1 |, vilket kopplar både standard ut och standard fel till standard in på nästa kommando.

Returvärdet för en pipeline är värdet från det sista kommandot, såvida inte pipelinen föregås av ! – då inverteras det sista kommandots sanningsvärde.

Exempel:

echo foo | sed 's/foo/bar/'

när utdata (foo + nyrad) från första kommandot skickas till det andra.

Om en pipeline föregås av coproc körs den som en medprocess (coprocess); en tvåvägspipe upprättas mellan den och förälderskalet. Skal kan läsa/skriva via omdirigerarna >&p och <&p eller kommandona print -p och read -p. En pipeline kan inte föregås av både coproc och !. Med jobbkontroll aktiv kan medprocessen behandlas som ett vanligt bakgrundsjobb vad gäller input/output.

En sublista är antingen en enskild pipeline, eller en sekvens av två eller fler pipelines separerade av && eller ||. Med && körs den andra pipelinen bara om den första lyckas (retur 0). Med || körs den andra bara om den första misslyckas (retur ≠ 0). Båda operatorerna har samma prioritetsnivå och är vänsterassociativa. Returvärdet för sublistan är värdet från den sista pipeline som kördes.

Exempel:

dmesg | grep panic && print yes

Här körs det andra kommandot endast om grep returnerar 0.

En lista är en sekvens av noll eller fler sublistor där varje sublista avslutas med ;, &, &|, &! eller nyrad. Terminatorn kan utelämnas för den sista sublistan inuti (...) eller {...}. Med ; eller nyrad väntar skalet på att sublistan avslutas. Med &, &| eller &! körs sista pipelinen i bakgrunden och skalet väntar inte (till skillnad från vissa andra skal). En bakgrundad pipeline returnerar 0.

Generellt kan en lista ses som ett godtyckligt set av skalkommandon, inklusive komplexa kommandon nedan.

FÖRKOMMANDO‑MODIFIERARE (Precommand Modifiers)

Ett enkelt kommando kan föregås av en förkommando‑modifierare som ändrar hur kommandot tolkas. Modifierarna är inbyggda kommandon, utom nocorrect som är ett reserverat ord.

Modifierare/kommando	Flagga(r)	Beskrivning
-	–	Kör kommandot med ett ledande - framför argv[0] (behandlas som inloggningsskal i vissa sammanhang).
builtin	–	Tolka ordet som namnet på ett inbyggt (builtin) kommando, inte en funktion eller extern binär.
command	-p, -v, -V	Tolka ordet som extern binär (inte funktion/inbyggd). -p: använd standard‑sökväg i stället för $path. -v: liknar whence; -V: motsvarar whence -v.
exec	-c, -l, -a argv0	Kör nästa kommando i nuvarande process (ingen fork); skalet ersätts. -c: rensa miljön. -l: ekvivalent med modifieraren - (login‑stil) och prefixar argv[0] med -. -a argv0: sätt explicit argv[0] (motsvarar env‑variabeln ARGV0). TRAPEXIT körs inte; zlogout läses inte.
nocorrect	–	Ingen stavningskorrigering på något ord. Måste stå före andra precommand‑modifierare. Ingen effekt i icke‑interaktiva skal.
noglob	–	Filnamnsgenerering (globbing) utförs inte på några ord.

KOMPLEXA KOMMANDON

Följande strukturer är komplexa kommandon i zsh:

if lista then lista [ elif lista then lista ] ... [ else lista ] fi

Kör första listan; om retur 0, kör then‑listan, annars prövas varje elif. Om ingen lyckas, körs else‑listan.

for namn ... [ in ord ... ] term do lista done

Iterera över ord (eller positionsparametrar om in utelämnas). Flera namn stöds; vid N namn tilldelas nästa N ord per varv.

for (( [expr1] ; [expr2] ; [expr3] )) do lista done

C‑lik aritmetisk for‑loop. Utvärdera expr1, sen så länge expr2 ≠ 0: kör listan och utvärdera expr3.

while lista do lista done

Kör do‑listan så länge testlistan returnerar 0.

until lista do lista done

Kör do‑listan så länge testlistan returnerar ≠ 0.

repeat ord do lista done

ord tolkas aritmetiskt till n; kör listan n gånger.

case ord in [(] mönster [ | mönster ] ... ) lista (;;|;&|;|) ] ... esac

Kör listan för första matchande mönstret. ;&: fall‑genom och kör nästa lista också. ;|: fortsätt matcha vidare utan att re‑expandera ord.

select namn [ in ord ... term ] do lista done

Presentera meny av ord med nummer; läs val till namn. Värdet i REPLY. Kör listan per val.

( lista ) – kör i underskal (traps återställs).

{ lista } – kör listan i aktuellt skal.

{ try‑lista } always { always‑lista } – kör alltid‑blocket oavsett fel/break/continue/return; TRY_BLOCK_ERROR anger felstatus (1 fel, 0 inget fel). Sätt TRY_BLOCK_ERROR=0 i always‑block för att rensa felet.

function ord ... [ () ] [ term ] { lista }

ord ... () [ term ] { lista }

ord ... () [ term ] kommando

Definiera funktion(er). Se avsnittet Funktioner.

time [ pipeline ] – kör och skriv tidsstatistik enligt $TIMEFMT; utan argument skriv statistik för skalet och dess barn.

'' ''uttryck'' ''' – utvärdera villkorligt uttryck; returnera 0 om sant. Se Villkorliga uttryck.

ALTERNATIVA FORMER FÖR KOMPLEXA KOMMANDON

Vissa kortformer finns (anser föråldrade) och kräver antingen att sublist är { lista } eller att optionen SHORT_LOOPS är satt. För detaljer och exempel, se originalsektionen. Kortformer finns för if, for, foreach, while, until, repeat, case, select.

RESERVERADE ORD

Följande ord känns igen som reserverade när de används som första ordet i ett kommando (såvida de inte citeras eller inaktiveras med disable -r):

do done esac then elif else fi for case if while function repeat time until select coproc nocorrect foreach end ! [[ { }

Dessutom känns } igen var som helst om IGNORE_BRACES inte är satt.

KOMMENTARER

I icke‑interaktiva skal, eller interaktiva med optionen INTERACTIVE_COMMENTS satt, ignoreras ett ord som börjar med tredje tecknet i $histchars (# som standard) samt all text till nyrad.

ALIAS

Varje token i skalets indata kontrolleras mot definierade alias. Om alias finns ersätts ordet av aliastexten när det står i kommandoposition (eller aliaset är globalt). Slutar aliastexten med ett blanktecken behandlas nästa ord som i kommandoposition. Alias definieras med alias (-g för globala alias). Aliasexpansion sker före annan expansion (utom historikexpansion).

Vanligt problem: alias expanderas när raden läses, inte vid körning, t.ex.:

alias echobar='echo bar'; echobar

kan ge ”kommando ej funnet” då aliaset ej gällde vid körning. I skript/funktioner rekommenderas funktioner i stället för alias.

CITATTECKEN (Quoting)

Tecken kan citeras med \\. \\ följt av nyrad ignoreras.

Sträng mellan $'... behandlas som argument till print och anses fullständigt citerad. En literal \\: kan införas som \\.

Enkelcitat '...' citerar allt; ett enkelt citattecken kan inte förekomma inuti, utom om RC_QUOTES är satt – då blir ''' → '.

Inuti dubbla citat \"...\" sker parameter‑ och kommandosubstitution; \\ citerar \\, \", $ och '.

OMDIRIGERING (Redirection)

Om ett kommando följs av & och jobbkontroll inte är aktiv används /dev/null som standard in. Annars är filbeskrivarevs miljövs tillståndvs.

Nedanstående kan förekomma var som helst i ett enkelt kommando eller före/efter ett komplext kommando. Expansion sker före ord/siffra används (med angivna undantag). Om substitution av ord ger fler än ett filnamn sker omdirigering för varje fil i turordning.

Operator	Beskrivning
< ord	Öppna fil för läsning som standard in.
<> ord	Öppna fil för läsning/skrivning som standard in; skapa om den saknas.
> ord	Öppna/sätt standard ut för skrivning; skapa vid behov. Om CLOBBER är av – fel vid befintlig fil; annars truncera.
ord / >! ord	Som >, men tvinga truncering även om CLOBBER är av.
>> ord	Öppna för append. Om CLOBBER är av och fil saknas → fel; annars skapa.
ord / >>! ord	Som >>, men skapa även om CLOBBER är av.
<<[-] ord	Here‑document till rad som är samma som ord, eller EOF. Citering av ord styr expansioner i dokumentet. <<- tar bort ledande tabbar.
<<< ord	Here‑string: expandera ord och mata som standard in.
<& nr / >& nr	Duplicera standard in/ut från filbeskrivare nr.
<&- / >&-	Stäng standard in/ut.
<&p / >&p	Flytta I/O från/till medprocessen till standard in/ut.
>& ord / &> ord	Omdirigera både standard ut och standard fel som > ord. (Skiljer sig från > ord 2>&1 med multios.)
/>&!/&>|/&>! ord	Som ovan men tvingar truncering även om CLOBBER är av.
>>>& ord / &>> ord	Append för både standard ut och fel.
/>>>&!/&>>|/&>>! ord	Append + tvingad skapelse.

Om en siffra skrivs före operatorn avses den filbeskrivaren istället för 0/1. Ordningen spelar roll, t.ex. 1>fil 2>&1 kopplar först 1→fil, sedan 2→1 (dvs fil). Omvänt ger annat resultat.

Man kan även allokera en ny fd ≥ 10 via {namn}>&1 och få numret i parametern namn; stäng med {namn}>&-. Parametern får inte vara readonly. IGNORE_BRACES får inte vara satt.

|& är förkortning för 2>&1 |.

Processubstitution <(lista), =(lista) (in) och >(lista) (ut) kan kombineras med omdirigering. Se zshexpn(1).

Multios

Med optionen MULTIOS (på som standard) kan flera omdirigeringar till samma fd ske parallellt via en intern tee‑process:

date >foo >bar

skriver till både foo och bar. En pipe räknas som implicit omdirigering, så

date >foo | cat

skriver både till foo och pipar till cat.

Med MULTIOS globbas även ordet efter en omdirigeringsoperator:

: > *

trunkerar alla filer i katalogen (om några finns) istället för att skapa en fil *.

För läsning:

sort <foo <fubar

när ekvivalent med cat foo fubar | sort.

Observera att output‑multios till extern process kan leda till att skalet inte väntar på att alla kopior är skrivna. Lösning: kör kommandot i aktuellt skalblock:

{ cat file } >file1 >file2

Omdirigering utan kommando

Om en enkel kommando‑rad består av endast omdirigeringsoperatorer och ev. tilldelningar:

• Om NULLCMD ej satt eller CSH_NULLCMD satt → fel (csh‑beteende).
• Om SH_NULLCMD satt → infoga ': som kommando med givna omdirigeringar (sh/ksh‑beteende).
• Annars används $NULLCMD (standard cat) som kommando, och vid inläsning $READNULLCMD (standard more).

KOMMANDOKÖRNING

Om namnet saknar / söker skalet först funktion, sedan inbyggt, därefter i $path. Hittas inget: fel. Om körning misslyckas p.g.a. icke‑körbart format (och inte en katalog) antas en skalscript: /bin/sh startas. #! på första raden anger tolk.

Om command_not_found_handler finns körs den vid saknat kommando; return 0 om hanterat, annars standardfelhantering. Körs i underskal.

FUNKTIONER

Funktioner definieras med function eller namn(). Alias löses vid inläsning. Funktioner körs i samma process som anropare och delar öppna filer och arbetskatalog. return används för att lämna. Lista med functions; ta bort med unfunction.

Autoladdning av funktioner

autoload (eller functions -u/typeset -fu) markerar en funktion som odefinierad tills första körning, då söks dess definition i $fpath. Typiskt:

fpath=(~/myfuncs $fpath)
autoload myfunc1 myfunc2

-U för att undertrycka aliasexpansion vid autoload (rekommenderas för zshs standardfunktioner). För förkompilerade .zwc krävs -U vid zcompile.

Sökordning per element i $fpath:

1. element.zwc – kompilerad katalogfil.
2. element/function.zwc – kompilerad funktionsfil.
3. element/function – vanlig funktionsfil.

Med KSH_AUTOLOAD körs filens innehåll direkt (ska definiera funktionen, kan göra init). Utan, tolkas filens hela innehåll som funktionskropp.

autoload -X kan användas i en stub‑funktion för att ladda sig själv.

Anonyma funktioner

Utan namn körs funktionen omedelbart vid definition och sparas inte. $0 sätts till (anon). Praktiskt för lokala variabler i initfiler.

SPECIALFUNKTIONER

Hook‑funktioner: för flera av nedan kan en array <namn>_functions ange ytterligare hookar att köra i samma kontext; fel stoppar efterföljande hookar.

Hook	När körs
chpwd	Varje gång aktuell katalog ändras.
periodic	Om $PERIOD är satt: körs var $PERIOD sekund precis före prompt. Alla periodic_functions körs tillsammans.
precmd	Före varje prompt.
preexec	Efter att en rad lästs och ska köras. Arg1: rå inmatad rad (eller tom). Arg2: enkelradig, kortad representation. Arg3: full text som körs.
zshaddhistory	När en historikrad lästs interaktivt men före körning. Icke‑0 return → sparas inte i historik. Kan byta historikkontext med fc -p.
zshexit	När huvuds­kalet ska avslutas normalt (inte i underskal, och inte via exec; till skillnad från TRAPEXIT inte vid funktions‑exit).

Fällor (trap‑funktioner) – definiera TRAP<signalnamn> (t.ex. TRAPINT). För 0‑retur anses signalen hanterad. Exempel:

TRAPINT() { print "Caught SIGINT, aborting."; return $((128 + $1)) }

TRAPDEBUG, TRAPZERR, TRAPEXIT körs aldrig inuti andra fällor. TRAPDEBUG körs före (standard) eller efter varje kommando beroende på DEBUG_BEFORE_CMD. TRAPEXIT: vid skalets exit eller funktions‑exit (om definierad inuti funktionen). TRAPZERR: när ett kommando returnerar ≠ 0 (ej i &&/|| sublistor för icke‑sista kommandot). Fällor kan även definieras med builtinen trap.

JOBB

Med optionen MONITOR associerar ett interaktivt skal ett jobb till varje pipeline. jobs visar tabellen, och jobb får små heltals‑id. Start av bakgrundsjobb & skriver t.ex. [1] 1234 (jobb 1, process‑PID 1234). &| eller &! disownar direkt (ingen jobbtabelspost).

^Z (SIGTSTP) pausar aktuellt jobb, varpå du kan bg eller fg. Bakgrundsjobb stoppar om de läser från terminal. stty tostop gör att de även stoppar vid skrivning. Vid fg/wait återställs tty‑lägen.

Jobbreferenser: %n (nummer), %str (börjar med), %?str (innehåller), %%/%+ (aktuellt), %- (föregående).

Notiser om jobb skickas till terminalen. Varje avslutat bakgrundsjobb triggar eventuell CHLD‑fälla.

Vid försök att lämna skalet med jobb kvar varnas ”You have suspended (running) jobs”. För att undvika SIGHUP vid exit: använd nohup(1) eller disown.

SIGNALER

INT och QUIT ignoreras för ett kommando som följs av & om MONITOR inte är aktiv. Själva skalet ignorerar alltid QUIT. I övrigt är signalhanteringvsvs; se TRAP* ovan.

ARITMETISK UTVÄRDERING

Skalet kan utföra heltals- och flyttalsaritmetik via let eller $((...)). Heltal använder normalt 8‑bytes precision (annars 4). Flyttal använder double.

let tar uttryck som separata argument. Kommandon som börjar med (( … )) behandlas som citerade uttryck; return 0 om uttrycket ≠ 0, 1 om 0, 2 vid fel.

Talbaser: 0x för hex; bas#n (2..36) t.ex. 16#ff. Utdata‑bas kan anges med [#bas]. Med optionen C_BASES accepteras 0xFF (och med OCTAL_ZEROES även 077). [##bas] skriver utan basprefix.

Operatorer och prioritet (inbyggt läge):

Grupp	Operatorer	Betydelse
Unära	+ - ! ~ ++ --	unärt plus/minus, logiskt NOT, bitkomplement, pre/post inkrement/dekrement
Skift	<< >>	bitvis skift vänster/höger
Bitvisa		AND, XOR, OR
Exponent	**	upphöjt till
Produkt	* / %	multiplikation, division, rest
Summa	+ -	addition, subtraktion
Jämförelse	< > <= >=	jämförelse
Likhet	== !=	(o)likhet
Logik	&&	^^	AND, OR, XOR (kortslutning för && och	)
Ternär	? :	villkorsoperator
Tilldelning	= <<= >>= &&=	= ^^= **=	tilldelningar
Komma	,	sekvenseringsoperator

Med optionen C_PRECEDENCES ändras prioriteringar till C‑lika (se originaltabellen). Notera att -3**2 tolkas som -(3**2) kräver parentes för -9.

Matematiska funktioner finns i modulen zsh/mathfunc (ladda med zmodload). Tecken‑konstanter: ##x ger teckenvärdet för x. Namngivna parametrar/arrayer kan refereras direkt i aritmetik. integer/float deklarerar typer; heltal avrundar nedåt vid flyttals­tilldelning. Implicit typning kan ge fällor (t.ex. f += 0.1 om f först blev integer) – deklarera explicit.

VILLKORLIGA UTTRYCK

Används med ... för filtest och sträng-/talsjämförelser. Normal skalexpansion gäller, men resultatet begränsas till ett ord (som vid \"...\"). Mönster följer filnamnsglobbar (se zshexpn(1)) men utan speciell /‑hantering eller kvalificerare.

Form	Betydelse
-a fil	sant om fil finns.
-b fil	sant om blockenhet.
-c fil	sant om teckenenhet.
-d fil	sant om katalog.
-e fil	sant om fil finns.
-f fil	sant om vanlig fil.
-g fil	sant om setgid satt.
-h fil	sant om symbolisk länk.
-k fil	sant om sticky‑bit satt.
-n str	sant om längden ≠ 0.
-o option	sant om angiven skaloption är på.
-p fil	sant om FIFO (named pipe).
-r fil	sant om läsbar.
-s fil	sant om storlek > 0.
-t fd	sant om fd är öppen och kopplad till terminal.
-u fil	sant om setuid satt.
-w fil	sant om skrivbar.
-x fil	sant om körbar/sökbar (katalog).
-z str	sant om längden = 0.
-L fil	sant om symbolisk länk.
-O fil	sant om ägd av effektiv uid.
-G fil	sant om grupp = effektiv gid.
-S fil	sant om socket.
-N fil	sant om åtkomsttid inte nyare än mod‑tid.
fil1 -nt fil2	sant om fil1 nyare än fil2.
fil1 -ot fil2	sant om fil1 äldre än fil2.
fil1 -ef fil2	sant om samma fil.
str = mönster / ==	sant om str matchar mönster (== föredras).
str != mönster	sant om str inte matchar.
str =~ regexp	sant om str matchar regexp (PCRE med RE_MATCH_PCRE annars POSIX ERE). Sätter MATCH/match eller BASH_REMATCH vid träff.
str1 < str2	sant om str1 före str2 (ASCII).
str1 > str2	sant om str1 efter str2 (ASCII).
exp1 -eq exp2	numeriskt lika.
-ne, -lt, -gt, -le, -ge	numeriska (o)likhet/ordning.
( exp )	sant om exp sant.
! exp	sant om exp falskt.
exp1 && exp2	sant om båda sanna.
exp1	exp2	sant om någon sann.

Särskilt: /dev/fd/n testar öppen fd n. Numeriska expanderas som $((...)).

Exempel:

[[ ( -f foo || -f bar ) && $report = y* ]] && print File exists.

UTVIDGNING AV PROMPTSEKVENSER

Promptsträngar kan expanderas. Med PROMPT_SUBST sker parameter‑, kommando‑ och aritmetisk expansion. PROMPT_BANG: ! → historiknummer (!! för literal). PROMPT_PERCENT: %‑sekvenser aktiva (vissa med heltalsargument). Även villkorliga sekvenser finns.

Enkla prompt‑sekvenser (urval)

• %% → %
• %) → )

Inloggningsinfo: %l (tty utan /dev/; /dev/tty* kortas), %M (fullvärdnamn), %m (värd fram till första .; heltal kan ange antal komponenter, negativt från höger), %n ($USERNAME), %y (tty utan /dev/ utan specialfall).

Skalstatus: %# (# om med privilegier, annars %), %? (senaste returstatus), %_ (parserstatus/öppna block; användbar i PS2/PS4), %d/%/ ($PWD; heltal anger antal komponenter; negativt = ledande), %~ (som %d men med ~ för namngivna kataloger/$HOME), %h/%! (historiknummer), %i/%I (radräknare i skript/funktion resp. fil), %j (antal jobb), %L ($SHLVL), %N/%x (skript/funktionsnamn resp. filnamn; heltal för komponenter), %c/%./%C (sista $PWD‑komponent(er); föråldrade varianter).

Datum/tid: %D (yy-mm-dd), %T (24‑tim), %t/%@ (12‑tim), %* (24‑tim med sek), %w (dag-dd), %W (mm/dd/yy), %D{str} via strftime(3); vissa zsh‑utökningar (t.ex. %f, %K, %L); GNU -‑modifiering stöds för d,f,H,k,l,m,M,S,y.

Visuella effekter: %B/%b (bold på/av), %U/%u (underline), %S/%s (standout), %E (rensa till radslut), %F{färg}/%f (förgrund), %K{färg}/%k (bakgrund), %{ ... %} (literal escape som inte flyttar markören), %G (”glitch”: räkna bredd manuellt, t.ex. i alternativa teckenuppsättningar; %2G = bredd 2). Vid trunkering dela upp i enstaka tecken inom %{...%}.

Villkorliga substrängar i prompt

%v → första elementet i arrayen psvar (%<n>v för index; negativa från slutet).

Ternär: %(x.true-text.false-text) där x anger testet; samma avskiljare används mellan true/false. %) kan användas som ) i false‑text. Heltal före/efter ( anger parameter till testet. Testtyper (urval): ! (privilegier), # (effektiv uid == n), ? (senaste status == n), _ (antal öppnade block ≥ n), C///c/./~ (komponenter i $PWD), D (månad == n; jan=0), d (dag i månaden == n), g (effektiv gid == n), j (jobb ≥ n), L ($SHLVL ≥ n), l (skrivna tecken ≥ n), S ($SECONDS ≥ n), T (timme == n), t (minut == n), v (psvar har ≥ n element), V (psvar[n] satt/icke‑tom), w (veckodag == n; sön=0).

Trunkering: %<string< (vänster), %>string> (höger) eller %[xstring] (föråldrat). Numeriskt argument anger maxlängd för delen som följer; string visas istället för trunkerad del (expanderas inte). Trunkeringsområdet löper till slutet, slutet av närmaste %(... )‑grupp, eller nästa trunkering på samma nivå. %<< (n=0) markerar slutet av trunkeringsområdet och stänger av trunkering efteråt.

ENKLA KOMMANDON & RÖRLEDNINGAR

Ett enkelt kommando är en sekvens av valfria parameter­tildelningar följt av blankseparerade ord, med valfria omdirigeringar insprängda. Det första ordet är kommandot som ska köras, och återstående ord, om några, är argument till kommandot. Om ett kommandonamn anges påverkar parameter­tildelningarna kommandots miljö när det körs. Värdet (returkoden) för ett enkelt kommando är dess avslutsstatus, eller 128 plus signalnumret om det avbryts av en signal.

Exempel:

echo foo

En rörledning (pipeline) är antingen ett enkelt kommando, eller en sekvens av två eller fler enkla kommandon där varje kommando separeras från nästa med | eller |&.

• Med | kopplas standard ut från föregående kommando till standard in på nästa.
• |& är en förkortning av 2>&1 |, vilket kopplar både standard ut och standard fel till standard in på nästa kommando.

Exempel:

echo foo | sed 's/foo/bar/'

FÖRKOMMANDO-MODIFIERARE

Se även \[\[zshbuiltins(1)]].

| | | |

- | ---------------------- | - | ------------------------------------------------------------------------------------------------------------------ |

| – | | Kör kommandot med ett ledande - framför argv\[0]. |

| | | |

| – | | Tolka ordet som namnet på ett inbyggt kommando. |

| | | |

| -p, -v, -V | | Tolka ordet som extern binär. -p använder standardsökväg. -v/-V visar info (se \[\[whence(1)]]). |

| | | |

| -c, -l, -a | | Kör nästa kommando i nuvarande process (ingen fork). -c: rensa miljön. -l: login-stil. -a: sätt argv0. |

| | | |

| – | | Ingen stavningskorrigering. |

| | | |

| – | | Ingen globbing. |

| | | | Exempel: command ls -l /bin Kör alltid systemets ls, även om det finns en funktion/alias med samma namn. \== KOMPLEXA KOMMANDON == Exempel på for-loop: for f in *.txt; do echo "Fil: $f" done Exempel på if: if [[ -f /etc/passwd ]]; then echo "Filen finns" fi \== OMDIRIGERING == Se även \[\[zshexpn(1)]]. | | - | ----------------------------------------- | | Skicka standard ut till fil. | | | | Skicka standard fel till fil. | | | | Skicka både standard ut och fel till fil. | | | | Läs standard in från fil. | | | Exempel: ls > filer.txt 2>&1 Sparar både stdout och stderr i filer.txt. \== JOBB == Exempel: sleep 100 & jobs fg %1 Startar ett jobb i bakgrunden, visar jobblistan, tar tillbaka det i förgrunden. \== PROMPT == Exempel på färgglad prompt: PS1='%F{green}%n@%m%f:%F{blue}%~%f$ ' Visar användare\@värd och aktuell katalog med färger. \== FUNKTIONER == Exempel på funktion: myfunc() { echo "Hej från en funktion" } myfunc \== REFERERAS AV == \[\[zsh(1)]], \[\[zshcalsys(1)]], \[\[zshcompsys(1)]], \[\[zshcontrib(1)]], \[\[zshoptions(1)]], \[\[zshparam(1)]], \[\[zshroadmap(1)]], \[\[zshbuiltins(1)]], \[\[zshexpn(1)]], \[\[zshmodules(1)]], \[\[zshzle(1)]] --- \= zshmisc Snabbreferens = \== Vanliga operatorer == > fil – skriv stdout till fil 2> fil – skriv stderr till fil &> fil – skriv både stdout+stderr < fil – läs stdin från fil \== Villkorliga uttryck == -f fil – finns filen? -d dir – är det en katalog? str1 = str2 – strängjämförelse exp1 -eq exp2 – heltalsjämförelse \== Jobbkontroll == & – kör i bakgrunden jobs – lista jobb fg %1 – ta tillbaka jobb bg %1 – återstarta i bakgrunden \== Prompt == %n – användarnamn %m – värdnamn %\~ – aktuell katalog %# – # om root, annars % Exempel: PS1='%n@%m:%~ %# ' REFERERAS AV zsh(1), zshcalsys(1), zshcompsys(1), zshcontrib(1), zshoptions(1), zshparam(1), zshroadmap(1)