Nye brukere av UNIX og Linux blir kanskje litt skremt av størrelsen og den tilsynelatende kompleksiteten til systemet foran dem. Det finnes mange gode bøker om UNIX , for alle nivåer av kunnskaper fra nybegynner til ekspert. Dessverre er det ingen av disse bøkene som spesielt dekker en introduksjon om bruk av Linux. Selv om 95$ av Linux er helt likt andre UNIX-systemer, er den enkleste og mest likefremme måten å bli kjent med det nye systemet ditt på en veiledning skreddersydd for Linux. Her er en slik veiledning.
Dette kapittel fordyper seg ikke i en mengde detaljer eller tar opp mange avanserte emner. Isteden er hensikten å få nye Linux brukere opp og kjøre, på begge føtter, slik at han eller hun siden kan lese en mer generell bok om UNIX og forstå de grunnleggende forskjeller mellom andre UNIX-systemer og Linux.
Veldig lite er forutsatt her, unntatt kanskje litt kjennskap til personlige datamaskiner, og MS-DOS. Selv om du ikke er en MS-DOS bruker, skulle du være i stand til å forstå alt her. Ved første møte ser UNIX nesten ut som MS-DOS (når alt kommer til alt ble deler av MS-DOS modellert etter operativsystemet CP/M, som igjen var etter modell av UNIX). Imidlertid er det bare overfladiske egenskaper ved UNIX som ligner MS-DOS på noen måte. Selv om du er helt nybegynner på PC, burde denne veiledning være til hjelp.
Og før vi begynner: Ikke vær redd for å eksperimentere. Systemet vil ikke bite deg. Du kan ikke ødelegge alt ved å arbeide med systemet. UNIX har en del innebygget sikkerhet, for å hindre <<vanlige>> brukere (den rollen som du nå skal ha) i å ødelegge filer som er sentrale for systemet. Og i såfall, det verste som kan skje er at du sletter alle egne filer --- og at du må gå tilbake og re-installere disse. Derfor, ved dette punkt har du ingenting å tape.
UNIX er et fleroppgave, flerbruker operativsystem. Dette betyr at mange personer kan bruke en datamaskin samtidig, og kjøre mange forskjellige applikasjoner. (Dette til forskjell fra MS-DOS, hvor bare en person av gangen kan bruke systemet.) Under UNIX må brukere for å identifisere seg selv i systemet, logge inn. Det består i følgende steg: Registrer innloggings-navnet ditt (det navnet som systemet identifiserer deg med), og deretter ditt passord, som er din personlige nøkkel for å låse opp din konto. Fordi bare du kjenner passordet, kan ingen andre logge inn i systemet under ditt brukernavn.
På tradisjonelle UNIX-system er det systemadministrator som vil tildele deg et brukernavn og et første gangs passord når det opprettes en brukerkonto i systemet. Men fordi du selv er systemadministrator, må du sette opp din egen konto før du kan logge inn --- se avsnitt 3.2.1, nedenfor. I det følgende, vil vi bruke det tenkte brukernavn <<larry>>.
I tillegg har hvert UNIX-system tilordnet et eget vertsnavn. Det er dette vertsnavn som gir maskinen din et navn, gir den karakter og sjarm. Vertsnavnet brukes for å identifisere de enkelte maskiner i et nettverk, men selv om din maskin ikke er i et nettverk, bør den ha et vertsnavn. I avsnitt 4.10.2 vil vi gjennomgå hvordan du definere systemets vertsnavn. For vårt eksempel nedenfor, er systemets vertsnavn <<darkstar>>.
For å kunne opprette en konto til deg selv, må du logge inn som root og bruke useradd eller adduser kommandoen. Se avsnitt 4.4 for information om denne prosedyren.
darkstar login:Angi brukernavnet ditt, og trykk [enter]. Vår helt, larry, ville taste følgende:
darkstar login: larry Password:Angi passordet ditt nå. Det vil ikke vises på skjermen når du logger inn, så skriv påpasselig. Hvis du skiver passordet ditt feil, vil du se beskjeden
Login incorrectog du må forsøke igjen.
Når du har angitt brukernavn og passord korrekt, er du offisielt logget inn i systemet, og kan fritt vandre rundt.
For å demonstrere dette, logg inn i systemet ditt (som vist over).
Trykk [Alt] [F2].
Du skulle nå se innloggings-prompten igjen. Du ser nå det andre virtuelle konsollet du logget inn i. For å bytte tilbake til det første VK, trykk [Alt] [F1]. Voila! Du er tilbake i din første innloggings-sesjon.
Et nyinstallert Linux-system vil antakelig gi deg adgang til de første fire VK. Men det er mulig å sette opp 12 VK --- et for hver funksjonstast på tastaturet ditt. Som du ser, kan bruken av VK være meget kraftig --- du kan arbeide i flere forskjellige VK på en gang.
Mens bruken av VK'er er litt begrenset (du kan tross alt bare se på en VK av gangen), skulle det gi deg en følelse av UNIX's flerbruker muligheter. Mens du arbeider på VK nr. 1, kan du bytte over til VK nr. 2 og starte arbeidet med noe annet.
Så snart du er logget inn, starter systemet et skall, og du kan taste kommandoer til det. Her er et raskt eksempel. Larry logger inn, og sitter med skall-prompten.
darkstar login: larry Password: larry's passord Welcome to Darkstar! /home/larry$/home/larry$ er skallets prompt, klart til å ta imot kommandoer. (Mer om hva prompten betyr senere.) La oss forsøke å fortelle systemet at det skal gjøre noe interessant:
/home/larry$ make love make: *** No way to make target `love'. Stop. /home/larry$Vel, som det viste seg var make et navn på et virkelig program i systemet, og skallet utførte programmet da det mottok kommandoen. (Dessverre var systemet uvillig.)
Dette bringer oss til et brennende spørsmål: Hva er kommandoer? Hva hender når du taster make love ? Første ordet på kommando linja, <<make>>, er navnet til kommandoen som skal utføres. Alt annet på kommando linja blir tatt som argumenter til denne kommando.
Eksempel:
/home/larry$ cp foo barHer er navnet på kommandoen <<cp>>, og argumentene er <<foo>> og <<bar>>.
Når du taster en kommando, vil skallet gjøre flere ting. Først vil det lete etter kommandoens navn, og sjekke om kommandoen er intern i skallet. (Altså en kommando som skallet selv vet hvordan det skal utføre. Det er mange slike kommandoer, og vi skal komme til dem senere.) Skallet sjekker også for å se om kommandoen er en alias, eller erstatningsnavn, for en annen kommando. Hvor ingen av disse betingelsene er oppfylt, leter skallet etter et program, på harddisken, med denne kommandoens navn. Dersom det finner et slikt program, kjører skallet det, og gir programmet de argumentene som ble gitt på kommando linja.
I vårt eksempel, leter skallet etter et program som heter make, og kjører det med argumentet love.
Make er et program som ofte brukes til å kompilere store programmer, og det tar som argumenter navnet til <<resultatet>> for kompileringen. I tilfellet <<make love>>, instruerte vi make til å kompilere resultatet love.
Fordi make ikke kan finne et resultatmål med det navnet, mislykkes det med en humoristisk feilmelding, og vi blir returnert til skallets prompt.
Hva hender når vi taster en kommando til skallet, og skallet ikke kan finne et program med det kommandonavnet å utføre? Vi kan forsøke det:
/home/larry$ eat dirt eat: command not found /home/larry$Ganske enkelt, der hvor skallet ikke kan finne et program med navnet gitt på kommando linja (her, <<eat>>), skriver det en feilmelding som skulle være selv-forklarende. Du kan ofte se feilmeldingen dersom du skriver en kommando feil (for eksempel, hvis du tastet <<mkae love>> isteden for <<make love>>).
/home/larry$ exittil utlogging. Det er andre måter å logge ut på også, men dette er den sikreste av dem.
Filer blir identifisert med filnavn. For eksempel, fila som inneholder din historie- avhandling ble kanskje lagret med filnavnet historie-avhandling. Disse navnene identifisere vanligvis fila og dens innhold på en måte som er meningsfull for deg. Det er ikke noe lagringsformat for filnavn slik som det er i MS-DOS og andre operativsystem; filnavn kan inneholde alle tegn (unntatt /--- se diskusjonen om sti-navn, nedenfor), og er begrenset til en lengde på 256 tegn.
Med begrepet fil kommer også begrepet katalog. En katalog er en samling av filer. Det kan sammenlignes med en <<mappe>> som inneholder mange filer. Katalogene har også navn, som du kan identifisere, kjenne igjen. I tillegg er katalogene ordnet i en trestruktur; som vil si at kataloger kan inneholde andre kataloger.
En fil kan refereres med sitt stinavn, som består av filnavnet, med navnet på katalogen som inneholder fila foran. For eksempel, la oss si at Larry har en katalog kalt avhandling, som inneholder tre filer: historie-ferdig, engelsk-litt, og hoved-oppgave. (Hver av disse tre filene inneholder informasjon om tre av Larry's nåværende prosjekter.) For å henvise til fila engelsk-litt, kan Larry spesifisere filas stinavn:
avhandling/engelsk-littSom du ser, skilles katalog og filnavn med en enkel slash (/). Av denne grunn, kan ikke filnavn selv inneholde tegnet / . MS-DOS brukere vil finne denne praksis kjent, selv om det i MS-DOS brukes backslash (\) isteden.
Som nevnt, kan kataloger flettes etter hverandre også. For eksempel, la oss si at Larry har en annen katalog, med avhandlinger, kalt notater. Denne katalog inneholder filene math-notater og lure-ark. Stinavnet til fila lure-ark er nå
avhandling/notater/lure-arkDerfor er stinavn virkelig en <<sti>> som du tar for å finne en bestemt fil. Katalogen over er gitt en underkatalog som kalles foreldre katalog. Her er katalogen avhandling foreldre til katalogen notater.
Hver for seg har alle brukere en hjemmekatalog. Den er reservert for brukeren til å lagre hans eller hennes filer i. I eksempelet over er alle Larry's filer (som lure-ark og historie-ferdig) lagret i Larry's hjemme katalog. Vanligvis er brukerens hjemme-kataloger satt opp under /home, og er gitt navn etter brukeren som eier den katalogen. Derfor er Larry's hjemme-katalog /home/larry.
I figur 3.2.8 er et eksempel på et katalog tre presentert. Det burde gi deg noen ideer om hvordan katalogtreet på ditt system er organisert.
/___|_bin
|_dev
|_etc
|_home_____larry
| |_sam
|_lib
|_proc
|_tmp
|_usr__|X386
|_bin
|_emacs
|_etc
|_g++-include
|_include
|_lib
|_local_____bin
| |_emacs
| |_etc
| |_lib
|_man
|_spool
|_src_____linux
|_tmp
Figur 3.1: Et typisk (forenklet) katalogtre i Unix.
Her er et eksempel. Larry har katalogen avhandling, og avhandling inneholder fila historie-ferdig. Når Larry ønsker å se på fila, kan han bruke kommandoen
/home/larry$ more /home/larry/avhandling/historie-ferdigmore-kommandoen viser ganske enkelt ei fil, en skjerm av gangen. Men fordi Larry's gjeldende arbeids-katalog er /home/larry, kan han isteden referere til fila relativt til filas gjeldende lokasjon.
Kommandoen blir da
/home/larry$ more avhandling/historie-ferdigDerfor, når du begynner et filnavn (som avhandling/final) med et annet tegn enn <</>>, antar systemet at du refererer til fila relativt til din gjeldende arbeidskatalog. Dette er kjent som et relativt stinavn.
Men dersom du begynner et filnavn med en <</>>, tolker systemet det som et fullt stinavn --- det vil si et stinavn som inkluderer hele stien til fila og starter fra root katalogen, /. Dette er kjent som et absolutt stinavn.
/home/larry$ more ~/avhandling/historie-ferdiger det samme som
/home/larry$ more /home/larry/avhandling/historie-ferdig<<~>> tegnet er erstattet med navnet til din hjemmekatalog av skallet.
I tillegg kan du spesifisere andre brukeres hjemmekataloger med tilden også. Stinavnet <<~karl/letters>> oversettes til <</home/karl/letters>> av skallet (hvor /home/karl er karl's hjemme katalog). Bruken av tilde er ganske enkelt en forkortelse; ingen kataloger heter <<~>>---det er bare syntetisk sukker levert av skallet.
cd <katalog>
hvor <katalog> er navnet på katalogen som du ønsker å
bytte til.
Som vi sa, når du logger inn, begynner du i din hjemmekatalog. Hvis Larry ønsket å flytte ned i underkatalogen avhandling, bruker han kommandoen
/home/larry$ cd avhandling
/home/larry/avhandling$
Som du kan se, Larry's prompt er endret til å være hans
nåværende arbeidskatalog (slik at han vet hvor han er). Nå
når han er i katalogen avhandling, kan han se på historie-ferdig
med kommandoen
/home/larry/avhandling$ more historie-ferdig
Nå sitter Larry fast i underkatalogen avhandling. For å flytte opp
til foreldrekatalogen brukes kommandoen
/home/larry/avhandling$ cd ..
/home/larry$
(Legg merke til mellomrom mellom <<cd>> og
<<..>>.) Hver katalog har et navn <<..>> som refererer
til en foreldrekatalog. På samme måte har hver katalog et
adgangsnavn <<.>> som refererer til seg selv. Derfor, fører
kommandoen
/home/larry/avhandling$ cd .
oss ingen steder.Du kan også bruke absolutte stinavn i cd kommandoen. For å cd til Karl's hjemme katalog, kan vi bruke kommandoen
/home/larry/avhandling$ cd /home/karl
/home/karl$
Ved å bruke cd uten argument vil du komme tilbake til din egen
hjemmekatalog.
/home/karl$ cd
/home/larry$
/home/larry$ ls
Mail
letters
avhandling
/home/larry$
Her kan vi se at Larry har tre registreringer i sin nåværende
katalog: Mail, letters, og avhandling. Dette forteller oss ikke mye --- er
dette kataloger eller filer? Vi kan bruke -F opsjonen på
ls kommando til fortelle oss mer.
/home/larry$ ls -F
Mail/
letters/
avhandling/
/home/larry$
Fra / knyttet til hvert filnavn, vet vi at disse tre registreringer er
underkataloger.Ved å bruker ls -F vil <<*>> også knyttes til enden av filnavnet. Dette forteller at fila er kjørbar, eller et program vi kan få til å kjøre. Hvis ingenting er knyttet til filnavnet når vi bruker ls -F, er fila ei <<vanlig gammel fil>>, det vil si, den er hverken en katalog, eller ei kjørbar fil.
Vanligvis kan hver UNIX-kommando ta flere opsjoner i tillegg til andre argument. Disse opsjoner begynner vanligvis med <<->>, som demonstrert over med ls -F. -F opsjonen ber ls gi mer informasjon om typer av filer involvert --- i dette tilfelle, skrives en / etter hvert katalognavn. Hvis du gir ls et katalognavn, vil innholdet til katalogen skrives ut.
/home/larry$ ls -F avhandling
engelsk-litt
historie-ferdig
hoved-teser
notater/
/home/larry$
Eller, for en mer interessant liste, la oss se hva som er i systemets /etc
katalog.
/home/larry$ ls /etc
Images ftpusers lpc rc.new shell
adm getty magic rc0.d startcons
brc gruppe mount rc2.d swapon
brc~ inet mtab rc3.d syslog.conf
csh.cshrc init mtools rc4.d syslog.pid
csh.login init.d pac rc5.d syslogd.rel
default initrunlvl passwd rmt termcap
derktab inittab printcap rpc umount
fdprm inittab.old profile rpcinfo update
fstab ersue psdatabase securetty utmp
ftpaccess lilo rc services wtmp
/home/larry$
(Alle MS-DOS brukere der ute, legg merke til hvordan filnavn kan være
lenger enn 8 tegn, og kan inneholde punktum i en hvilken som helst posisjon.
Det er til og med mulig å ha mer enn ett punktum i et filnavn.)La oss cd opp til toppen av katalogtreet, med <<cd ..>>, og deretter ned til en annen katalog:
/usr/bin.
/home/larry$ cd ..
/home$ cd ..
/$ cd usr
/usr$ cd bin
/usr/bin$
Du kan også flytte til kataloger i flere steg, som i cd /usr/bin.
Forsøk å flytte rundt i kataloger, og bruk ls og cd. I noen tilfeller, kan du komme inn i et forbudt område og få <<Access denied>> meldingen. Dette er en del av sikkerhets-konseptet til UNIX som dukker opp: for å ls eller cd inn i en katalog, må du ha adgang til den. Vi skal snakke mer om dette i avsnitt 3.9.
/home/larry$ mkdir foo
/home/larry$ ls -F
Mail/
foo/
letters/
avhandling/
/home/larry$ cd foo
/home/larry/foo$ ls
/home/larry/foo$
Gratulerer! Du har nettopp laget en ny katalog og flyttet dit.Siden det ikke er noen filer i denne nye katalogen, la oss lære hvordan filer kopieres fra et sted til et annet.
/home/larry/foo$ cp /etc/termcap .
/home/larry/foo$ cp /etc/shell .
/home/larry/foo$ ls --F
shell termcap
/home/larry/foo$ cp shell bells
/home/larry/foo$ ls --F
bells shell termcap
/home/larry/foo$
cp kommandoen kopierer filer vist på kommandolinja til ei fil
eller en katalog gitt som det siste argumentet. Legg merke til hvordan vi
bruker katalog <<.>> for å henvise til den
nåværende katalog.
/home/larry/foo$ mv termcap sells
/home/larry/foo$ ls -F
bells sells shell
/home/larry/foo$
Legg merke til at termcap ikke lenger finnes, men i dens plass er det fila
sells. Dette kan brukes til å døpe om filer, som vi nettopp har
gjort, men også til å flytte ei fil til en helt ny katalog.NB !: mv og cp vil skrive over mål-fila (hvis den finnes) uten å spørre deg. Forsiktig når du flytter ei fil til en annen katalog: det kan allerede finnes ei fil med det samme navnet i den katalogen, som vil du dermed skriver over!
For å slette ei fil, brukes kommandoen rm. (<<rm>> betyr <<remove>>).
/home/larry/foo$ rm bells sells
/home/larry/foo$ ls -F
shell
/home/larry/foo$
Bare shell er igjen, men vi klager ikke. Legg merke til at rm ikke ber
deg om bekreftelse før fila slettes --- så vær forsiktig.En beslektet kommando til rm er rmdir. Denne kommando sletter en katalog, men bare hvis katalogen er tom. Hvis katalogen inneholder ei fil eller underkataloger, vil rmdir beklage seg.
For å se på fila shell, kan vi bruke kommandoen
/home/larry/foo$ more shell
Hvis du vil vite hva shell inneholder, er det ei liste av gyldige skallprogram
i systemet ditt. På de fleste systemer, inkluderer det /bin/sh,
/bin/bash, og /bin/csh. Vi skal snakke om disse forskjellige skall-typene
senere.
Når du bruker more, vil [mellomrom-tasten] vise neste side av teksten, og [b] vil vise forrige side. Det er andre kommandoer tilgjengelig i more også, men disse er grunnkommandoene. Trykker du [q] vil more avsluttes.
Avslutt more og forsøk cat /etc/termcap. Teksten vil blafre forbi så fort at du ikke klarer å lese den. Navnet <<cat>> betyr egentlig <<concatenate>>, som er den egentlige hensikt med programmet. cat-kommandoen kan brukes til å flette sammen innholdet i flere filer, og lagre resultatet i en annen fil. Dette vil bli forklart senere.
Kommandoen som brukes for å lese manual-sidene er man. For eksempel, hvis du vil vite om det er andre opsjoner av ls kommandoen, taster du
/home/larry$ man ls
og manual-siden til ls vil komme fram.
Dessverre er de fleste av manual-sidene skrevet for dem som allerede har kunnskap om hva kommandoen eller ressursen gjør. Av denne grunn er manual-sidene vanligvis korte og inneholder kun den tekniske kjerne av detaljer om kommandoen, uten noen større veiledning. Men, manual-sider kan være en uvurderlig ressurs for å friske opp hukommelsen når du glemmer syntaksen til en kommando. Manual-sider vil også fortelle deg mye om kommandoer som vi ikke vil fortelle deg om i denne boka.
Jeg foreslår at du forsøker man på de kommandoer vi allerede har vært igjennom, og når jeg introduserer en ny kommando. Du vil finne at noen av disse kommandoer ikke har manual-sider. Det kan skyldes flere ting. For det første, er ikke manual-sidene skrevet ennå (LDP, Linux Documentation Project er ansvarlig for manual-sidene i Linux også. Vi akkumulerer gradvis de fleste manual-sidene for systemet). For det andre, kommandoen kan være en intern skallkommando, eller an alias (som diskutert i avsnitt 3.2.4), i noen tilfeller har den ikke en manual-side for seg selv. Et eksempel er cd, som er en intern skall kommando. Skallet utfører cd --- det er ikke noe separat program som inneholder denne kommando.
Legg merke til at opsjoner vanligvis begynner med en <<->>, og i de fleste tilfeller kan flere en-bokstavs opsjoner kombineres ved å bruke en enkel <<->>. For eksempel, isteden for å bruke kommandoen ls -l -F, holder det å bruke -lF.
Isteden for å liste alle opsjoner som er mulig for hver av disse kommandoene, vil vi bare snakke om dem som er nyttige eller viktige på dette stadiet. I virkeligheten har de fleste av disse kommandoene et stort antall opsjoner ( mange av dem vil du antakelig aldri bruke). Du kan bruke man til å se manual-sidene for hver kommando, som viser alle mulige opsjoner.
Merk deg også at mange av disse kommandoer tar en liste av filer eller kataloger som argument, angitt slik <<<file1> ... <fileN>>>. For eksempel tar cp kommandoen som argument en liste av filer fulgt av resultat-fil eller katalog. Når mer enn en fil skal kopieres, må resultatet være en katalog.
cd Endrer den gjeldene arbeidskatalog Syntaks: cd <katalog> <katalog> er katalogen du flytter til. (<<.>> refererer til gjeldende katalog, <<..>> foreldre katalog.) Eksempel: cd ../foo setter gjeldende katalog til ../foo ls Viser informasjon om navnets filer og kataloger. Syntaks: ls <file1> <file2> ... <fileN> Hvor <file1> til <fileN> er filnavn eller kataloger som skal vises. Opsjon: Det er flere opsjoner enn du ønsker å tenke på. Den mest brukte er -F (brukt til å vise informasjon om type fil), og -l (gir en lang <<long>> liste, inkludert filstørrelsen, eier, adgang, osv. Dette vil bli dekket i detalj senere.) Eksempel: ls -lF /home/larry vil vise innholdet av katalogen /home/larry. cp Kopierer fil(er) til en annen fil eller katalog. Syntaks: cp <file1> <file2> ... <fileN> <destination> mv Flytter fil(er) til en annen fil eller katalog. Denne kommando gjør det samme som å kopiere fulgt av sletting av originalen. Dette kan du bruke til å døpe om filer, som i MS-DOS kommandoen RENAME. Syntaks: mv <file1> <file2> ... <fileN> <destination> Hvor <file1> til <fileN> er filer som skal flyttes, og <destination> er bestemmelse/målet for filene eller katalogen. Eksempel: mv ../frog joe flytter fila ../frog til fila eller katalogen joe. rm Sletter filer. Når filer er slettet under UNIX, kan de ikke gjenopprettes (ulikt MS-DOS, hvor du vanligvis kan<<undelete>> fila). Syntaks: rm <file1> <file2> ... <fileN> Hvor <file1> til <fileN> er filnavnet som skal slettes. Opsjoner: -i vil be om bekreftelse før sletting av fila. Eksempel: rm -i /home/larry/joe /home/larry/frog sletter fila joe og frog i /home/larry mkdir Lager nye kataloger Syntaks: mkdir <dir1> <dir2> ... <dirN> Hvor <dir1> til <dirN> er kataloger som skal opprettes Eksempel: mkdir /home/larry/test lager katalogen test under /home/larry. rmdir Denne kommando sletter tomme kataloger. Når du bruker rmdir, må din nåværende arbeidskatalog ikke være med i de kataloger som skal slettes Syntaks: rmdir <dir1> <dir2> ... <dirN> Hvor <dir1> til <dirN> er kataloger som skal slettes. Eksempel: rmdir /home/larry/avhandling sletter katalogen /home/larry/avhandling, hvis den er tom. man Viser manual side for den gitte kommando eller ressurs (det vil si alle systemrutiner som ikke er en kommando, som bibliotek- funksjoner.) Syntaks: man <kommando> Hvor <kommando> er navnet på kommandoen eller ressursen som det ønskes forklaring på. Eksempel: man ls gir hjelp på ls kommandoen more Viser innholdet av navngitte filer, en skjerm av gangen. Syntaks: more <file1> <file2> ... <fileN> Hvor <file1> til <fileN> er filene som vises. Eksempel: more avhandling/historie-ferdig viser fila avhandling/historie-ferdig. cat For fletting av filer, cat brukes også til å vise innholdet av ei hel fil. Syntaks: cat <file1> <file2> ... <fileN> Hvor <file1> gjennom <fileN> er filer som skal vises. Eksempel: cat letters/fra-mdw viser fila letters/fra-mdw. echo Viser (ekko) det gitte argumentet. Syntaks: echo <arg1> <arg2> ... <argN> Hvor <arg1> til <argN> er argument som skal vises. Eksempel: echo <<Hallo verden>> viser strengen <<Hallo verden>>. grep Viser alle linjer i navngitt fil(er) som passer med mønsteret (pattern) Syntaks: grep <pattern> <file1> <file2> ... <fileN> Hvor <pattern> er et regulært utrykks-mønster, og <file1> til <fileN> er filene som skal gjennomsøkes. Eksempel: grep loomer /etc/hosts vil vise all linjene i fila /etc/hosts som inneholder mønsteret <<loomer>>.
Du har ferdighetene og kunnskap til å forstå hva jeg sier, og du har et veikart. (Referer til figur 3.2.8).
Bytt først til root katalogen (cd /), og skriv ls -F. Du vil antakelig se disse katalogene bin, dev, etc, home, install, lib, mnt, proc, root, tmp, user, usr, og var.
La oss se nærmere på hver av disse katalogene.
/bin /bin er forkortelse for <<binaries>>, eller kjørbare. Dette er
hvor katalogen mange sentrale systemprogram befinner seg. Bruk
kommandoen <<ls -F /bin>> til å liste filene her. Hvis du ser
nedover lista vil du se noen kommandoer du gjenkjenner, som cp,
ls, og mv. Disse er det du har brukt. Når du bruker cp kommando,
kjører du programmet /bin/cp. Bruker du ls -F, vil du se at de
fleste (hvis ikke alle) filene i /bin har an asterisk (<<*>>)
etter filnavnet. Dette indikerer at filene er kjørbare, som
beskrevet i avsnitt 3.3.2.
/dev Neste stopp er /dev. Ta en titt med ls -F igjen. <<Filene>> i
/dev er kjent som enhetsdrivere (device drivers) --- de brukes
til å aksessere systemets enheter og ressurser, som harddisker,
modem, hukommelse, osv. For eksempel, akkurat som du kan lese
data fra ei fil, kan du lese inndata fra ei mus ved å aksessere
/dev/mouse. Filnavn som begynner med fd er
floppy-diskettstasjoner. fd0 er den første
floppy-diskettstasjon, fd1 den andre. De kløktige av dere vil
legge merke til at det er flere floppy-diskettstasjoner enn de
to jeg nevnte ovenfor: Disse representerer spesielle typer
floppy stasjoner. For eksempel, fd1H1440 vil lese high-density,
3.5>> disketter i drive 1. Her er en liste over noen av de
vanligste enhetsfilene. Legg merke til at selv om du ikke har
noen av enhetene vist under, er det mulig at du vil ha dem i
/dev uansett. · /dev/console refererer til systemets konsolll --
dvs, monitor koplet direkte til systemet. · De forskjellige
/dev/ttyS og /dev/cua enheter brukes for å aksessere
serieportene. For eksempel refererer /dev/ttyS0 til <<COM1>>
under MS-DOS. /dev/cua enheten er <<callout>> enhet, som brukes
sammen med et modem. · Enhetsnavn som begynner med hd aksesserer
harddisker. /dev/hda refererer til første harddisk, mens hda1
refererer til første partisjon på /dev/hda. · Enhetsnavn som
begynner med sd er SCSI disker. Hvis du har en SCSI harddisk,
vil du isteden for å aksessere den med /dev/hda, bruke /dev/sda.
SCSI-tape er aksessert via st enheter, og SCSI CD-ROM via sr
enheter. · Enhetsnavn som begynner med lp aksesserer
parallell-porten. /dev/lp0 refererer til <<LPT1>> i MS-DOS
verden. · /dev/null brukes som et <<black hole>> --- data sendt
til denne enhet er borte for alltid. Hvorfor er dette nyttig?
Vel, hvis du ønsket å hindre utdata av en kommando å komme på
skjermen din , kunne du sende utdata til /dev/null. Vi skal
snakke mer om dette senere. · Enhetsnavn som begynner med
/dev/tty refererer til <<virtuelle konsoll>> på systemet ditt
(aksessert ved å trykke [alt-F1], [alt-F2], etc.). /dev/tty1
refererer til første VK, /dev/tty2 refererer til andre, osv. ·
Enhetsnavn som begynner med /dev/pty er <<pseudo-terminaler>>.
De brukes for å gi en <<terminal>> til eksterne
innloggingsesjoner. For eksempel, hvis din maskinen er på et
nettverk, vil inkommende telnet sesjoner bruke en av /dev/pty
enhetene.
/etc /etc inneholder mange forskjellige system konfigurerings-filer.
Disse inkluderer /etc/passwd ( bruker database), /etc/rc
(systemets initialiserings- skript), osv.
/sbin sbin er brukt for å lagre viktige system binærfiler, til bruk
for systemets administrator.
/home /home inneholder brukerens hjemmekataloger. For eksempel,
/home/larry er hjemme katalog for bruker <<larry>>. På et
ny-installert system, er det kanskje ingen brukere i denne
katalog.
/lib /lib inneholder delte bibliotekfiler (images). Disse filer
inneholder kode som mange programmer har felles. Istedet for at
hvert program har sin egen kopi av disse delte rutiner, er alle
lagret på et felles sted, i /lib. Dette gjør kjørbare filer
mindre, og sparer plass på systemet ditt.
/proc /proc er et <<virtuelt filsystem>>, filer som er lagret i
hukommelsen, ikke på disken. De refererer til forskjellige
prosesser som kjører på system, og tillater det å få informasjon
om hvilke program og prosesser det er som kjører til enhver tid.
Vi vil se mer detaljert på det i avsnitt 3.11.1.
/tmp Mange program trenger å generere informasjon og lagre det i en
temporær fil. Den tradisjonelle plassering for disse filer er i
/tmp.
/usr /usr er en meget viktig katalog. Den inneholder flere
underkataloger som igjen inneholder noen av de viktigste og
nyttigste program og konfigurerings-filer i bruk på systemet. De
forskjellige kataloger beskrevet over er sentale for at systemet
skal virke, men de fleste ting funnet i /usr er valgfri for
systemet. Men, det er disse valgfrie ting som gjør systemet
nyttig og interessant. Uten /usr, har du et mer eller mindre
kjedelig system, bare med program som cp og ls. /usr inneholder
de fleste større programvare-pakker og konfigurerings-filer som
ledsager dem.
/usr/X386 /usr/X386 inneholder X Window Systemet, hvis du installerte det.
X Window Systemet er et stort, kraftig grafisk miljø som
inneholder et stort antall av grafiske verktøy og programmer,
vist i <<windows>> på skjermen din. Hvis du kjenner Microsoft
Windows eller Macintosh miljøet, vil X Windows virke kjent.
Katalogen /usr/X386 inneholder all X Windows programmer,
konfigureringsfiler, og hjelpefiler. Dette vil bli dekket mer
detaljert i avsnitt 5.1.
/usr/bin /usr/bin er varehuset for programvare på et UNIX-system. Det
inneholder de fleste kjørbare programfiler som ikke finnes andre
steder, som /bin.
/usr/etc Akurat som /etc inneholder forskjellige system-program og
konfigurerings-filer, inneholder /usr/etc mer av disse
hjelpeverktøy og filer. Vanligvis er filer i /usr/etc ikke
viktige for systemet, ulikt hva de som finnes i /etc er.
/usr/include /usr/include inneholder include-filer for C-kompilatoren. Disse
filer (de fleste ender på .h, for <<header>>) deklarerer
datastruktur navn, subrutiner, og konstanter brukt for å skrive
C program. De filene som finnes i /usr/include/sys er mest brukt
for programmering på UNIX-system nivå. Hvis du er kjent med
programmeringsspråket C, vil du finne header filer som stdio.h,
som deklarerer funksjoner som printf().
/usr/g++-include /usr/g++-include inneholder inklude-filer for C++ kompilatoren
(likt /usr/include).
/usr/lib /usr/lib inneholder <<stubber>> og <<statiske>> bibliotek likt
de filene funnet i /lib. Når du kompilerer et program, blir
programmet <<lenket>> med bibliotek funnet i /usr/lib, som så
henviser programmet til å se i /lib når det trenger kode fra
biblioteket. I tillegg lagrer forskjellige andre program
konfigureringsfiler i /usr/lib.
/usr/local /usr/local er ganske likt /usr --- det inneholder forskjellige
program og filer som ikke er sentrale for systemet, men som gjør
systemet morsomt og spennende. Vanligvis finnes disse
spesialiserte program i /usr/local i systemet --- dvs skillet i
/usr/local er stort mellom forskjellige UNIX-system. Her vil du
finne store programvarepakker som TeX (et dokument
formatteringssystem) og Emacs (en stor og kraftig editor), hvis
du installerte dem.
/usr/man Denne katalog inneholder manual-sidene. Det er to underkataloger
for hver man side <<avsnitt>> (bruk kommandoen man man for
detaljer). For eksempel, /usr/man/man1 inneholder kilden (dvs,
den uformatterte original) til manual-sidene i seksjon 1, og
/usr/man/cat1 inneholder de formatterte manual-sidene for
seksjon 1.
/usr/src /usr/src inneholder kildekode (ikke-kompilerte program) for
forskjellige program på systemet. Den viktigste her er
/usr/src/linux, som inneholder kilde-koden til Linux kjerna.
/var /var inneholder kataloger som ofte endrer størrelse eller har
tendens til å vokse. Mange av disse katalogene bruker å finnes i
/usr, men siden vi forsøker å holde det relativt uendret, blir
kataloger som ofte endres flytttet til /var. Noen av disse
kataloger er:
/var/adm /var/adm inneholder forskjellige filer av interesse for
systemets administrator, spesielt system-logg, som registrerer
enhver feil eller problemer med systemet. Andre filer
registrerer innlogging i systemet, og mislykkede innloggings-
forsøk. Dette vil bli dekket i kapittel 4.
/var/spool /var/spool inneholder filer som skal <<spooles>> til et annet
program. For eksempel, hvis maskinen er koplet til et nettverk,
vil innkommende e-post bli lagret i /var/spool/mail, til du
leser det eller sletter det. Utgående eller innkommende
nyhetsartikler kan finnes i /var/spool/news, osv.
Mange av mulighetene som vil bli dekket i dette avsnittet, er egenskaper som skallet selv tilbyr. Vær forsiktig med å ikke blande UNIX ( et helt operativsystem) med skallet --- skall er bare et grensesnitt mot det underliggende systemet. Skallet tilbyr en stor funksjonalitet på toppen av UNIX selv.
Skallet er ikke bare en tolker for dine interaktive kommandoer, som du taster etter prompten. Det er også et kraftig programmeringspråk, som tillater deg å skrive skall-skript, til en <<batch>> av flere skall-kommander sammen i ei fil. MS-DOS brukere vil gjenkjenne likheten til <<batch filer>>. Bruk av skall-skript er et veldig kraftige verktøy, som tillater deg å automatisere og ekspandere din bruk av UNIX. Se avsnitt 3.13.1 for mer informasjon.
Det er flere typer av skall i UNIX. Hovedtypen er <<Bourne-skall>> og <<C-skall>>. Bourne-skallet bruker en kommando syntaks likt originale skall på tidlige UNIX-system, som System III. Navnet på Bourne-skallet på de fleste UNIX-system er /bin/sh (hvor sh står for <<shelll>>). C-skallet (ikke å forveksle med <<sea shell>>) bruker en annen syntaks, litt lik programmerings-språket C, og på de fleste UNIX-system er navnet /bin/csh.
Under Linux, er det flere varianter av disse skall tilgjengelig. De to vanligst brukte er Bourne Again Shell, eller <<Bash>> (/bin/bash), og Tcsh (/bin/tcsh). Bash er en form av Bourne-skallet med mange av de avanserte egenskaper som finnes i C-skall.
Fordi Bash støtter et supersett av Bourne skall-syntaksen, burde noen skall-skript skrevet i standard Bourne skall virke med Bash.
For de som foretrekker å bruke C-skall-syntaks, støtter Linux Tcsh, som er en utvidet versjon av det originale C-skall.
Typen av skall som du velger å bruke er nesten et religiøst spørsmål. Noen folk foretrekker Bourne-skallets syntaks med avanserte egenskaper fra Bash, og noen foretrekker mer strukturert C-skall syntaks. Når det gjelder normale kommandoer, som cp og ls, er typen av skall du ønsker å bruke uten betydning --- syntaksen er den samme. Bare når du begynner å skrive skall-skript eller bruke noen av de avanserte egenskaper ved skall, vil skillet mellom skall typene få noen betydning.
Når vi skal diskutere noen av egenskapene ved skall under, vil vi gjøre oppmerksom på forskjellene mellom Bourne- og C-skall. Men, i forhold til denne manual, er de fleste av disse forskjellene minimale. (Hvis du er virkelig nysgjerring på dette punkt, les manual-sidene for bash og tcsh).
Jokertegnet <<*>> refererer til alle bokstaver eller strenger av tegn i et filnavn. For eksempel, når du bruker tegnet <<*>> i et filnavn, vil skallet erstatte det med alle mulige kombinasjoner av filnavn i katalogen som du refererer til.
Her er et eksempel. La oss anta at Larry har filene frog, joe, og stuff i sin nåværende katalog.
frog joe stuff
/home/larry$
/home/larry$ ls
For å aksessere alle filer med bokstaven <<o>> i filnavnet,
kan vi bruke kommandoen
/home/larry$ ls *o*
frog joe
/home/larry$
Som du kan se, gjorde bruken av jokertegnet <<*>> at alle navn som
passet med jokertegnet ble erstattet med filnavn i nåværende
katalog.Bruken av <<*>> alene passer med alle filnavn, fordi alle tegn stemmer med dette jokertegn.
/home/larry$ ls *
frog joe stuff
/home/larry$
Her er noe eksempel til.
/home/larry$ ls f*
frog
/home/larry$ ls *ff
stuff
/home/larry$ ls *f*
frog stuff
/home/larry$ ls s*f
stuff
/home/larry$
Prosessen med å endre et <<*>> til filnavn blir kalt
jokertegn-ekspansjon og utføres av skallet. Dette er viktig: de
individuelle kommandoer, som ls, ser ikke <<*>> i
parameterlista. Skallet ekspanderer jokertegnet til å inkludere alle
filnavn som passer. Slik at kommandoen
/home/larry$ ls *o*
blir ekspandert av skallet til å bli
/home/larry$ ls frog joe
En viktig merknad om jokertegnet <<*>>. Bruk av dette jokertegn vil
ikke passe med filnavn som begynner med et punktum (<<.>>). Disse
filer behandles som skjulte (<<hidden>>) filer --- selv om de ikke
er virkelig skjult, vil de ikke vises i en normal ls listing, og blir
ikke rørt av bruken av <<*>>-jokertegnet.
Her er et eksempel. Vi har allerede nevnt at hver katalog har to spesielle innganger: <<.>> refererer til nåværende katalog, og <<..>> refererer til foreldre-katalogen. Men, når du bruker ls, vil ikke disse to dukke opp.
/home/larry$ ls
frog joe stuff
/home/larry$
Hvis du bruker -a bryteren med ls, kan du vise filnavn som begynner med
<<.>>. Observer:
/home/larry$ ls -a
. .. .bash_profile .bashrc frog joe
stuff
/home/larry$
Nå kan vi se to spesielle innganger, <<.>> og
<<..>>, og to andre <<skjulte>> filer---.bash_profile
og .bashrc. Disse to filene er oppstartfiler brukt av bash når
larry logger inn. Mer om dem i avsnitt 3.13.3.
Merk at når vi bruker jokertegnet <<*>>, blir ingen filnavn som begynner med <<.>> vist.
/home/larry$ ls *
frog joe stuff
/home/larry$
Dette er en sikkerhets-egenskap: hvis jokertegnet <<*>> passet
filnavn som begynner med <<.>>, ville det også passe
katalognavn <<.>> og <<..>>. Dette kan være
farlig når man bruker visse kommandoer.
Et annet jokertegn er <<?>>. Jokertegnet <<?>> vil bare ekspandere et enkelt tegn. Derfor vil <<ls ?>> vise alle et-tegns filnavn, og <<ls termca?>> vil vise <<termcap>> men ikke <<termcap.backup>>. Her er et annet eksempel:
/home/larry$ ls j?e
joe
/home/larry$ ls f??g
frog
/home/larry$ ls ????f
stuff
/home/larry$
Som du kan se, tillater jokertegn deg å spesifisere mange filer på
en gang. I den enkle kommando-oppsummering i avsnitt 3.4, sa vi at cp og
mv kommandoene faktisk kan kopiere eller flytte mange filer på en
gang. For eksempel,
/home/larry$ cp /etc/s* /home/larry
vil kopiere alle filnavn i /etc som begynner med <<s>> til katalog
/home/larry. Derfor er formatet til cp kommandoen egentlig
cp <file1> <file2> <file3> ... <fileN> <destination>
hvor <file1> til og med <fileN> er en liste av filnavn som skal
kopieres, og <destination> er destinasjons-fil eller katalog hvor de skal
kopieres til. mv har en identisk syntaks.Merk at hvis du kopierer eller flytter mer enn ei fil må <destination> være en katalog. Du kan bare kopiere eller flytte ei enkel fil til ei anna fil.
Her er et eksempel på kommandoen cat. Normalt leser cat data fra alle filnavn gitt på kommando-linja og sender disse data direkte til stdout. Derfor, ved å bruke kommandoen
/home/larry/avhandling$ cat historie-ferdig hoved-teser
vil innholdet av fila historie-ferdig vises fulgt av hoved-teser.Men, hvis ikke noe filnavn er gitt til cat som parameter, leses istedet data fra stdin, og det sendes tilbake til stdout. Her er et eksempel.
/home/larry/avhandling$ cat
Hello there.
Hello there.
Bye.
Bye.
[ctrl-D]
/home/larry/avhandling$
Som du kan se, blir hver linje som brukeren taster (vist i italics), med en
gang ekkoet tilbake av cat kommandoen. Når det leses fra standard
inngang, vet kommandoene at inndata er <<ferdige>> når de
mottar et EOT (end-of-text) signal. Vanligvis blir dette generert når det
trykkes [ctrl-D].
Her er et annet eksempel. Kommandoen sort leser tekstlinjer (igjen, fra stdin, hvis ikke filene er gitt på kommando linja), og sender sorterte utdata til stdout. Forsøk det følgende.
/home/larry/avhandling$ sort
bananas
carrots
apples
[ctrl-D]
apples
bananas
carrots
/home/larry/avhandling$
Nå kan vi alfabetisere vår handle-liste... er ikke UNIX nyttig?
/home/larry/avhandling$ sort > handle-liste
bananas
carrots
apples
[ctrl-D]
/home/larry/avhandling$
Som du kan se, blir ikke resultatet av sort kommandoen vist, istedet
blir det lagret i fila handle-liste. La oss se på denne fila.
/home/larry/avhandling$ cat handle-liste
apples
bananas
carrots
/home/larry/avhandling$
Nå kan vi sortere vår handleliste, og lagre den også! Men la
oss anta at vi lagret vår usorterte, originale handleliste i fila ting.
En måte å sortere informasjonen og lagre den i ei fil ville
være å gi sort filnavnet, i steden for standard inngang, og
omdirigere standard utgang som vi gjorde over. Slik:
/home/larry/avhandling$ sort ting > handle-liste
/home/larry/avhandling$ cat handle-liste
apples
bananas
carrots
/home/larry/avhandling$
Men, det er en annen måte å gjøre dette på. Ikke bare
kan vi omdirigere standard utgang, men vi kan omdirigere standard inngang
også, ved å bruke symbolet <<<>>.
/home/larry/avhandling$ sort < ting
apples
bananas
carrots
/home/larry/avhandling$
Teknisk, er sort < ting likt sort ting, men det første
tillater oss å demonstrere poenget: sort < ting oppfører
seg som om data i fila ting ble tastet til standard inngang. Skallet
håndterer omdirigeringen. sort ble ikke gitt navnet til fila
(ting); så når det gjelder sort, ble det fortsatt lest fra
standard inngang som om du hadde tastet data fra tastaturet ditt.
Dette introduserer konseptet et filter. Et filter er et program som leser data fra standard inngang, prosesserer det, og sender de prosesserte data til standard utgang. Ved å bruke omdirigering, kan standard inngang og/eller standard utgang bli referert fra ei fil.
sort er et enkelt filter: det sorterer innkommende data og sender resultatet til standard utgang. cat er enda enklere: det gjør ikke noe med de innkommende data, det gir bare ut det som ble gitt inn til det.
/home/larry/avhandling$ ls
engelsk-liste
historie-ferdig
hoved-teser
notater
/home/larry/avhandling$ ls > fil-liste
/home/larry/avhandling$ sort -r fil-liste
notater
hoved-teser
historie-ferdig
engelsk-liste
/home/larry/avhandling$
Her lagret vi utdata fra ls i ei fil, og så kjørte vi
sort -r på fila. Men dette er tungvint, og tvinger oss til å
bruke ei temporær fil til å lagre data fra ls.
Løsningen er å bruke rørlegging. Rørlegging er en annen egenskap ved skallet som tillater deg å flette en streng av kommandoer i et <<rør>>, hvor stdout fra første kommando blir sent direkte til stdin av andre kommando, osv. Her ønsker vi å sende stdout av ls til stdin av sort. Symbolet <<|>>brukes til å lage et rør:
/home/larry/avhandling$ ls | sort -r
notater
hoved-teser
historie-ferdig
engelsk-liste
/home/larry/avhandling$
Denne kommandoen er mye kortere, og opplagt lettere å taste.Et annet nyttig eksempel --- ved å bruke kommandoen
/home/larry/avhandling$ ls /usr/bin
vil ei lang liste av filer vises, de fleste vil fly over skjermen alt for raskt
til å lese dem. Isteden, la oss bruke more til å vise ei
liste av filer i /usr/bin.
/home/larry/avhandling$ ls /usr/bin | more
Nå kan du bla ned fil-lista i ditt eget tempo.Men det som er moro stopper ikke her! Vi kan rørlegge mer enn to kommandoer. Kommandoen head er et filter som viser de første linjer fra en inndata-strøm (her, inndata fra et rør). Hvis vi ønsket å vise filnavn i alfabetisk orden i nåværende katalog, kan vi bruke:
/home/larry/avhandling$ ls | sort -r | head -1
notater
/home/larry/avhandling$
hvor head -1 viser første linje av inndata den mottar (i dette
tilfelle, strømmen av baklengs-sorterte data fra ls).
/home/larry/avhandling$ ls > fil-liste
overskriver innholdet av fila fil-liste. Hvis du istedet omdirigerer med
symbolet <<>>>>,vil utdata bli skjøtet på den
navgitte fila, istedet for å overskrive den.
/home/larry/avhandling$ ls >> fil-liste
vil hekte på utdata av ls kommando til fil-liste.Husk at omdirigering og å bruke rør er tjenester gitt av skallet --- skall gir denne hendige syntaksen ved å bruke <<>>> og <<>>>> og <<|>>. Det har ingenting å gjøre med kommandoene selv, men med skallet.
UNIX tillater også filer å bli delt mellom brukere og grupper av brukere. Hvis Larry ønsket, kunne han sperre adgang til sine filer, slik at ingen andre brukerere fikk adgang til dem. Men på de fleste systemer er det normale å tillate andre brukere å lese dine filer, men ikke å endre eller slette dem.
Som forklart over, er hver fil eid av en bestemt bruker. Men filer er også eid av en bestemt gruppe, som er en system-definert gruppe av brukere. Hver bruker er plassert i minst en gruppe når en bruker blir opprettet. Men systemets administrator kan også gi brukere adgang til mer enn en gruppe.
Grupper er vanligvis definert ved typer av brukere som maskinen gir adgang. For eksempel, på et universitets UNIX-system, kan brukere bli plassert i gruppene student, stab, fakultet eller gjest. Det er også noen få system-definerte grupper (slik som bin og admin) som er brukt av systemet selv til å kontrollere adgang til ressurser --- meget sjelden trenger brukere å høre til disse system-gruppene.
Adgang faller i tre hovedeler: lese, skrive, og utføre. Disse adganger kan gis til tre klasser av brukere: eieren av fila, gruppen som fila tilhører, og til alle brukere, uavhengig av gruppe.
Lese-adgang tillater en bruker å lese innholdet av filer, eller for kataloger, å liste innholdet av katalogene (ved å bruke ls). Skrive-adgang tillater brukere å skrive til og endre fila. For kataloger, tillater skriveadgang bruker å lage nye filer eller slette filer i katalogen. Og til slutt, tillater utføre-adgang brukere å kjøre fila som et program eller skall-skript (dvs, hvis fila er et program eller skall-skript).
Å ha utføre-adgang i kataloger, tillater bruker å cd inn i disse katalogene.
/home/larry/foo$ ls -l stuff
-rw-r--r-- 1 larry users 505 Mar 13 19:05 stuff
/home/larry/foo$
Det første felt i lista representerer fil-adgang. Det tredje felt er
eieren av fila (larry), og fjerde felt er gruppen som fila tilhører
(users).
Siste felt er jo opplagt navnet på fila (stuff), og vi vil ta opp de andre feltene senere.
Denne fil er eid av larry, og tilhører gruppen users. La oss se på fil-adgangen. Strengen -rw-r--r-- viser, i rekkefølge, adgang gitt til filas eier, filas gruppe, og alle andres rettigheter.
Det første adgangs-tegnet i strengen (<<->>) representer typen fil. Et <<->> betyr at dette er en vanlig fil (i motsetning til en katalog eller en enhets-driver). De neste tre bokstaver (<<rw->>) representerer adgang gitt til filas eier, larry. <<r>> står for <<read>> og <<w>> for <<write>>. Dermed har larry lese- og skrive-adgang til fila stuff.
Som vi nevnte, er det ved siden av lese- og skrive-adgang, også <<utføre>> adgang ---representert med en <<x>>. Men, det er et <<->> her i stedet for <<x>>, så Larry har ikke utføre-adgang på denne fila. Dette er fint, fila stuff er ikke et program av noen type. Selvfølgelig, fordi Larry eier fila, kan han gi seg selv utføre-adgang for fila hvis han ønsker. Dette vil bli forklart om et øyeblikk.
De neste tre tegn, r--, representerer gruppenes adgang til fila. Gruppen som eier denne fila er users. Fordi bare en <<r>> finnes her, kan enhver bruker som tilhører gruppen users lese denne fila.
De siste tre tegn, også r--, representerer adgang gitt til alle andre brukere på systemet (andre enn eieren av fila og alle i gruppen users). Fordi bare en <<r>> er tilstede, kan andre brukere lese fila, men ikke skrive til den eller utføre/kjøre den.
Her er noen andre eksempler på gruppe adgang.
-rwxr-xr-x
Eier av fila kan lese, skrive, og utføre fila. Brukere i filas gruppe, og alle andre brukere, kan lese og utføre fila.
-rw-------
Eier av fila kan lese og skrive til fila. Ingen andre brukere har adgang til fila.
-rwxrwxrwx
Alle brukere kan lese, skrive, og utføre fila.
Med andre ord, for å ha adgang til ei fil i det hele tatt, må du ha utføre-adgang til alle kataloger langs filas stinavn, og lese- (eller utføre-) adgang til fila selv.
Vanligvis er brukere på et UNIX-system veldig åpne med sine filer. Det vanlige sett av adgang gitt til filer er -rw-r--r--, som vil tillate andre brukere å lese fila, men ikke endre den på noen måte. Det vanlige sett adgang gitt til kataloger er -rwxr-xr-x, som vil tillate andre brukere å se gjennom dine kataloger, men ikke lage eller slette filer innen dem.
Men, mange brukere ønsker å holde andre brukere ute av sine filer. Å sette adgang til ei fil til -rw-------, vil sperre andre bruker fra å få adgang til fila. På samme måte ved å sette adgang til en katalog til -rwx------, vil adgangen for andre brukere til den katalog det gjelder sperres.
chmod {a,u,g,o}{+,-}{r,w,x} <filnavn>
Kort, du angir en eller fler av, bruker, gruppe, eller andre. Så
spesifiserer du om du legger til rettigheter (+) eller tar dem bort (-). Til
slutt spesifiserer du en eller fler av lese, skrive, og utføre.
Noen eksempel på lovlige kommandoer:
chmod a+r stuff
Gir alle brukere lese-adgang til fila.
chmod +r stuff
Samme som over --- hvor ingen av a, u, g, eller o er spesifisert, er a
antatt.
chmod og-x stuff
Fjerne utføre-adgang fra andre brukere enn eieren.
chmod u+rwx stuff
Tillater eieren av fila å lese, skrive, og kjøre fila.
chmod o-rwx stuff
Fjerne lese-, skrive-, og utføre-rettighet fra andre brukere enn
eieren og brukere i filas gruppe.
$ ls -i foo
22192 foo
$
Her har fila foo et inode nummer 22192 i filsystemet. Vi kan lage en
annen lenke til foo, med navnet bar:
$ ln foo bar
Med ls -i ser vi at to filer har samme inode.
$ ls -i foo bar
22192 bar 22192 foo
$
Hvis du nå aksesserer enten foo eller bar vil du hente
samme fil. Hvis du endrer til foo, vil disse endringer bli gjort i
bar også. For all bruk er foo og bar nå samme
fil.Disse lenker er harde lenker fordi de lager en direkte lenke til en inode. Merk at du bare kan hard-lenkee filer i samme filesystem; symbolske lenker (se under) har ikke denne restriksjon.
Når du sletter ei fil med rm, sletter du bare en lenke til fila. Hvis du bruker kommandoen
$ rm foo
slettes bare lenkeen med navnet foo; bar vil fortsatt eksistere.
Ei fil slettes egenlig bare i systemet når den ikke har noen lenke til
seg.
Vanligvis har filer bare en lenke, så kommandoen rm sletter fila. Men, hvis ei fil har flere lenker til seg, vil rm bare slette en enkel lenke; for å slette fila, må du slette alle lenker til fila.
Kommandoen ls -l vil vise antall lenker til ei fil (blant andre informasjoner).
$ ls -l foo bar
-rw-r--r-- 2 root root 12 Aug 5 16:51 bar
-rw-r--r-- 2 root root 12 Aug 5 16:50 foo
$
Den andre kolonne i lista, <<2>>, angir antall lenker til fila.Som det viser seg, er en katalog bare ei fil med informasjon om lenke-til-inode oversettelse. Hver katalog har også, i det minste to harde lenker: <<.>> (en lenke som peker til seg selv), og <<..>> (en lenke som peker til foreldrekatalogen). Root katalogens (/) <<..>> lenke peker ganske enkelt tilbake til /.
Kommandoen ln -s vil lage en symbolsk lenke til ei fil. Hvis vi for eksempel bruker kommandoen
$ ln -s foo bar
vil vi lage en symbolsk lenke bar, som peker til fila foo. Hvis
vi bruker ls -i, vil vi se at to filer har forskjellige inoder.
$ ls -i foo bar
22195 bar 22192 foo
$
Men, med ls -l, vil vi se at fila bar er en symlenke som peker
til foo.
$ ls -l foo bar
lrwxrwxrwx 1 root root 3 Aug 5 16:51 bar -> foo
-rw-r--r-- 1 root root 12 Aug 5 16:50 foo
$
Adgangs-bitet til en symbolsk lenke er ikke brukt (de vises alltid som
rwxrwxrwx). Istedet er adgangen på en symbolsk lenke besemt ved adgangen
på målfilen til den symbolsk lenke (i vårt eksempel, fila
foo).
Funksjonelt er harde lenker og symbolske lenker det samme, men det er noen forskjeller. En er at du ikke kan lage en symbolsk lenke til ei fil som ikke eksisterer; det samme er ikke sant for harde lenker.
Symbolske lenker er prosessert i skallet som er forskjellig fra harde lenker. Dette er bare en teknisk forskjell, men noen ganger er den viktig. Symbolske lenker er nyttige fordi de identifiserer hvilken fil de peker til; med harde lenker er der ingen enkel måte å avgjøre hvilke filer som er lenket til samme inode.
Lenker er brukt på mange steder i Linux systemet. Symbolske lenker er spesielt viktig for delte biblioteksfiler (images) i /lib. Se avsnitt 4.7.2 for mer informasjon.
Hver gang du kjører et program, starter du en prosess --- som bare er et fantasifullt navn på det å kjøre et program. Kommandoen ps viser ei liste av prosesser som kjører nå. Her er et eksempel:
/home/larry$ ps
PID TT STAT TIME COMMAND
24 3 S 0:03 (bash)
161 3 R 0:00 ps
/home/larry$
PID vist i første kolonne er prosess ID, et unikt nummer gitt til hver
kjørende prosess. Den siste kolonnen, COMMAND, er navnet på en
kjørende kommando. Her ser vi bare på prosesser som Larry
kjører nå. Disse er bash
(Larry's skall), og ps-kommandoen selv. Som du kan se, kjører
bash alltid med ps-kommandoen. bash utfører
ps når Larry skrev kommandoen. Etter at ps er ferdig
å kjøre (etter at prosessene er vist), blir kontrollen returnert
til bash prosessen, som viser prompten, klar for en annen kommando.
En kjørende prosess er kjent som en jobb i skallet. Termene prosess og jobb er utbyttbare. Men, en prosess er vanligvis referert til som en <<jobb>> når den er brukt i sammenheng med en jobb-kontroll --- en egenskap ved skallet som tillater deg å bytte mellom flere uavhengige jobber.
I de fleste tilfeller kjører brukere bare en enkel jobb av gangen --- det er den kommando som de sist tastet til skallet. Men ved å bruke jobb-kontroll, kan du kjøre flere jobber på en gang, og bytte mellom dem når du behøver det. Hvordan kan dette være nyttig? La oss si at du redigerer en tekstfil og plutselig trenger å avbryte redigeringen for å gjøre noe annet. Med jobb-kontroll, kan du temporært suspendere editoren, og tilbake i skallprompten starte arbeid med noe annet. Når du er ferdig, kan du starte editoren, og være tilbake hvor du startet, som om du aldri forlot editoren. Dette er bare et eksempel. Det er mange praktiske bruk av jobb-kontroll.
Noen jobber tar lang tid å avslutte, og gjør ikke noe interressant mens de kjører. Kompilering er en slik jobb, eller å komprimere ei stor fil. Det er ingen grunn til at du skulle sitte å kjede deg mens disse jobber gjør ferdig sine oppgaver; du kan bare kjøre dem i bakgrunnen. Mens jobbene kjører i bakgrunnen, kan du fritt kjøre andre program.
Jobber kan også bli suspendert. En suspendert jobb er en jobb som ikke kjører i øyeblikket, men er temporært stoppet. Etter at du suspenderte en jobb, kan du be jobben å fortsette, i forgrunn eller bakgrunn etter behov. Å starte en suspendert jobb vil ikke endre jobbens status på noen måte --- jobben vil fortsette å kjøre fra der den ble stoppet.
Merk at suspendering av en jobb ikke er det samme som å avbryte en jobb. Når du avbryter en kjørende prosess (med å trykke avbrudds-tasten , som vanligvis er[ctrl-C]), drepes prosessen for godt. Når en jobb er drept, er det mulig å gjennoppta den; vil du, må du starte kommandoen på nytt. Merk også at noen program fanger opp avbrudd, så [ctrl-C] vi derfor ikke øyeblikkelig drepe jobben. Dette er for å tillate program å utføre nødvendige oppryddinger før jobben avsluttes. Noen program tillater faktisk ikke at du dreper dem med et avbrudd.
Forsøk det.
/home/larry$ yes
y
y
y
y
y
Y'ene vil fortsette ad infinitum. Du kan drepe prosessen ved å trykke
avbrudds-tasten, som vanligvis er [ctrl-C]. Så for at vi ikke skal slite
med sjenerende strømmer av y'er, la oss omdirigere standard utgang av
yes til /dev/null. Som du kanskje husker, virker /dev/null som et
<<sort hull>> for data. Alle data sendt til det vil forsvinne.
Dette er en effektiv metode å bli kvitt et ellers ordrikt program.
/home/larry$ yes > /dev/null
Ah, mye bedre. Ingenting skrives ut, men skall-prompten kommer ikke tilbake.
Det er fordi yes fortsatt kjører, og sender disse intetsigende
y'ene til /dev/null. Igjen, for å drepe jobben, trykk avbrudds-tasten.
La oss anta at vi ønsket at yes kommandoen skulle fortsette å kjøre, men ville hatt tilbake vår skall-prompt for å arbeide med andre ting. Vi kan legge yes i bakgrunnen, som vil tillate at det kjører, men uten å trenge noen interaksjon.
En måte å sette en prosess i bakgrunnen på er å hekte en <<&>> på enden av kommandoen.
/home/larry$ yes > /dev/null &
[1] 164
/home/larry$
Som du kan se, vi har vår skall-prompt tilbake. Men hva er dette
<<[1] 164>>? Og kjører yes kommandoen?
<<[1]>> representerer jobb nummeret for yes- prosessen. Skallet tilordner et jobb-nummer til hver kjørende jobb. Fordi yes er den eneste jobb vi kjører nå, er den tilordnet jobb nummer 1. <<164>> er prosess ID, eller PID, nummeret gis av systemet til jobben. Begge nummer kan brukes til å refere til jobben, som vi vil se senere.
Du har nå yes prosessen kjørende i bakgrunnen, den sender uavbrutt en strøm av y'er til /dev/null. For å sjekke status på denne prosess, brukes den interne skall-kommando jobs.
/home/larry$ jobs
[1]+ Running yes >/dev/null &
/home/larry$
Og ganske riktig, der er den. Du kunne også bruke ps kommandoen,
som demonstrert over, til å sjekke jobbstatus.
For å avslutte en jobb, brukes kommandoen kill. Denne kommando tar enten et jobbnummer, eller et prosess ID-nummer, som argument. Dette var jobb nummer 1, så kommando
/home/larry$ kill %1
vil drepe jobben. Når du vil identifisere en jobb med jobb-nummer,
må du sette prosent- (<<%>>) tegnet forran nummeret.
Nå når vi har drept jobben, kan vi bruke jobs igjen til å sjekke med:
/home/larry$ jobs
[1]+ Terminated yes >/dev/null
/home/larry$
Jobben er faktisk død, og hvis vi brukte jobs-kommandoen igjen
vil ingenting bli skrevet ut.Du kan også drepe jobber med prosess ID (PID)-nummeret, som er skrevet ut sammen med jobb ID når du starter jobben. I vårt eksempel, er prosess ID 164, så kommandoen
/home/larry$ kill 164
er den samme som
/home/larry$ kill $1
Du trenger ikke å bruke <<%>> når du refererer til en
jobb med dens prosess ID.
Først, start yes prosessen i forgrunnen, som du normalt ville:
/home/larry$ yes > /dev/null
Igjen, fordi yes kjører i forgrunnen, skulle du få din
skall-prompt tilbake.Istedet for nå å avbryte jobben med [ctrl-C], vil vi suspendere jobben. Å suspendere en jobb dreper den ikke; det stopper bare jobben temporært til du restarter den. For å gjøre dette, trykker du suspend-tasten, som vanligvis er [ctrl-Z].
/home/larry$ yes > /dev/null
[ctrl-Z]
[1]+ Stopped yes >/dev/null
/home/larry$
Mens jobben er suspendert, kjører den ikke. Ingen CPU-tid brukes til
jobben. Men, du kan restarte jobben, som vil få jobben til å
kjøre igjen som om ingenting hadde hendt. Den vil fortsette å
kjøre fra der den stoppet sist.For å restarte jobben i forgrunnen, brukes kommandoen fg (for <<foreground>>).
/home/larry$ fg
yes >/dev/null
Skallet skriver ut navnet til kommandoen igjen, så du er klar over
hvilken jobb du nettop satte i forgrunn. Stopp jobben igjen, med [ctrl-Z].
Denne gangen bruker du kommandoen bg for å sette jobben i
bakgrunn. Dette vil få kommandoen til å kjøre akkurat som om
du startet kommandoen med <<&>>, som i forrige avsnitt.
/home/larry$ bg
[1]+ yes >/dev/null &
/home/larry$
Og vi har vår prompt tilbake. jobs skulle rapportere at yes
kjører, og vi kan drepe jobben med kill som vi gjorde i sted.
Hvordan kan vi stoppe jobben igjen? Å bruke [ctrl-Z] vil ikke virke, fordi jobben er i bakgrunn. Svaret er å sette jobben i forgrunn, med fg, og så stoppe den. Som det viser seg, kan du bruke fg på enten stoppede jobber, eller jobber i bakgrunn.
Det er en stor forskjell mellom en jobb i bakgrunn og en jobb som er stoppet. En stoppet jobb kjører ikke --- dvs den bruker ikke noe CPU-tid og utfører ikke noe arbeid ( jobben opptar alikevel systemets hukommelse, selv om det kan overføres til harddisken). En jobb i bakgrunn kjører, og vil bruke hukommelse, såvel som å fullføre noen oppgaver, mens du gjør noe annet arbeid. Men en jobb i bakgrunn kan forsøke å vise tekst på terminalen, som kan være irriterende hvis du forsøker å arbeide med noe annet. For eksempel, hvis du brukte kommandoen
/home/larry$ yes &
uten å omdirigere stdout til /dev/null, vil en strøm av y'er
skrives til skjermen din, uten annen måte å avbryte den (du kan
ikke bruke [ctrl-C] til avbrudd av jobber i bakgrunn). For å stoppe de
endeløse y'ene, må du bruke kommandoen fg, for å
bringe jobben til forgrunnen, og så bruke [ctrl-C] for å drepe
den.
En annen merknad. fg og bg kommandoene er normalt forgrunn- eller bakgrunn-jobben som sist stoppet (indikert av en <<+>> etter jobbnummeret når du bruker kommandoen jobs). Hvis du kjører flere jobber på en gang, kan du sette en spesiell jobb i forgrunn eller bakgrunn ved å gi jobb ID som et argument til fg eller bg, som i
/home/larry$ fg %2
(til forgrunnjobb nummer 2), eller
/home/larry$ bg %3
(til bakgrunn jobb nummer 3). Du kan ikke bruke prosess ID-nummer med fg
eller bg.
Videre, ved å bruke jobbnummer alene, som i
/home/larry$ $2
er det samme som
/home/larry$ fg $2
Husk bare på at å bruke jobb-kontroll er en egenskap ved skallet.
Kommandoene fg, bg og jobs er interne i skallet. Hvis du av noen
grunner bruker et skall som ikke støtter jobb-kontroll, regn ikke med
å finne disse kommandoene tilgjengelige.
I tillegg, er det noen aspekter ved jobb-kontroll som er forskjellig mellom Bash og Tcsh. Noen skall har ikke jobb kontroll i det hele tatt --- men, de fleste skall i Linux har jobb-kontroll.
vi er ikke den letteste editor å bruke, ikke er den veldig selv-forklarende. Men, fordi den er så vanlig i UNIX verdenen, og at du til tider kan bli nødt til å bruke den, fortjener den litt dokumentasjon her.
Ditt valg av en editor er for det meste et spørsmål om Emacs --- en editor med flere egenskaper enn noe annet enkelt program i UNIX verden. For eksempel, har Emacs sin egen innebygde dialekt av programmerings-språket LISP, og har mange utvidelser (en av dem er et <<Eliza>>-likt AI-program). Men, fordi Emacs med alle sine hjelpefiler er relativt stor, kan du kanskje ikke få adgang til den på mange systemer. På den andre side, er vi liten og kraftig, men mer vanskelig å bruke. Men, snart vet du å finne fram i vi, det er egentlig veldig enkelt. Det er lære-kurven som noen ganger er vanskelig å komme over.
Dette avsnitt er en sammenhengende introduksjon til vi --- ikke alle egenskaper blir diskutert, bare de du trenger å vite for å komme igang. Du kan referere til manual-sidene til vi hvis du er interessert i å lære mer om denne editorens egenskaper. Eller, du kan lese boka <<Learning vi Editor>> fra O'Reilly og Associates. Se tillegg A for informasjon.
Når du starter opp vi, er du i kommando-modus. Denne modus tillater deg å bruke visse kommandoer for å redigere filer eller til å bytte til andre modi. For eksempel, å taste <<x>> i kommando-modus, sletter tegnet under markøren. Pil-tastene flytter markøren rundt i fila som du redigerer. Stort sett er kommandoer brukt i kommando-modus et eller to tegn langt.
Du setter inn eller redigerer tekst i insett-modus. Når du bruker vi, vil du antakelig bruke mest tid i denne modus. Du starter insett-modus ved å bruke kommandoen <<i>> (for <<insert>>) fra kommando-modus. Når du er i insett-modus, setter du tekst inn i dokumentet fra din nåværende markørposisjon. For å slutte insett-modus og returnere til kommando-modus, trykk [esc].
Siste-linje-modus er en spesiell modus brukt til å gi bestemte utvidede kommandoer til vi. Når du taster disse kommandoene, kommer de fram på siste linje av skjermen (derav navnet). For eksempel, når du taster <<:>> fra kommando-modus, hopper du til siste-linje-modus, og kan bruke kommandoer som <<wq>> (skrive til fila og avslutte vi), eller <<q!>> (avslutte vi uten å lagre endringer). Siste-linje-modus er stort sett brukt til vi kommandoer som er lenger enn ett tegn. I siste-linje-modus, skriver du en en-linje kommando og trykker [enter] for å utføre den.
Syntaksen for vi er vi <filnavn> hvor <filnavn> er navnet på fila at du ønsker å redigere.
Start opp vi med å skrive
/home/larry$ vi test
som vil redigere fila test. Du skulle se noe som dette:
--------------------------------------------------------------------------- _ ~ ~ ~ ~ >>test>> [New_file]---------------------------------------------------------------------------
Kolonnene med <<~>> tegn indikerer at du er i slutten av fila.
--------------------------------------------------------------------------- Nå er tiden for alle gode menn å komme selskapet til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
Mens du setter inn tekst, kan du taste så mange linjer som du ønsker (trykk [return] etter hver linje selvfølgelig), og du kan korrigere feil ved å bruke backspace-tasten. For å avslutte insett-modus, og returnere til kommando-modus, trykk [esc].
I kommando-modus, kan du bruke pil-tastene til å flytte rundt i fila. Her, fordi vi bare har en linje tekst, vil å bruke opp- eller ned-pil-tastene antakelig få vi til å bippe.
Det er flere måter å sette inn tekst på, andre enn ved å bruke kommandoen <<i>>. For eksempel, kommandoen <<a>> setter inn tekst etter nåværende markørposisjon, isteden for på nåværende markørenposisjon.
For eksempel, bruk venstre pil-tast til å flytte markøren mellom ordene <<gode>> og <<menn>>.
--------------------------------------------------------------------------- Nå er tiden for alle gode_menn å komme selskapet til unnsetning. ~ ~ ~ ~ ---------------------------------------------------------------------------
Trykk [a], for å starte insett-modus, tast <<lens>>, og så [esc] for kommando-modus.
--------------------------------------------------------------------------- Nå er tiden for alle gode lensmenn å komme selskapet til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
For å begynne insetting av tekst under nåværende linje, bruk kommando <<o>>. For eksempel, trykk [o] og tast inn en eller to nye linjer:
---------------------------------------------------------------------------
Nå er tiden for alle gode lensmenn å komme selskapet til unnsetning.
Etterpå skal vi gå ut etter pizza og øl_.
~
~
~
~
---------------------------------------------------------------------------
Husk at du til en hver tid enten er i kommando-modus (hvor kommandoer som i, a, eller o er gyldige), eller i insett-modus (hvor du setter inn tekst, fulgt av [esc] for å returnere til kommando-modus), eller siste-linje-modus (hvor du skriver utvidede kommandoer, som beskrevet under).
--------------------------------------------------------------------------- Nå er tiden for alle gode lensmenn å komme selskapet til unnsetning. Etterpå skal vi gå ut etter pizza og_ ~ ~ ~ ~ ---------------------------------------------------------------------------
Trykk nå [a], sett inn litt tekst, fulgt av [esc]:
--------------------------------------------------------------------------- Nå er tiden for alle gode lensmenn å komme selskapet til unnsetning. Etterpå skal vi gå ut etter pizza og Cola Light_. ~ ~ ~ ~ ---------------------------------------------------------------------------
Du kan slette hele linjer ved å bruke kommandoen <<dd>> (trykk [d] to ganger i rekkefølge). Hvis markøren din er på andre linje, og du taster dd,blir resultatet:
--------------------------------------------------------------------------- Nå er tiden for alle gode lensmenn å komme selskapet til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
For å slette ord som markøren er på, bruker du kommandoen <<dw>>.
Plasser markøren på ordet <<gode>>, og tast dw.
--------------------------------------------------------------------------- Nå er tiden for alle lensmenn å komme selskapet til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
Du kan erstatte deler av tekst ved å bruke kommandoen <<R>>. Plasser markøren på første bokstav i <<selskapet>>, trykk [R], og tast ordet <<fangene>>.
--------------------------------------------------------------------------- Nå er tiden for alle lensmenn å komme fangene til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
Å bruke R til å rediger tekst er det samme som med i- og a-kommandoene, men R skriver over tekst, isteden for å sette den inn.
Kommandoen <<r>> erstatter enkle tegn under markøren. Flytt for eksempel markøren til begynnelsen av ordet <<Nå>>, og tast r fulgt av F og du vil ha:
--------------------------------------------------------------------------- Få er tiden for alle lensmenn å komme fangene til unnsetning. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
<<~>> kommandoen endrer mellom stor og liten bokstav under markøren , og vise versa. For eksempel, hvis du plasserer markøren på <<å>> i <<Få>>, over, og repeterende trykker [~], vil du ende opp med:
--------------------------------------------------------------------------- FÅ ER TIDEN FOR ALLE LENSMENN Å KOMME FANGENE TIL UNNSETNING. ~ ~ ~ ~ ~ ---------------------------------------------------------------------------
Kommandoen <<w>> flytter markøren til begynnelsen av neste ord; <<b>> flytter den til begynnelsen av forrige ord.
<<0>> (altså null) -kommandoen flytter markøren til begynnelsen av nåværende linje, og <<%>>-kommandoen flytter den til enden av linjen.
Når du redigerer store filer, vil du ønske å flytte framover eller tilbake gjennom fila en skjerm av gangen. Å trykke [ctrl-F] flytter markøren en skjerm framover, og [ctrl-B] flytter den en skjerm tilbake.
For å flytte markøren til enden av fila, tast G. Du kan også flytte til en vilkårlig linje; for eksempel, å taste kommandoen 10G ville flytte markøren til linje 10 i fila. For å flytte til begynnelsen av fila, bruk 1G.
Du kan kople flytte-kommandoer med andre kommandoer, slik som sletting. For eksempel, kommandoen <<d%>> vil slette alt fra markøren til enden av linja; <<dG>> vil slette alt fra markøren til enden av fila, osv.
--------------------------------------------------------------------------- FÅ ER TIDEN FOR ALLE LENSMENN Å KOMME FANGENE TIL UNNSETNING. ~ ~ ~ ~ :_ ---------------------------------------------------------------------------
I siste-linje-modus, er visse utvidede kommandoer tilgjengelige. En av dem er <<q!>>, som avslutter vi uten å lagre. Kommandoen <<:wq>> lagrer fila og avslutter så vi. Kommandoen <<ZZ>> (fra kommando-modus, uten <<:>>) er likeverdig med <<:wq>>. Husk at du må trykke [enter] etter en kommando gitt i siste-linje-modus.
For å lagre fila uten å avslutte vi, brukes kun <<:w>>.
--------------------------------------------------------------------------- FÅ ER TIDEN FOR ALLE LENSMENN å KOMME FANGENE TIL UNNSETNING. ~ ~ ~ ~ ~ :e foo ---------------------------------------------------------------------------
Hvis du bruker <<:e>> uten å lagre fila første, vil du få en feilmelding
--------------------------------------------------------------------------- No_write_since_last_change_(:edit!_overrides) ---------------------------------------------------------------------------
som betyr at vi ikke ønsker å redigere en annen fil før du lagrer den første. Ved dette punkt, kan du bruke <<:w>> til å lagre original-fila, og så bruke <<:e>>, eller du kan bruke kommandoen
--------------------------------------------------------------------------- FÅ ER TIDEN FOR ALLE LENSMENN Å KOMME FANGENE TIL UNNSETNING. ~ ~ ~ ~ :e foo_ ---------------------------------------------------------------------------
<<!>> forteller vi at du virkelig mener det --- rediger ei ny fil og lagre endringene i den gamle først.
---------------------------------------------------------------------------
:r foo.txt
---------------------------------------------------------------------------
ville sette innholdet av fila foo.txt i teksten ved
nåværende markørplass.
---------------------------------------------------------------------------
:r! ls -F
---------------------------------------------------------------------------
vil du ende opp med
--------------------------------------------------------------------------- FÅ ER TIDEN FOR ALLE LENSMENN Å KOMME FANGENE TIL UNNSETNING. brev/ avhandling/ forskjellig/ ~ ~ ---------------------------------------------------------------------------
Du kan også kjøre en skallkommando (<<shell out>>) fra vi, med andre ord, kjøre en kommando inne fra vi, og returnere til editoren når du er ferdig. For eksempel, hvis du bruker kommandoen
---------------------------------------------------------------------------
:! ls -F
---------------------------------------------------------------------------
vil ls -F kommandoen bli utført, og resultatet vist på
skjermen, men ikke satt inn i fila som du redigerer. Hvis du bruker
kommandoen
---------------------------------------------------------------------------
:shell
---------------------------------------------------------------------------
vil vi starte et nytt skall, og tillate deg temporært å
<<stoppe>> vi mens du utfører andre kommandoer. Logg
ut av skallet (ved å bruke kommandoen exit) for å returnere
til vi.
Som vi har nevnt før, bruker forskjellige skall forskjellig syntaks når de utfører skall skript. For eksempel, bruker Tcsh en C-lik syntaks, mens Bourne-skallet bruker en annen type syntaks. I dette avsnitt, skal vi ta opp de mange forskjellene mellom de to, men vi vil anta at skall-skriptet er utført ved å bruke Bourne-skallets syntaks.
/home/larry$ cat kap1 kap2 kap3 > bok
/home/larry$ wc -l bok
/home/larry$ lp bok
ville skjøte sammen filene kap1, kap2, og kap3 og plassere
resultatet i fila bok. Deretter, ville antallet linjer i boka bli vist,
og tilslutt vil bok bli printet med lp kommandoen.Istedet for å taste alle disse kommandoene, kunne du gruppere dem i et skall-skript. Vi beskrev skall-skript kort i avsnitt 3.13.1. Skriptet skallet ville bruke til å kjøre alle disse kommandoer ville se slik ut:
#!/bin/sh # Et skall skript for å lage og printe bok cat kap1 kap2 kap3 > bok wc -l bok lp bokHvis dette skript var lagret i fila lagbok, kunne du ganske enkelt bruke kommandoen
/home/larry$ lagboktil å kjøre alle kommandoene i skriptet. Skall-skript er vanlige tekstfiler; du kan lage dem med en editor som emacs eller vi.6
La oss se på dette skall-skriptet. Første linje, <<#!/bin/sh>>, identifiserer fila som et skall-skript, og forteller skallet hvordan skriptet skal utføres. Det instruerer skallet til å gi skriptet til /bin/sh for kjøring, hvor /bin/sh er skall-programmet selv.
Hvorfor er dette viktig? På de fleste UNIX-systemer, er /bin/sh et skall av Bourne-typen, som Bash. Ved å tvinge skall-skriptet til å kjøre ved å bruke /bin/sh, er vi sikker på at skriptet vil kjøre under et Bourne-syntaks skall (istedet for, f.eks., et C-skall). Dette vil få skriptet ditt til å kjøre ved å bruke Bourne syntaks selv hvor du bruker Tcsh (eller et annet C-skall) som ditt innloggings-skall.
Den andre linja er en kommentar. Kommentarer begynner med tegnet <<#>> og fortsetter til enden av linja. Kommentarer blir ignorert av skallet --- de er vanligvis brukt til å identifisere skall-skriptet for programmereren.
Resten av linjene i skriptet er bare kommandoer, som du ville taste dem til skallet direkte. Faktum er at skallet leser hver linje av skriptet og kjører linje for linje som om du hadde tastet det fra skall-prompten.
Adgang er viktig for skall-skript. Hvis du lager et skall-skript, må du sikre at du har utføre-adgang til skriptet for å kjøre det. Kommandoen
/home/larry$ chmod u+x lagbok
kan bli brukt til å gi deg selv utføre-adgang til skall-skriptet
lagbok.
! Merk at Tcsh, såvel som andre C-typer skall, bruker en annen mekanisme for å sette variabler enn det som er beskrevet her. Denne diskusjonen antar bruk av et Bourne skall, slik som Bash (som du antakelig bruker nå). Se Tcsh manual-sidene for detaljer.
Når du tilordner en verdi til en variabel (ved å bruke <<=>> operatoren), kan du hente variabelen ved å sette en <<$>> foran variabel-navnet, som demonstrert under.
/home/larry$ foo=<<hello there>>
Variabelen foo er gitt verdien <<hello there>>. Du kan
nå refere til denne verdi med variabel- navnet, med <<$>>som
prefiks-tegn. Kommandoen
/home/larry$ echo $foo
hello there
/home/larry$
produserer samme resultat som
/home/larry$ echo <<hello there>>
hello there
/home/larry$
Disse variablene er interne i skallet. Det betyr at bare skallet kan få
adgang til disse variabler. Dette kan være nyttig i skall-skript; hvis du
trenger å holde styr på et filnavn, for eksempel, kan du lagre det
i en variabel, som over. Ved å bruke kommandoen set vil ei liste
av alle definerte skall-variabler vises.
Men, skallet tillater deg å eksportere variabler til omverden. Omverden (environment) er et sett av variabler som alle kommandoer du utfører har adgang til. Når du har definert en variabel i et skall, gjør eksport av den at variablen blir tilgjengelig for omverden også. Kommandoen export er brukt til å ekportere en variabel til omverden/miljøet.
! Igjen er det forskjell mellom Bash og Tcsh. Hvis du bruker Tcsh, er en annen syntaks brukt for å sette miljø-variabler (kommando setenv brukes). Se manual-sidene til Tcsh for mer informasjon.
Miljøet er veldig viktig for et UNIX-system. Det tillater deg å konfigurere visse kommandoer ved bare å sette variabler som kommandoene vet om.
Her er et kort eksempel. Miljø-variablen PAGER er brukt av kommandoen man. Den spesifiserer kommandoen for å vise manual-sidene en skjerm av gangen. Hvis du setter PAGER til å være navnet på en kommando, vil den bruke denne kommando til å vise manual-sidene, istedet for more (som er default).
Sett PAGER til <<cat>>. Dette vil få alle utdata fra man til å bli vist på skjermen på en gang, uten å bryte det opp i sider.
/home/larry$ PAGER=<<cat>>
Eksporter nå, PAGER til omgivelsene.
/home/larry$ export PAGER
Forsøk kommandoen man ls. Manual-sidene skulle nå
fly over skjermen uten pause.Hvis vi nå setter PAGER til <<more>>, vil more kommandoen bli brukt til å vise manual-sidene.
/home/larry$ PAGER=<<more>>
Merk at vi ikke har brukt export kommandoen etter at vi endret verdien
av PAGER. Vi trenger bare eksportere en variabel en gang; alle endringer
deretter vil automatisk bli overført til omgivelsen.
Manual-sidene for en bestemt kommando vil fortelle deg hvis kommandoen bruker noen miljø-variabler; for eksempel, man's man side forklarer at PAGER er brukt til å spesifisere side-kommandoen. Noen kommandoer deler miljøvariabler; for eksempel, mange kommandoer bruker EDITOR-miljøvariablen til å angi default editor til bruk når man trenger den.
Omgivelsen er også brukt til å holde styr på viktig informasjon om din innloggings-sesjon. Et eksempel er miljø-variablen HOME som inneholder navnet på din hjemme katalog.
/home/larry/avhandling$ echo $HOME
/home/larry
En annen interessant miljø variabel er PS1, som definerer
hoved-skall-prompten. For eksempel,
/home/larry$ PS1=<<Your command, please:>>
Your command, please:
For å sette prompten tilbake til vår vanlige (som inneholder
nåværende arbeids katalog fulgt av en <<$>> symbol),
Your command, please: PS1=<<\w$>>
/home/larry$
Bash manual-sidene beskriver syntaksen brukt for å sette prompten.
For eksempel, kan PATH variablen din være satt til:
/bin:/usr/bin:/usr/local/bin:.
Dette er ei liste av kataloger for skallet å søke gjennom, hvis
katalogene er skilt av en <<:>>. Når du bruker kommandoen
ls, leter skallet først etter /bin/ls, så /usr/bin/ls,
osv.Merk at PATH har ingenting å gjøre med å finne vanlige filer. For eksempel, hvis du bruker kommandoen
/home/larry$ cp foo bar
Skallet bruker ikke PATH til å lokaliser filene foo og bar ---
disse filnavn er antatt å være komplette. Skallet bruker bare PATH
til å finne cp programmet.
Dette sparer deg for mye tid; det betyr at du ikke trenger å huske hvor alle kjørbare kommando-filer er lagret. På mange systemer, er programfilene strødd rundt på mange plasser, slik som /usr/bin, /bin, eller /usr/local/bin. Istedet for å gi kommandoens fulle stinavn (som /usr/bin/cp), kan du ganske enkelt sette PATH til den liste av kataloger du ønsker at skallet automatisk skal søke i.
Merk at PATH inneholder <<.>>, som er nåværende arbeidskatalog. Dette tillater deg å lage et skall-skript eller program og kjøre det som en kommando fra din nåværende katalog, uten å måtte spesifisere det direkte (som i ./lagbok). Hvis en katalog ikke er i din PATH, da vil ikke skallet søke etter kommandoen --- dette inkluderer nåværende katalog.
Initialiserings-skriptene er ganske enkelt skall-skript, som beskrevet ovenfor. Men der er meget nyttige for å sette opp dine omgivelser, ved automatisk å utføre kommandoer når du logger inn. For eksempel, hvis du alltid bruker mail kommandoen til å sjekke om du har post når du logger inn, kan du plassere kommandoen i ditt initialiserings-skript slik at det blir utført automatisk.
Både Bash og Tcsh skiller mellom et innloggings-skall og andre bruk av skallet. Et innloggings-skall er et skall som utføres ved innlogging; vanligvis er dette det eneste skall du vil bruke. Men hvis du går ut (<<shell out>>) av et annet program, ved at du starter en annen kopi av skallet, er du ikke i ditt innloggings-skall. Når du i tillegg kjører et skall-skript, starter du automatisk en annen kopi av skallet for å utføre skriptet.
Initialiserings-filene som Bash bruker er: /etc/profile (satt opp av systemadministrator, utføres av alle Bash brukere ved innlogging), $HOME/.bash_profile (utført av en Bash innloggings-sesjon), og $HOME/.bashrc (utført av alle ikke-innloggings kopier av Bash). Hvis .bash_profile ikke finnes, blir .profile brukt istedet.
Tcsh bruker følgende initialiserings-skript: /etc/csh.login (utført av alle Tcsh brukere ved innlogging), $HOME/.tcshrc (utført ved innlogging og av alle nye kopier (instances) av Tcsh), og $HOME/.login (utført ved innlogging, fulgt av .tcshrc). Hvis .tcshrc ikke finnes blir .cshrc brukt istedet.
For fullt å forstå funksjonen til disse filene, trenger du å lære mer om skallet selv. Skall- programmering er et komplisert emne, langt utenfor denne bokas omfang. Se manual-sidene for bash og/eller tcsh for å lære mer om tilpassing av skall-miljøet ditt.
Et uunnværlig verktøy for å lære om systemet er å lese manual-sidene. Selv om mange av manual-sidene kan se forvirrende ut med de samme, er det et vell av informasjon å finne der hvis du graver under overflaten.
Vi foreslår også at du leser ei god bok om bruk av UNIX. Det er mye mer i UNIX enn det som du ser ved første øyekast --- dessverre er det meste av dette langt utenfor denne bokas rekkevidde. Forslag til noen gode UNIX bøker du kan lese, er oppført i tillegg A.