add_blank(". $n . ");"; } ?>
dölj finstilt
OBS! Sidan har ny adress:
[http://e-dog.info/t/63/doc/Ubuntu_skript.php]
Var vänlig uppdatera ert bokmärke.

Sidan är under uppbyggnad.
Senast uppdaterad:
den tredje april, 2011
[TA BORT MEDDELANDET]
[index]
[Tillbaka till: Ubuntu - Installation, partitionering. Grunder.]

Skript

Vad är skript?

- Rent formellt kan man säga att skript är program som inte kompileras (inte översätts till maskinspråk). (På denna sida står lite mer om vad kompilering är.) Det kan därför ofta gå snabbt och enkelt att sätta samman ett skript. (Man skriver bara några rader med en texteditor i en textfil.) I skriptspråk görs ofta anrop till systemkommandon för att snabbt och enkelt få programmet att utträtta det som efterfrågas.

Eftersom skript inte komplieras måste de översättas till maskinspråk medan de körs ("interpreteras"). Tidigare var detta en faktor att beakta eftersom interpreteringen gjorde att programmet fungerade långsammare. Numera har dock datorernas hårdvara förbättrats så påtagligt att denna aspekt inte behöver beaktas annat än för enstaka applikationer där hastigheten är avgörande. Det finns även olika sätt att underlätta för en server att tolka ("exekvera") PHP-koden.

Varför/Hur använder man skript?

- Den vanligaste användningen av skript är att automatisera uppgifter som ofta måste upprepas. Säkerhetskopiering är ett exempel. I detta fall kanske skriptet helt enkelt sparar en kopia av användarens hempartition. Här är ett exempel på ett sådant skript vilket också tilldelar kopian ett namn baserat på när kopian gjordes [ref.]:
#!/bin/bash
OF=/var/backup_min_hempartition_$(date +%Y%b%d_%H:%M).tgz
tar -cZf $OF /home/mitt_anvandarnamn/
Säkerhetskopians filnamn kommer t.ex. att bli:
backup_min_hempartition_2010sep04_15:20.tgz
Ett skript av denna typ kan aktiveras automatiskt, t.ex. varje natt, genom att man lägger in skriptets adress/namn i Linux-funktionen crontab.

En annan orsak att använda skript är att skapa web-sidor med "dynamiskt" innehåll. Man ändrar här sidans innehåll beroende på hur användaren navigerar inom sidan. Skriptet kan hämta och skriva data i databaser eller radikalt ändra sidans utseende allt efter hur användaren navigerar vidare. Allt detta går alltså att göra utan att behöva ladda in nya websidor vilket ju gör det snabbare och enklare att surfa till sajten.

Skript är vanligen högnivåspråk som inte direkt själva påverkar datorns hårdvaruadresser (De utför inte "låg-nivå-operationer". De kan dock anropa program som påverkar enstaka hårdvaruadresser.)

I motsats till låg-nivå-språk (som maskinspråk) så går det ofta fortare att utveckla program i skriptspråk och andra högnivåspråk eftersom deras kommandon "liknar det sätt en människa tänker och uttrycker sig på", det tycker jag i alla fall. Maksinspråk fordrar däremot att programmeraren mer anpassar sig till datorns uttryckssätt.

Utvecklingstiden för skript kortas ju ytterligare eftersom man inte heller måste översätta dessa till maskinkod inför varje testkörning. (De översätts/interpreteras under körningen.)

Att använda låg-nivå-språk (som t.ex. maksinspråk eller vissa delar av programmeringsspråket C) är däremot nödvändigt för att skriva program som påverkar enskilda minnesadresser eller måste fungera mycket snabbt (t.ex. drivrutiner och andra delar av kärnan, datorspel etc).

Det finns många fler anledningar att använda skript. Några av dessa beskrivs på denna sida under de stycken som handlar om "terminalen".

Vilket språk skall man använda för skript?

- Detta kan ofta vara en personlig fråga. bash är ju det grundläggande språk som finns på de flesta Unix-/Linux-system. bash utnyttjar systemets kommandon på ett omfattande sätt. Om man arbetar med Linuxsystem har man svårt att klara sig om man inte känner till bash.

Det finns dock andra alternativ som t.ex. PHP, AWK, Perl, "Ruby" (Ruby on Rails, "RoR") och Python. Vilket språk man väljer beror som sagt på personlig bakgrund och intresse. Själv använder jag gärna PHP. Det är lätt att fastna för PHP som är lättanvänt och tämligen sällan ger "onödiga" fel
PHP är ursprungligen konstruerat för att bygga upp websidor. PHP-programmet körs helt enkelt på servern och genererar den HTML-kod som bygger upp web-sidan. (Lösenord för databaser och annan känslig information ligger öppet i PHP-programmen. Den som surfar till en PHP-sida kommer inte åt PHP-koden utan presenteras alltid output från PHP-programmet, dvs HTML-koden.) PHP kan enkelt kontakta databaser (t.ex. MySQL) och på det sättet snabbt skapa websidor med variabelt innehåll. PHP fungerar även bra från terminalen. PHPs satser (syntax) liknar andra programmeringsspråk som t.ex. JavaScript eller C och kan därför av många uppfattas som ganska lättläst.

JavaScript är ju också ett skriptspråk som dock används mest på websidor. Programmet körs i webläsaren och av säkerhetsskäl omgärdas programmet av kraftiga restriktioner. Man kan ju t.ex. inte skriva eller läsa filer i datorn som tillhör den som surfar till sidan. (Det enda som kan skriva i användarens dator är korta textfiler s.k. kakor (cookies).)

PHP, JavaScript, AJAX
PHP kommunicerar bra med JavaScript. En väsentlig skillnad mellan dessa språk är att PHP körs redan när websidan skapas på web-servern medan JavaScript aktiveras ett ögonblick senare, när sidan laddats ner i web-läsaren. Man kan därför skicka ett värde från PHP till JavaScript. Skall man däremot skicka värden från JavaScript till PHP måste man antingen generera en ny PHP-sida eller använda JavaScript-funktionen AJAX ("Asynkron JavaScript och XML").

Via AJAX kan man aktivera PHP-sidor utan att ladda om den sida man befinner sig i. Dessa PHP-funktioner kan t.ex. hämta och analysera information från andra web-sidor (ofta via funktionen "curl") eller läsa/skriva databaser (ofta av typen MySQL). JavaScript-funktionen getElementById (och liknande) gör att de resultat man fått via AJAX kan användas för att direkt modifiera innehållet i den websida man befinner sig i. Man behöver alltså inte heller här ladda in någon ny sida, man kan presentera nytt material i den sida som besökaren redan kommit till. Web-sidor baseras ju på den så kallade DokumentObjektModellen (DOM) vilket innebär att sidan är organiserad i en trädstruktur. Om man så önskar kan man bygga om trädstrukturen (sidans utseende) medan besökaren befinner sig på sidan vilket kan användas för att förenkla besökarens tillgång till informationen på sidan.

Genom anrop till AJAX och getElementById kan man alltså kontinuerligt bygga om den web-sida som besökaren surfat till allt efter hur besökaren navigerar på sidan.

Det sätt som JavaScript kan lagra information i användarens dator är genom s.k. kakor (eng. cookies). En kaka är en (vanligen) kortare textfil. Varje webläsare har separata kakor för varje server (domän) användaren surfar till. När användaren så önskar kan den välja att radera alla kakor i sin webläsare.

En viktig egenskap hos JavaScript är att kunna komma åt de olika "objekt" (text, bilder och allt annat) som finns på en websida och ändra deras egenskaper utan att ladda om sidan.

Java och JavaScript är olika språk. Java är inget skriptspråk. Java kompileras men fungerar ändå på olika plattformar (t.ex. Linux, Windows). (På denna sida står lite mer om (På kompilering. För att fungera på olika plattformar så kompileras Java till s.k. "bytekode".) En likhet mellan Java, JavaScript och PHP är att de använder en syntax (skrivregler) som liknar syntaxen i programmeringsspråket C. Java körs ofta i applikationer (program) speciellt anpassade för websidor, s.k. "applets". Applets inkluderas i websidor lite grand på samma sätt som bilder fast fast applets utgör interaktiva program. Inom just detta användningsområde är Java liksom JavaScript omgärdat av stränga säkerhetsregler.


Programmeringsspråket PHP används ofta för att bygga upp websidor. PHP hämtar och skriver ofta data i databaser. Man installerar då en PHP-server som komplement till sin webserver. Därigenom kan websidor som innhehåller PHP-kommandon aktivera dessa kommandon. Websidor som avänder PHP-komandon har fil-extensionen ".php".

PHP kan även användas i skrivbordsdatorn. (Alltså inte bara i webservrar för att skapa websidor.) För att använda skript i PHP från terminalen (kommandoraden) kan man göra så här:

1. installera php för terminalen
sudo apt-get install php5-cli
2. verifiera att den installerats rätt
$ sudo which php
/usr/bin/php
3.skriv ett skript (php_cli_test) - se exempel nedan
4. gör filen körbar
sudo chmod +x php_cli_test
5. kör filen
./php_cli_tst

Här är exempel på hur några kommandon kan se ut i ett PHP-skript.
Skriptet byter ut ordet "lång" mot ordet "kort".
Skriptet adderar värdet ett till variabeln "nisse".
Skriptet listar filerna i den aktuella mappen.
$ cat php_cli_test
#!/usr/bin/php
<?
$pelle = 'Detta är en lång mening.



';
$pattern = '/lång/';
$replace_string = 'kort';
$pelle = preg_replace($pattern, $replace_string, $pelle);
echo $pelle;
$nisse = 3;
$nisse++;
if ($nisse == 4) {
echo 'nisses värde är fyra

';
}
echo shell_exec('ls');
?>
Här används funktionen shell_exec för att anropa bash-kommandot ls (lista filer i katalogen). Vill man göra ett "rent" PHP-program krävs lite mer jobb på denna punkt. Just detta "korsanropande" mellan t.ex. bash och PHP kan vara mycket tidsbesparande när man tar fram skript.

Detta skript körs från terminalen för att skapa en textfil i skrivbordsdatorn. Man kunde emellertid lika gärna ha skriptet i webservern för att generera en websida. Om man vill skriva ut till websidor istället för till terminalen är de viktigaste förändringarna:
1. Byt \n (ny rad) mot <br> (Ny rad representeras i html som <br>. Byt gärna \n mot \n<br> så blir web-sidans källkod mer lättläst.)
2. Byt blanka mot &nbsp; (Annars kommer flera blanka i rad att se ut som en blank.)

Här är resultatet när man kör skriptet:
$./php_cli_test
Detta är en kort mening.



nisses värde är fyra

bild003.jpg
bulle
kalle001.jpg
kalle002.jpg
lisa001.jpg
lisa002.jpg

Motsvarande bash-kommandon kan se ut så här:
$ cat bash_tst
#!/bin/bash
pelle='Detta är en lång mening.\n\n\n'
pattern='lång'
replace_string='kort'
pelle=`echo $pelle | sed -e "s/$pattern/$replace_string/"`
echo -e $pelle;
nisse=3
let nisse=$nisse+1
if [ $nisse -eq 4 ]; then
echo -e 'nisses värde är fyra\n'
fi
ls -1

Speciellt när man använder bash måste man följa skrivreglerna noggrant. Se t.ex. till att blanktecken hamnar på rätt ställen PHP är mer förlåtande på denna punkt, tycker jag.
När man skall skriva in ny rad i textsträngar kan flera sätt bli aktuella:
1. vagnretur/enter
2. omvänt snedtecken följt av vagnretur/enter
3. \n
(Om PHP-skriptet ovan skulle användas på en websida så är det vanliga att man anger ny rad i källkoden som \n, inte som vagnretur/enter i exemplet ovan.)
Det omvända snedtecknet (\) används ofta för att citera det tecken som följer. Skall man skicka ett omvänt snedtecken genom flera stränghanteringssystem måste man tänka sig för. Ett omvänt snedtecken representeras t.ex. i en variabel i preg_replace med tre omvända snedtecken!





Kommunikation mellan websidor
[Detta stycke har bara påbörjats]
1. GET-variabler
2. POST-variabler
3. client side cookies
4. session, server side cookies


cgi skript
PHP är alltså ett språk som utvecklats för web-sidor, men som ovan beskrivits även kan användas från teminalen (t.ex. skrivbordsmiljön/arbetsstationen).

Språket bash har däremot sitt ursprung i Linux terminalmiljö. (Mer om den på denna sida.) Den som gärna använder bash i terminalen kan också använda det på web-sidor genom att köra programmet via "CGI" (Common Gateway Interface). I typfallet gör man bara en fil med extensionen "cgi" körbar ("chmod +x mitt_skript.cgi") och lägger i därför avsedd mapp på webservern (mappen brukar ofta heta "cgi" eller "cgi-bin"). Även argument i webadressen (av typen http://example.com/cgi-bin/mitt_skript.cgi?data_1=kalle&data_2=vera) kan skickas till dessa program. På detta sätt kan man alltså använda bash för att skapa web-sidor. Rent allmänt tycker nog dock de flesta att PHP är lite mer lätthanterligt än bash för web-programmering. För den som har stor vana vid bash eller behöver använda speciella systemfunktioner kan dock bash via CGI vara ett alternativ. (Även PHP kan dock anropa Linux systemfunktioner genom funktionen shell_exec. Databasen MySQL kan nås från både PHP och bash.)

bash ger alltså direkt tillgång till Linux systemfunktioner. bash uppvisar dock ofta lite längre och mer sammansatta uttryck än PHP. Som exempel kan ges hur man hämtar argument. (Argument är värden som man anger när man anropar skriptet och som skriptet sedan kan använda i sin funktion.) I bash måste man själv dela upp strängen med argument. Här hämtas ett numeriskt argument med beteckningen "id":
ID=`echo "$QUERY_STRING" | grep -oE "(^|[?&])id=[0-9]+" | cut -f 2 -d "=" | head -n1`
I PHP får man argumenten "serverade" direkt:
$ID = $_GET['id'];
Anropet till denna sida skulle kunna se ut så här:
http://example.com/cgi-bin/mitt_skript.cgi?id=1234
Generellt är det kanske också lite lättare att blanda HTML-kod (som bygger upp web-sidor) med PHP än med bash. Naturligtvis är dessa skillnader små "om man bara vänjer sig" men lite skämtsamt kanske kan man säga att den som vill bygga upp en site mha bash skall nog gilla att "käka taggtråd till frukost"

Reguljära uttryck
Vill man dra maximal nytta av de textredigerare och program som används i terminalen kan man överväga att lära sig s.k. reguljära uttryck ("regexpar", eng. regular expressions, "regex", "regexp"). Reguljära uttryck utgör ett sätt att beskriva uttryck av bokstäver/siffror (s.k. strängar). (Lite mer formellt kan man säga att ett reguljärt uttryck motsvaras av en mängd (eng. set) av strängar.) Reguljära uttryck gör att redi­gerings­programmen kan finna önskade textpartier. Vill man t.ex. finna - och ev. ta bort - alla blanka i början på en rad skriver man: ^[ \t]+ (^ betyder radbörjan och \t motsvarar tabulatortangenten).

[] används för att ange vilka alternativa tecken som skall ingå i sökmönstret (i exemplet blank eller \t).
[A-Za-z0-9] motsvarar alla "alfanumeriska" tecken (dvs stora och små bokstäver samt siffror).
Vill man ange alternativa ord ("strängar") använder man denna konstruktion istället:
sed 's/\(Kalle\|Nisse\)/Pelle/'
uttrycket byter Kalle eller Nisse mot Pelle
Exemplen med regular expressions visas ibland som sed-kommandon. sed är en textredigerare ("editor") som ofta används för att redigera textfiler "off-line", dvs man öppnar inte filen "för hand" och ger kommandona via tangentbordet. I stället ger man kommandon när man startar programmet via terminalen eller via en kommandofil. (Detta kan alltså vara en tidsbesparande metod om man behöver redigera många filer på samma sätt.) I exemplet ovan anger "sed 's" att sed skall användas för att byta text (s=substitute). Vad som skall bytas ut och till vad det skall bytas ut anges mellan de följande snedtecknen (/).

De tre specialtecknen ? * + kan användas för att ange hur många gånger det föregående uttrycket/tecknet skall upprepas:
? noll eller en gång (det föregående tecknet får ingå men det är ej nödvändigt)
* noll eller fler gånger
+ en eller fler gånger
sed 's/haj\(ar\)\?/guldfisk/g' byter haj och hajar mot guldfisk

Upprepar man ett sökmönster med stjärnan så kommer det längsta möjliga sökmönstret att matchas:
echo 'ett två hej tre hej fyra hej fem sex' | sed 's/^.*hej//;' | sed 's/^.*\x0//'
fem sex
(Här byts hej ut mot ett icke skrivbart tecken vilket i nästa kommando används för att bestämma hur lång del av strängen som skall tas bort.)

Vill man förkorta sökmönstret och t.ex. bara inkludera text upp till den andra förekomsten av sökmönstret skriver man:
echo 'ett två hej tre hej fyra hej fem sex' | sed 's/hej/\x0/2;' | sed 's/^.*\x0//'
fyra hej fem sex
("/2" anger att man söker fram till den andra förekomsten.)

Söker man på enstaka tecken och önskar ett så kort sökmönster som möjligt kan säga att sökmönstret icke (^) får innehålla ett visst tecken (i detta fall ">"). En enkel regexp för att ta bort html-taggar kan då bli:
echo 'one two <tag> three </tag> four' | sed 's/<[^>]\+>//g'
one two three four

Liknande resultat uppnås om man anger att sökmönstret endast får innehålla bokstäver (A-Z, a-z), siffror (0-9) blanka och snedtecken (/).
echo 'one two <tag> three </tag> four' | sed 's/<[A-Za-z0-9 /]\+>//g'
one two three four


Ett par användbara förkortningar är \w som motsvarar tecknen a-zA-Z0-9_ samt \b som motsvarar gränsen mellan a-zA-Z0-9_ och andra tecken

Här följer några fler exempel på reg-expar som kan användas för att tolka HTML-kod.:
<([^>]*?)> (alla html taggar, här anger frågetecknet att stjärnan är s.k. "lazy star")
<[^\/][^>]*?> (alla start-taggar (/ skall föregås av \ för att inte tolkas som slut pa sökmönstret))
<\/[^>]*?> (alla stopp-taggar)
<a [^>]*?> (alla a (start) taggar)
<\/a[^>]*?> (alla a (stopp) taggar)
<\/?a( [^>]*)?> (alla a (start eller stopp) taggar)
<img .*?> (alla img-taggar)
<\/?p( [^>]*)?> (alla p (start eller stopp) (men inte t.ex. pre) taggar)
    här anger frågetecknet att mönstret innan inte måste finnas
<(?=[^>]*(kanin|morot))[^>]*> (alla html-taggar som innehåller 'kanin' eller 'morot')
<(?![^>]*(kanin|morot))[^>]*> (alla html-taggar som inte innehåller 'kanin' eller 'morot')
Accepterar man både stora och små bokstäver lägger man till växeln "i". Hela sökmönstret kan då se ut så här.
/<div( [^>]*)?>/i (alla div (start) taggar
/<\/div( [^>]*)?>/i (alla div (stopp) taggar
/<\/?div( [^>]*)?>/i (alla div (start eller stopp) taggar
Regexpar kan användas för jämförelse ("matchning") av text-strängar. Vill man i PHP plocka ut länkadressen ur alla a-taggar skriver man:
preg_match("/<a href=\"?([^ \"]*?)\"?( [^>]*)?>/", $string, $matches);
Länkadressen finns nu i variabeln $matches[1]. (Det första uttrycket inom parentes i sökmönstret lagras i $matches[1], det andra i $matches[2] etc)

Vissa system tillåter att man anger ett frågetecken för att få den kortaste matchande strängen. man kan då skriva t.ex. "<.*?>" för att hitta en html-tagg. (På engelska kallar man då .* för en "eager star" och .*? för en "lazy star") Om sed på det aktuella systemet inte tillåter detta kan man (i t.ex. Ubuntu) istället använda Perl:
$ echo 'ett två hej tre hej fyra fem' | perl -pe 's/^.*hej//'
fyra fem
$ echo 'ett två hej tre hej fyra fem' | perl -pe 's/^.*?hej//'
tre hej fyra fem


Vill man upprepa ett sökmönster anges detta med siffror inom klamrar:
echo '20 1010 22300 600 8975 18976' | sed 's/\b[0-9]\{3,4\}\b//g'
20 22300 18976
Det beskrivna mönstret tar alltså bort tal mellan 100 och 9999 (tal med tre eller fyra siffror).

Det finns också en operator "t" vilken upprepar ett kommando från en markör (i detta exempel "a") så länge kommandot påverkar filen:
$ cat tst
Behåll blanka  här %%%% Byt blanka  mot understrykning här
$ cat tst | sed -r ':a;s/^(.*% [^ ]*) /\1_/;ta'
Behåll blanka här %%%% Byt_blanka__mot_understrykning_här

Tycker man det känns ovant att göra loop-kommandon med reguljära uttryck, kan man göra loopen med skript istället. Så här kan det se ut i PHP.
$string = "Behåll blanka här %%%% Byt blanka mot understrykning här";
$count = 1;
while ($count > 0) {
$string = preg_replace("/%(.*) (.*)/", "%\\1_\\2", $string, -1, $count);
}


För att upprepa ett kommando på alla udda rader skriver man (start~step)
$ cat tbd | sed -n '1~2p'


Lookaround
Vill man söka på hela strängar (ord) så kan man använda s.k. "lookaround". Beroende på om man tittar på strängen efter eller före kallas det "look ahead" eller "look back". Beroende på om man kräver att strängen skall eller inte skall vara inkluderad kallar man look around för "positiv" eller "negativ". Negativ look around kan vara speciellt användbart för att kunna utesluta ett ord ur söksträngen. här är några exempel i PHP baserade på dessa länkar [phpro, reg-exp]. Funktionen preg_match anger hur många gånger ett mönster återfunnits. Funktionen preg_replace byter ut ett mönster mot en sträng.
positive look ahead
(?=regex)
match "eg" immediately followed by a colon
$string = 'This is an example eg, foo'; // no match
$string = 'This is an example eg: foo'; // match
if(preg_match("/eg(?=:)/", $string, $match)) ...

negative look ahead
(?!regex)
match "white", not immediately followed by "house"
$string = 'I live in the whitehouse'; // no match
$string = 'I live in the white house';  // match
if(preg_match("/white(?!house)/i", $string)) ...

positive look behind
(?<=regex)
match "house" immediately preceded by "white"
$string = 'I live in the white house'; // no match
$string = 'I live in the whitehouse'; // match
if(preg_match("/(?<=white)house/i", $string)) ...

negative look behind
(?<!regex)
match "house", not immediately preceded by "white"
$string = 'I live in the whitehouse'; // no match
$string = 'I live in the bluehouse';  // match
if(preg_match("/(?<!white)house/i", $string)) ...

Vill man utesluta fler ord ur söksträngen kan man även
lägga till dessa åtskilda med "|".
$string = "mango-sour , banana-sour , lemon-sour , papaya-sour , grapefruit-sour , cherry-sour";
echo preg_replace("/(?<!lemon|grapefruit)-sour/", "\\1-sweet", $string);
mango-sweet , banana-sweet , lemon-sour , papaya-sweet , grapefruit-sour , cherry-sweet

Man kan alltså inkludera fler strängar i sökmönstret på detta vis:
(rose|tulip) - "rose" eller "tulip"
$string = " cat rose dog tulip parrot ";
$string = preg_replace("/(rose|tulip)/", "flower", $string);
echo $string;
// echoes: cat flower dog flower parrot 
Man kan även kräva att ord i sökmönstret avgränsas som egna ord och inte utgör sammanskrivningar:
(\brose\b|\btulip\b) (\b = word boundary)

Reguljära uttryck liknar de "wildcard characters" (sv. "jokertecken") som finns i de flesta operativsystem. I uttrycket fil_*.txt motsvarar "*" en godtycklig teckenkombination. Uttrycket motsvarar alltså t.ex. fil_1.txt, fil_33_Z.txt eller fil_abc.txt.

Man kanske kan säga att funktionen av reguljära uttryck motsvaras av s.k. "makros" i den grafiska miljön. Makros är helt enkelt en följd av tangenttryckningar som sparats.

Här är några enkla varianter av reguljära uttryck som kan användas för att finna vissa strängar:
uttryck betydelse
</?tag> <tag> och </tag>
<tag\b[^>]*>([^<]*)</tag> allt mellan <tag> och </tag> fungerar ej med "nested tags"
\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b IP-nummer (\b används för att avgränsa uttryck med bokstäver, siffror och "_")


Byta namn på filer
Vill man byta namn på en fil skriver man:

mv gammalt_filnamn nytt_filnamn

Kommandot mv (move) kan, som beskrivits, även användas för att flytta en fil till en mapp:
mv filnamn mapp_namn

När man byter namn på flera filer samtidigt i terminalen måste man tänka på vissa saker. Om man t.ex. vill byta filändelsen på alla sina .html-filer till .htm kan man inte göra mv *.html *htm Istället kan man t.ex använda kommandot rename:
rename -n -v s/\.html$/\.htm/ *.html
"-n -v" gör att kommandot bara är en testkörning så att man ser hur filnamnen kommer att ändras. När man är nöjd med resultatet tar man bort "-n -v" och kör "på riktigt".
Uttrycket
s/från/till/
anger hur utbytet kommer att ske. Vill man veta mer om detta kan man läsa om editorn (textredigeraren) sed (s står för substitute).

Man kan också använda skript. Vill man byta namn på alla filer som börjar med IMG_ till bild_ så skriver man:
for i in IMG_*; do newname=`echo $i|sed 's/^IMG_/bild_/g'`; mv $i $newname; done

Programmet sed används ofta för att byta ut förekomsten av en textsträng mot en annan.

Uttrycket ovan är ju ganska krångligt. Längre ner förklaras lite mer om namnbyten och skript i allmänhet.

Linux är ett "filorienterat" operativsystem. En konsekvens av det är att mappar ("directories", "kataloger") betraktas som filer. Man kan därför t.ex. inte ha en mapp och en fil med samma namn i samma mapp.

Linux tillåter nästan alla specialtecken i filnamnen. Det brukar dock vara säkrast att bara använda siffror, bokstäver, understrykningstecken, punkt och bindestreck i fil- och mapp-namn. Man brukar heller inte starta filnamn med bindestreck (detta kan tolkas som tilläggskommando ("option", "switch")). Filnamn som börjar med punkt är dolda filer.

Använder man blanka i filnamnen måste man ju visa för systemet att mellanslagen ingår i filnamnet:
cat 'Nisse och Vera'
eller
cat Nisse\ och\ Vera

(Den som inte använder terminalen för namnbyte av fler filer samtidigt använder istället ofta filhanteringsprogrammet Thunar som enkelt installeras och körs på vanligt (grafiskt) sätt i skrivbordsmiljön.)



Pipes
Operatorn | kan användas för att skicka output från ett kommando/program till ett annat (genom en s.k. "pipe"). Ett exempel på ett kommando som tar reda på antalet filer i den aktuella mappen är detta:
ls | wc -l
Kommandot ls (list) listar filernas namn och kommandot wc (wordcount) räknar antalet ord.
För att inkludera alla undermappar gör man:
find mappNamn -type f | wc -l
För att ta reda på en mapps storlek gör man:
du -hs mappNamn


Vill man spara output i en fil använder man operatorn > åtföljd av filnamnet, t.ex. >resultat .
Det följande exemplet lagrar först fillistan i filen "slask", därefter används filen "slask" som input till programmet wc.
ls > slask
wc -l < slask

Här används fillistan i filen "slask" som input till programmet wc och output skickas till filen "slask2".
wc -l < slask > slask2

Programmet cat listar en fil. I detta exempel skickas fillistan till programmet wc (och resultatet från wc sänds vidare till skärmen).
cat slask | wc -l

Vill man lägga till innehållet i en fil i slutet på en annan fil ("konkatenera", "append") använder man operatorn ">>". Här är två exempel.
cat fil_01 >> fil_02
cat slask | wc -l >> fil_03
Om den fil dit man ämnar lägga till något inte existerar så skapas den och operatorn ">>" fungerar då som ">", som beskrivits ovan.

Systemet är mycket flexibelt och sättet att arbeta har stått sig sedan Unix konstruerades på 1970-talet.

Skript
Terminalen används för att köra s.k. skript. I detta sammanhang är ett skript ett (ofta kort) program som använder systemkommandon för att bygga en funktion. Man kan säga att till skillnad från ett "vanligt" program så är ett skript ett program som tolkas av ett annat program (som t.ex. operativsystemet). Skript lagras vanligen i klartext (källkod) och är enkla att bygga och köra. Skript kan vara mycket användbara. (Motsatsen till ett skript kan sägas vara ett kompilerat program. Detta är oftast snabbare, men tar längre tid att konsturera. Här har någon försökt jämföra de skript som skrivs i Linux och Windows.)

Om man sparar kommandon man ofta använder i skript är det lätt att upprepa dessa eller låta någon annan göra det. För att göra ett enkelt skript som beräknar antalet filer i en mapp kan man skapa en textfil, t.ex. med namnet fil_antal . I filen lägger man de kommandon som räknar antalet filer (se stycket ovan - "Pipes"). Filen kan se ut så här:
#!/bin/bash
ls $1 | wc -l
Det programmeringsspråk som oftast används för att konstruera skript kallas Bash.

För att göra skriptet körbart skriver man:
chmod +x fil_antal

$1 anger det första argumentet till skriptet. Argument anges för att kunna skicka data till skriptet. Man skriver argumenten på samma rad som man anropar skriptet. I det första argumentet till detta skript anger man i vilken mapp filerna skall räknas. En användare med namnet kalle har hemmappen /home/kalle . Hemmappen kallas även ~ . Om skriptet ligger på skrivbordet (~/Skrivbord) så kan man starta skriptet genom att helt enkelt skriva skriptets namn i terminalen åtföljt av dess argument (den mapp där filerna skall räknas, i detta fall /home/kalle)
~/Skrivbord/fil_antal /home/kalle
Ett annat sätt att köra skriptet är att först förflytta sig till den mapp där skriptet ligger (med kommandot cd - change directory) och därefter köra skriptet med kommandot ./fil_antal. Vill man veta antalet filer i sin hem-mapp (som t.ex. heter /home/kalle) kan man anropa man skriptet med:
cd ~/Skrivbord
./fil_antal /home/kalle


for-loopar
for-loopar anänds ofta i bash för att bearbeta en grupp filer:
#!/bin/bash
FILES=/path/to/*.txt
for f in $FILES
do
echo "Listar $f "
cat $f
done
Parametrar (argument)
Det går att komma åt de parametrar som anväds för att anropa skriptet som variblerna $1, $2, $3 ...
$@ innehåller samtliga parametrarna. Så här skriver man ut alla parametrarna
echo $@
Man kan lagra samtliga parametrarna i t.ex. arrayen "args" med kommandot
args=("$@")
Sedan skriver man t.ex. ut parametrarna så här
echo ${args[0]} ${args[1]} ${args[2]}
Variabeln $# innehåller ANTALET parametrar till skriptet.

Nautilus-skript
I Ubuntu kan man starta skript från filbläddraren (Nautilus) i den grafiska miljön ("Nautilus scripts", "Gnome scripts"). Skripten arbetar på de filer som markerats. (Man erhåller helt enkelt en lista med namn över de filer som markerats (med musen). Man får listan i variablen $@.) För att kunna återfinna skripten (med högerklick i filbläddraren) skall de ligga i mappen ~.gnome/nautilus-scripts.


Mer om namnbyte av filer och skript

Texten går lite för fort fram här, jag ber om ursäkt för det. Avsikten är bara att visa hur terminalen kan användas. (När jag får tid skall jag göra detta parti tydligare.) Det här stycket försöker förklara lite om hur man bygger upp skript, bl.a. det skript som beskrivs ovan för att byta namn på större mängder filer:

for i in IMG_*; do newname=`echo $i|sed 's/^IMG_/bild_/g'`; mv $i $newname; done

Om man i början försöker konstruera längre uttryck av den här typen "tecken för tecken" blir det lätt fel. Bäst är att försöka dela upp kommandot i delar och testa varje del för sig. Numera hittar man ju många exempel på Internet. Man kan ju söka på t.ex. "shell scripting", "bash scripting guide", "sed tutorial" eller "introduction to regular expressions". Sedan kan man sätta samman allt mer komplicerade uttryck från de exempel man lärt sig förstå. I början är det bättre att att lära sig läsa, förstå och modifiera exempel. Gradvis lär man sig då att konstruera uttryck utan någon förlaga. Här följer några fler exempel på hur man kan byta namn på filer och lite om skript i allmänhet.

Vill man göra sina bilder enklare att sortera kanske man behöver byta namn på filerna:
bild_1, bild_2, ... bild_9, bild_10, ... bild_674
Man skriver då dessa kommandon:
rename bild_ bild_0 bild_?
rename bild_ bild_0 bild_??
Man får då filnamnen:
bild_001, bild_002, ... bild_009, bild_010, ... bild_674.

Vill man ändra ordningen av tecknen i filnamnet kan man använda reguljära uttryck. \1 och \2 syftar på det första respektive andra (o.s.v.) uttrycket som inramas med omvänt snedtecken och parentes, alltså så här: \(det man vill byta plats på\)
(Ett annat användbart tecken i utbytessträngen är &. Det betecknar hela sökmönstret.)
Vill man byta namn (sorteringsordning) på filerna:
001_kalle.jpg 001_lisa.jpg 002_kalle.jpg 002_lisa.jpg
Kan man skriva:
for i in *.jpg; do newname=`echo $i|sed 's/\([0-9]*\)_\([^.]*\)\.jpg/\2_\1.jpg/g'`; mv $i $newname; done
Man får då filerna:
kalle_001.jpg kalle_002.jpg lisa_001.jpg lisa_002.jpg

(\1, \2 etc kan även användas för att finna upprepningar i sökmönstret:
cat tmp01 | sed 's/^\([^ ]*\) \1/upprepning av \1/g'
Kommandot cat används här för att skicka filen tmp01 till sed
cat kan användas för att lista kortare filer. För att lista längre filer kan man använda kommandot more vilket stoppar vid varje skärmsida och väntar på att man skall trycka t.ex. blanksteg eller q (quit).)

Tecknet mellan $i och sed är ett vertikalt streck "|", en s.k. pipe.
echo $i|sed betyder att programmet echo används för att skicka variabeln "i" (det gamla filnamnet) till sed via en pipe. Det långa uttrycket som inleds med 's/ är ett reguljärt uttryck som styr hur sed skall jobba ("ett argument till sed").
sed är ett mycket vanligt textredigeringsprogram som alltså kan användas "off-line" för denna typ av textredigering där kommandon ges via filer (och inte via tangentbordet).

* motsvarar en så lång textsträng som möjligt av den typ som föregår stjärnan
[0-9]* betyder alltså alla på varandra följande siffror.
^ betyder att de följande tecknen INTE får förekomma i strängen. (Detta gäller bara när ^ inleder en grupp tecken inom hakparenteser. Annars motsvarar ^ början på raden.)
[^.]* betyder alltså alla på varandra följande tecken utom en punkt. Uttrycket motsvarar alltså texten fram till det kommer en punkt.
; används för att skilja kommandona åt. (Tecknet ";" gör helt enkelt att man kan skriva flera kommandon på samma rad.)

För att lättare bygga upp dessa uttryck kan man, som nämnts ovan, börja med att titta på uttrycket i sina delar. sed används för att definiera hur utbytet skall ske. sed kan man testa så här:
echo 001_kalle.jpg | sed 's/\([0-9]*\)_kalle/kalle_\1/g'
s/från/till/g
"från" byts mot "till"
På engelska brukar man kalla
från för "search pattern" (vad som skall bytas ut)
samt
till för "replacement string" (vad från skall bytas ut mot)

(Output från kommandot blir: kalle_001.jpg) Kommandot echo används här för att "skicka in" texten kalle_001.jpg i den följande pipen (tecknet "|") som ger texten vidare till sed. Exekverar man bara detta kommando så kommer inga filer att byta namn. Man ser bara vad "kalle_001.jpg" skulle ha ändras till efter det att kommandot körts.

"s" betyder "substitute", dvs att man skall byta ut något.

"g" anger att alla förekomster av "från" byts, inte bara den första på raden.
(Blanda inte ihop detta g med det g som kan inleda kommandon i andra editorer som ex eller vi. Detta senare g som inleder kommandon anger för vilka rader som kommandot skall användas. Vill man ge ett motsvarande "globalt" kommando i sed skriver man istället:
cat nisse | sed '/kalle/d' > pelle
Då tas alla rader där "kalle" förekommer bort ur filen nisse och resultatet läggs i filen pelle. I detta fall tas även rader som innehåller mer text än "kalle" bort. Vill man ta bort rader som enbart består av "kalle" skriver man:
cat nisse | sed '/^kalle$/d' > pelle    )

(Lägger man dessutom till "i" efter det avslutande "g" betyder det att skillnad inte görs mellan stora och små bokstäver i sökmönstret.)

När man tycker detta fungerar tittar man på det omgivande skriptet (for-loopen) och hur det går igenom filnamnen (som slutar på .jpg) i mappen ett efter ett:
for i in *.jpg; do ... ; done

Till sist ser man att skriptet använder kommandot mv för att byta namn på varje fil:
mv $i $newname
(Det nya namn som skapats med sed lagras i variabeln $newname.)

Batchfiler (skript)
I början kan det vara bra att införa ytterligare mellansteg för att i detalj se vad kommandona gör. Man kan då lagra en fillista i en fil:
ls > tmp
Sedan använder man t.ex. sed för att göra om fillistan till en kommandofil. Första steget kan t.ex. vara att lägga till mv i början av varje rad. Det kan man göra så här med sed:
sed -e 's/^/mv /' tmp > tmp2
^ betyder i detta fall början på raden. (När ^ däremot inleder en grupp tecken inom hakparentes är ^ ett negationstecken. Slutet på raden betecknas med "$".) Man "byter" rad-början mot "mv" vilket i praktiken betyder att man lägger till "mv " i början av raden. Filen tmp ändras inte utan man skickar output till filen tmp2 istället. (Skulle man tabba sig har man ju filen tmp kvar, oförändrad.) När man är klar med fillistan kan den se ut så här
mv 001_kalle.jpg kalle_001.jpg
mv 001_lisa.jpg lisa_001.jpg
mv 002_kalle.jpg kalle_002.jpg
mv 002_lisa.jpg lisa_002.jpg
Då kan man i detalj se vad kommandona gör. När man är nöjd med resultatet kör man fillistan som ett skript (s.k. kommandofil eller batchfil).

Citationstecken
Om man regelbundet skriver skript lär man sig skilja på de tre typerna av citationstecken:
fillista=`ls`
gör att output från kommandot ls lagras i variabeln fillista. (ls är det kommando som används för att lista filer.)

En variabel anropas genom att sätta tecknet "$" framför. Om en sådan variabel anropas inom dubbla ciationstecken kommer dess värde att användas. Kommandot
echo "$fillista"
kommer att visa den fillista som lagrades i variabeln.
I detta fall hade det gått lika bra att skriva
echo $fillista
Med citationstecken kan man emellertid förena text-strängar åtskilda av blanka och variabler till en sträng. För att kunna lagra hela denna sträng i varibeln text_01 måste man använda dubbla citationstecken.
text_01="Här är min fillista: $fillista"
echo $text_01
Man får utskriften:
Här är min fillista: Fil1 Fil2 Fil3

Nya rader betecknas vanligen med \n. För att få echo-kommandot att tolka det omvända snedtecknet ger man tillägskommandot (optionen, switchen) -e:
text_01="Här är min fillista:\n$fillista"
echo -e $text_01
Man får utskriften:
Här är min fillista:
Fil1 Fil2 Fil3

Det enkla ciationstecknet används när man inte vill utvärdera en variabels namn utan bara skriva ut t.ex. ett dollartecken.
'$fillista'
kommer helt enkelt att skriva ut $fillista. Enkla ciationstecken används därför om man t.ex. vill skriva att 'Datorn kostar $500.' Om man inte använder enkla ciationstecken så kommer $500 att tolkas som en variabel (med namnet 500).

Ett annat sätt att ange att specialtecken inte skall tolkas utan bara återges är att föregå dem med ett omvänt snedtecken "\". Observera dock att när man använder reguljära uttryck kan man inte infoga omvända snedtecken, "för säkerhets skull", framför vilket tecken som helst. Uttrycket kan då ändra betydelse. Vill man att ett specialtecken skall användas som ett vanligt tecken skriver man en \ före tecknet, inte annars. Det finns 11 specialtecken i regular expressions: [\^$.|?*+()
För att finna uttrycket 1+3 söker man alltså på 1\+3
Om de strängar man arbetar med tolkas i flera steg kan man behöva fylla på med fler citationstecken. Använder man sed via programmeringsspråket PHP ("preg_replace") är man tvungen att skriva \\\ för att finna \ i ursprungssträngen.
Ibland kan det vara svårt att på förhand veta vilka tecken som skall citeras. Man skall då inte försöka bygga upp något längre uttryck direkt. Istället gör man några testkörningar på de komponenter man ämnar använda i det färdiga uttrycket. Först kanske man testar hur omvända snedtecken skall representeras: Om följande uttryck byter "\" mot "Omvänt snedtecken" så vet man att "\" representeras med "\\\" i söksträngen
s/\\\/Omvänt snedtecken/g


Om man skriver
fillista=ls
så har man lagt tecknen ls i variablen fillista. Om man skriver $fillista så får man då en listning av den mapp man befinner sig i. Man kan säga att man skapat ett alias för kommandot ls. (Detta är alltså annorlunda än det längre upp beskrivna kommandot fillista=`ls`. fillista=`ls` lagrar en fillista i variabeln. Varibeln kommer då inte att förändras beroende på i vilken mapp man befinner sig. Den visar alltid den fillista man lade in från början.)

Vill man bespara sig obehagliga överraskningar skall man även skilja mellan textsträngar och numeriska variabler. Man erhåller det numeriska värdet av en text- ("sträng-") variabel (innehållande siffror) genom kommandot "let":
$ a=13
$ b=48
$ c=$a+$b
$ echo $c
13+48
$ let cn=$a+$b
$ echo $cn
61
(Det dollartecken som inleder raden visas där man skriver input. Övriga rader är output från systemet.)

De flesta s.k. skriptspråk är uppbyggda på ett liknande sätt. Speciellt noggrann skall man vara i JavaScript där man kan addera både strängar och nummer med operatorn "+".

Om man inte är van vid dessa problemställningar kan de kanske verka som en tvist om påvens skägg. Det blir emellertid betydligt färre fel när man skriver skript om man tänkt sig in lite i grunderna hur text och nummer lagras.

Sammanfattande tips: Håll reda på om det uttryck du arbetar med är ett tal eller en textsträng. Talet 37 och textsträngen "37" behandlas helt olika. (Exempel från JavaScript: 37+14=51, "37"+"14"="3714")

Här är ytterligare några exempel på hur man räknar i terminalen ("bash shell arithmetic").
$ expr 1 + 1
2
# när man använder expr måste * föregås av \
$ expr 3 \* 5
15
$ echo 'scale=2; 3*(2+7) / 5' | bc
5.40
$ a=`echo 'scale=2; 3*(2+7) / 5' | bc`
$ echo $a
5.40
$ echo $(( 142/(3+7) ))
14
bc kan användas för flyttalsberäkningar (beräkningar med decimaler), scale anger alltså antalet decimaler för programmet bc.

Så här kan man skapa en serie tal.
count=0
while [ $count -lt 10 ]; do
echo $count
count=`expr $count + 1`
done


Ibland kan man behöva addera filer kolumnvis:
paste ett två > tre
Kommandot paste får fil ett och fil två att läggas i fil tre bredvid varandra, "i två kolumner". (För att på motsvarande sätt klippa ut en kolumn ur en fil kan man använda awk eller cut.)

Kommandot tr kan ofta vara användbart när man arbetar med strängar. tr kan t.ex. användas för att konvertera mellan stora och små bokstäver eller ta bort oskrivbara tecken (kontrolltecken eller s.k. "slasktecken").

Cron

För att köra kommandon på regelbundna tider använder man cron. Med kommandot "crontab -e" kan man skapa poster som anger vilken tid ett visst kommando skall köras. Man skriver en post på varje rad. # anger kommentar. De fem första talen på raden anger när jobbet skall köras (min, hour, date, month, weekday), därefter anges kommandot. En stjärna anger att jobbet skall köras varje tidsenhet (t.ex. minut, timme eller dag). /10 betyder var tionde (t.ex. minut eller timme). För att inte erhålla notifieringar per epost anger man följande sist på raden: >/dev/null 2>&1
# run myScript every Sunday morning at 3:07 AM
07 03 * * sun /home/joe/script/myScript.sh
# run myScript every five minutes; no email notifications
*/5 * * * * /home/joe/script/myScript.sh >/dev/null 2>&1
Vill man bara fördröja ett jobb använder man kommandot at.

Mer om sed

Kommandon till sed kan delas upp i två delar:
 1. Adressen, dvs vilka rader som påverkas av kommandot.
 2. Det egentliga kommandot.
"5,10d" betyder att raderna 5-10 kommer att tas bort (d=delete)
"8d" betyder att rad 8 kommer att tas bort (d=delete)
"/pelle/d" alla rader som innehåller "pelle" kommer att tas bort (d=delete)
"/pelle/!d" alla rader som inte innehåller "pelle" kommer att tas bort (d=delete)
"/pelle/,/kalle/d" alla rader f.o.m. en rad med "pelle" t.o.m. en rad med "kalle" kommer att tas bort (d=delete)
Om ingen adress ges kommer alla rader i filen att pvåerkas av kommandot:
"s/kalle/nisse/" (s=substitute)

Här följer några exempel på hur sed kan användas.
; kan användas för att utföra fler kommandon i samma anrop
cat tbd | sed 's/vera/Vera/ ; s/pelle/Pelle/' > tbd2

Varning! Använd inte samma filnamn för infil och utfil i kommandot cat. Resultatet kan bli oväntat.

Glesa ut filen så var annan rad blir tom:
cat tbd | sed 's/$/\n/' > tbd2

Ta bort alla tomma rader:
cat tbd | sed '/^$/d' > tbd2

Sammanfoga var annan rad med nästa:
cat tbd | sed '$!N;s/\n/ /' > tbd2
Samma resultat fast med kommandot paste:
paste -s -d" \n" tbd > tbd2; cat tbd2

Sammanfoga rad 6 med rad 5:
cat tbd | sed '$!N;6s/\n/ /' > tbd2

I vissa system kan det vara knepigt att sammanfoga rader med sed. Man kan då först markera vilka radbrytningar (nyrad-tecken) man vill behålla med en kod. Därefter tar man bort ALLA radbrytningar. Till sist byter man ut sin kod mot "äkta" radbrytningar. (Man kan ju också använda kontrolltecken, vilka då inte får finnas i filen, som kod, t.ex. \x0)
sed '15,33s/$/min_Radslutskod/' tbd > tbd2
cat tbd2 | tr '\n\' ' ' > tbd3
sed 's/min_Radslutskod/\n/' tbd3 > tbd4

Man kan också använda perl för att ta bort nyrad-tecknet
cat tbd | perl -pe 's/\n//g' > tbd2

Ta bort rader:
cat tbd | sed '5,10d' > tbd2

Läs in en fil (med namnet "ins") vid rad 6:
cat tbd | sed '6r ins' > tbd2

Lägg till (a=append) några rader efter 6:
cat tbd | sed '6a\
> Denna rad kommer att infogas i filen\
> Likaså denna.' > tbd2
(Det omvända snedtecknet måste alltså användas innan man trycker enter/vagnretur.)
Om man ofta tillfogar rader brukar man använda sed från en kommandofil:
sed -f tbd_batch.sed tbd > tbd2
tbd_batch.sed:
{
s/pelle/nisse/g;
s/vera/olga/g;
}


Skriv ut alla rader som innehåller strängen "kalle" till filen tbd2:
cat tbd | sed -n '/kalle/w tbd2'
Detta liknar alltså det resultat man kan erhålla med kommandot "grep". Man kan även göra så här:
cat tbd | sed -n -e '/kalle/{p;}' > tbd2

Så här skriver man ut alla rader som innehåller "kalle" samt den efterföljande raden:
cat tbd | sed -n -e '/kalle/{N;p;}' > tbd2
Här skrivs både den föregående och den efterföljande raden ut:
cat tbd | sed -n -e '/kalle/{x;1!p;g;$!N;p;D;}' -e h > tbd2
Lite grovt kan man beskriva kommandot så här. sed läser filen rad för rad. Kommandot h sparar den senaste raden. När man träffar på "kalle" så skrivs först den sparade raden ut (första kommandot p). Sedan läggs nästa rad till den rad man står på dvs raden med "kalle" (kommandot N). Till sist skrivs denna "kombinerade" rad ut (den rad som funnit "kalle" samt nästa rad; andra kommandot p).

Att arbeta över flera rader kan alltså vara lite krångligt i sed. En metod att slippa detta kan vara att markera alla radbrytningar med en eget uppfunnen kod som ju inte får förekomma i filens innehåll (i detta fall: _NY\x0RAD_):
cat tbd | sed 's/$/_NY\x0RAD_/' > tbd2
därefter ta bort alla "äkta" radbrytningar med tr.
cat tbd2 | tr -d '\n' > tbd3
Man har nu hela filen på en rad och kan göra de flerradsoperationer man behöver. Till sist lägger man tillbaka de "äkta" radbrytningarna.
cat tbd3 | sed 's/_NY\x0RAD_/\n/g' > tbd4

Linknande listningar kan ofta åstadkommas enkelt med grep. Vill man lista raderna där strängen återfunnits tillsammans med de tre föregående och två följande raderna skriver man.
grep -B 3 -A 2 kalle tbd


För att få inspiration till hur man använder sed, sök t.ex. på sed one-liners

Ref: [1, 2].

Med skript, sed och reguljära uttryck brukar man klara de flesta textredigeringsproblem. Om man väljer att lära sig andra metoder beror nog valet lite på hur man tycker om att arbeta. Makron i grafiska editorer (i kombination med reguljära uttryck) är ofta förhållandevis säkra och överskådliga. AWK och Perl ger tillgång till mer avancerade textbearbetningsfuktioner. Använder man inte dessa språk ofta så kan det dock ta lite tid att ta fram rätt uttryck. Ett enkelt och säkert sätt att bearbeta en text kan ju ofta vara att använda det programmeringsspråk man för tillfället arbetar med. Man läser helt enkelt in texten och genomför de nödvändiga ändringarna. De flesta programmeringsspråk har dessutom strängbearbetningsfunktioner. C och PHP har t.ex. mycket bra stränghantering.

Hur man lagrar data

Traditionellt lagrar man serier av data i filer. Man skriver en fil med data i rader och kolumner. Man separerar data med t.ex. något av tecknen komma, semikolon, blank eller tab. De flesta programmeringsspråk innehåller funktioner som hjälper till att läsa denna slags filer. I programmeringsspråket C finns t.ex. scanf, denna funktion motsvaras i PHP av sscanf/fscanf. (Använder man istället rena shellscript (bash) för att arbeta med tabeller kan det ibland bli lite krångligt. Man kan använda t.ex. cut eller awk. Ofta går det dock ganska snabbt att surfa fram en lösning via en sökmotor.) För att minska lagringsutrymme och finna data snabbare brukar man göra om dessa (ascii-)filer till binärfiler.

Numera används dock ofta färdigutvecklade databaser. (I grunden lagras naturligtvis data även här som filer, men man kommer åt dem genom anrop till databas-servern.) MySQL är en populär databas med stor internationell spridning. Den har utvecklats av ett Uppsala­företag och är konstruerad i öppen källkod. I MySQL kan stora mängder data bearbetas snabbt och lagras på förhållandevis litet utrymme. Flera skriptspråk kan anropa MySQL databaser. Speciellt enkelt och funktionellt blir det i PHP, det är i alla fall min uppfattning.

Man når databasen via en databasserver. (Data går alltså lätt att nå över Internet.) Man kan kontakta databasservern via t.ex. terminalen (kommandot mysql) eller via phpMyAdmin. phpMyAdmin är ett webinterface som gör att det gå enkelt att lista och editera data.

Här är ett exempel hur man kan skapa och editera en MySQL databas genom PHP. (kanin, morot, tomat är exempel på användarnamn, lösenord och databas-namn)
$con = mysql_connect("gronsakslandet.net","kanin","morot");
mysql_select_db("tomat", $con);
	
/* skapa tabell */
$qs = "
CREATE TABLE IF NOT EXISTS snurre(
name VARCHAR(50),
title VARCHAR(20),
age INT(3),
salary INT(6)
)
;";
mysql_query($qs) or die(mysql_error());

/* lägg in de anställda som poster i tabellen */
$name = 'anna'; $title='försaljare'; $age=35; $salary=40000;
$qs ="
INSERT INTO snurre
(name, title, age, salary)
VALUES('$name', '$title', $age, $salary) 
;";
mysql_query($qs) or die(mysql_error());

$name = 'bertil'; $title='utvecklare'; $age=38; $salary=40000;
$qs ="
INSERT INTO snurre
(name, title, age, salary)
VALUES('$name', '$title', $age, $salary) 
;";
mysql_query($qs) or die(mysql_error());

$name = 'cissi'; $title='utvecklare'; $age=55; $salary=40000;
$qs ="
INSERT INTO snurre
(name, title, age, salary)
VALUES('$name', '$title', $age, $salary) 
;";
mysql_query($qs) or die(mysql_error());

$name = 'david'; $title='försaljare'; $age=25; $salary=40000;
$qs ="
INSERT INTO snurre
(name, title, age, salary)
VALUES('$name', '$title', $age, $salary) 
;";
mysql_query($qs) or die(mysql_error());

$name = 'eva'; $title='utvecklare'; $age=28; $salary=40000;
$qs ="
INSERT INTO snurre
(name, title, age, salary)
VALUES('$name', '$title', $age, $salary) 
;";
mysql_query($qs) or die(mysql_error());

/* en anställd slutar */
mysql_query("DELETE FROM snurre WHERE name='anna';")
or die(mysql_error()); 

/* en anställd byter befattning */
mysql_query("UPDATE snurre SET title='systemerare' WHERE name='bertil';")
or die(mysql_error());

/* ge utvecklarna löneförhöjning */
mysql_query("UPDATE snurre SET salary=42000 WHERE title='utvecklare';")
or die(mysql_error());

/* beräkna totala lönekostnaderna */
$rs = mysql_query("SELECT * , SUM(salary) AS wagecosts FROM snurre;")
or die(mysql_error());
$row = mysql_fetch_array($rs);
echo 'lönekostnader: ' . $row['wagecosts'] . "<br>\r\n";

/* gör en lista */
$qs = "SELECT *
FROM snurre
";
$rs = mysql_query($qs);
echo "<table>";
echo "\r\n";
while( $row = mysql_fetch_array($rs) ){
	echo "<tr>";
	echo "<td>";
	echo $row['name'];
	echo "<td>";
	echo $row['title'];
	echo "<td>";
	echo $row['age'];
	echo "<td>";
	echo $row['salary'];
	echo "\r\n";
}
echo "</table>";

mysql_close($con);


- - -
Utskrift av skriptet:

lönekostnader: 164000
bertilsystemerare3840000
cissiutvecklare5542000
davidförsaljare2540000
evautvecklare2842000
PHP och MySQL innehåller en mycket stor mängd funktioner. Det går oftast att finna rationella lösningar på nästan alla "tänkbara" problem.

Det är en stor fördel att databasen kontrolleras genom dessa frågor (s.k. queries, textsträngarna $qs i exemplet ovan). Detta gör att flera användare kan använda databasen samtidigt.